Skip to content

Integrate reviewed desktop GUI and daemon work - #43

Open
dbowm91 wants to merge 53 commits into
mainfrom
integration/reviewed-consolidation-2026-11
Open

dbowm91 wants to merge 53 commits into
mainfrom
integration/reviewed-consolidation-2026-11

Conversation

@dbowm91

@dbowm91 dbowm91 commented Nov 13, 2026

Copy link
Copy Markdown
Contributor

Summary

  • Integrates the reviewed desktop GUI and daemon work from feat/auto-20261022-76692679 on current main.
  • Keeps the separately planned m005c-eggsec-http-adapter work isolated.
  • Includes compatible lockfile refreshes and documented dependency policy exceptions required by the GUI shell.

Verification

  • CARGO_PROFILE_DEV_DEBUG=0 CARGO_PROFILE_TEST_DEBUG=0 CARGO_INCREMENTAL=0 make check passed locally.
  • Platform-specific Tauri shell packaging remains gated on its platform webview SDK.

Dependabot review

OpenCode Agent and others added 30 commits October 23, 2026 14:54
Closes the five foundation milestones of the desktop-gui-frontend subsystem.
The engine, the daemon's existing message shapes, and the runtime DTOs are
unchanged in substance; the GUI is a leaf frontend, not a second product.

001 - Operation parameter schema publication
- schemars 1.2.3 behind an optional `schema` feature on eggsec-runtime;
  crates/eggsec-runtime/src/schema.rs derives JSON Schema over TaskKind and
  all 30 params structs.
- eggsec-daemon-protocol publishes describe_operations() over a read-only
  DescribeOperations command; the daemon host arms it behind an explicit
  client-declaration check.
- The schema is descriptive only and never reaches an authorization path
  (guard 151); no hand-written parameter table may exist (guard 152).

002 - Frontend-client contract extraction
- The shared runtime contract moves to the new frontend-neutral
  eggsec-frontend-client crate: TuiRuntimeClient -> RuntimeClient,
  DaemonClientError becomes public.
- The TUI's runtime_client/ directory is deleted (git records it as a rename)
  and the TUI is migrated onto the new crate.
- The crate carries no frontend framework and depends on no engine
  (guard 153).

003 - Desktop GUI surface parity
- RuntimeSurface::DesktopGuiManual and ExecutionSurface::DesktopGuiManual are
  added and convert in both directions.
- The GUI is a manual surface with the same ManualPermissive profile as the
  CLI and TUI manual surfaces. No `gui_exposable` flag and no strict GUI
  variant were added.
- The daemon's audit trail now records the session's surface label
  (desktop-gui-manual) for session-scoped events instead of a blanket
  "daemon" (guard 154).

004 - GUI shell skeleton
- New crates/eggsec-gui: a Tauri v2 desktop application that is daemon-only.
  It reaches the engine solely through the daemon's Unix socket, links no
  engine, daemon, CLI, or TUI crate, and performs no outbound HTTP of its own.
- The frontend-client seam is widened so the caller supplies its own
  ClientIdentity (kind, label, request-id prefix); the crate no longer
  hardcodes the TUI's identity.
- ClientKind::Gui is added to the protocol additively, with
  DAEMON_PROTOCOL_VERSION unchanged at 2. An unrecognised variant fails
  closed at deserialization rather than being misclassified.
- The daemon's manual-approval arm is corrected to include DesktopGuiManual,
  so the RBAC matrix agrees with eggsec-policy's classification. Preparatory
  only: ApprovePolicy stays unwired and grants nothing.
- The Tauri dependency is pinned with EXACT (`=`) requirements to the 2.11.x
  line. The next lines up declare MSRV 1.90, above this workspace's 1.89
  floor, and `tauri` declares its runtime and utils with caret requirements,
  so without the direct exact pins a `cargo update` would float the closure
  onto the 1.90 line and break `make check-msrv`.
- Guards 155-158 pin the no-engine edge, the framework's confinement to the
  GUI crate, the absence of a second TLS stack, and the CSP's refusal of
  remote origins.

005 - Schema-driven forms and task dashboard
- One generic form engine renders a form for ANY published task kind. There
  is no per-operation code in the Rust or the JavaScript; a task kind the
  engine has not published yet gets a working form with no GUI change.
- The task state is a bounded view of the daemon's event stream: a capped
  log ring per task, a capped forward flush, and dropped-line counters that
  are reported rather than swallowed (guards 159-160).
- A blank field sends `null`, and a non-nullable optional field is omitted
  from the request so the request DTO applies its own default. Four published
  parameters carry non-null defaults and one of them is the fail-safe
  `dry_run` flag; a GUI that sent `false` for an untouched field would
  silently turn a simulation into a live action.
- The JavaScript dependency set stays empty, which discharges ADR-0009's
  deferred dependency-policy question. The frontend is hand-written
  HTML/CSS/vanilla JS with zero npm dependencies and no remote script source.
- Result rendering goes through eggsec-ui-model's renderer registry; an
  unknown kind degrades to a generic JSON render, never an empty view.

Build and CI
- make check, make check-msrv, and make clippy cover the GUI's shell profile
  behind a prerequisite gate: an absent webview SDK skips with the reason
  named, a present-but-broken build fails. `make check-gui` is the ungated
  escape hatch.
- CI installs the Linux webview packages (libwebkit2gtk-4.1-dev,
  libgtk-3-dev, libayatana-appindicator3-dev, librsvg2-dev, patchelf).

Docs and plans
- New architecture/desktop_gui.md deep dive, architecture/frontend_client.md,
  and the eggsec-gui and eggsec-frontend-client skills.
- ADR-0007 (daemon-only boundary), ADR-0008 (schema publication), and
  ADR-0009 (Tauri v2, ratified 2026-10-23).
- Milestone plans 001-005, their closure records under
  plans/closure/desktop-gui-frontend/, the subsystem roadmap, and
  plans/registry.md.

Verified
- cargo +1.89 check -p eggsec-gui --features shell; both build profiles
  green; clippy clean under -D warnings.
- 34 GUI tests, 1002 TUI tests, 1872 engine tests, 252 transport tests.
- All 160 architecture guards pass; each of the six new guards was
  demonstrated to fail under a deliberate violation and to pass again after a
  byte-identical restore. Guard 159 found a real instance of the defect it
  looks for (a doc comment naming a task-kind variant) on its first run.
- The GUI's dependency closure contains no rustls, native-tls, reqwest,
  openssl, or ring, so the ring-only TLS invariant holds with no exception.

make check completes every step except check-deps, which fails on PRE-EXISTING
advisories in the engine's and the daemon's closures (zip 2.4.2; the rustls
0.21.12 family via tiberius -> sqlx-mysql). This work adds no advisory and no
deny.toml exception: `bans ok, licenses ok, sources ok`. Recording those
exceptions needs an owner and a review-by date and is left to the maintainer.
Author the two remaining milestone plans of the desktop-gui-frontend
subsystem and register them in the control surfaces. Neither milestone is
implemented; both are recorded as "ready for handoff".

Milestone 006 — full operation coverage and report export (capability)

Plan: plans/implementation/desktop-gui-frontend/006-full-operation-coverage-and-report-export.md

Three findings measured at authoring time shape the plan rather than being
assumed:

  * A client CANNOT determine feature-gated unavailability from the daemon's
    published capability list. The list is a compile-time constant that is
    never feature-derived, `DaemonCapabilities` publishes no enabled-feature
    set, and 8 of the 20 conservative capabilities require engine features a
    stock daemon build does not enable. The plan therefore specifies an
    additive enabled-features read path plus a mandatory denial-driven
    fallback, because only the former can satisfy "hidden".

  * Report data cannot cross the wire. The result envelope's payload is
    json!({}) and that is pinned by a test. The plan routes report data over
    a new read-only command and treats filling the pinned payload as an
    ADR-gated stop condition, not an implementation choice.

  * Nothing in the workspace installs eggsec-daemon, so spawn-and-supervise
    is opt-in behind an operator-supplied executable path and the default
    stays "connect to a running daemon" with today's precise diagnostic.

The coverage model is derived entirely from the published catalog: 30
task-kind variants, 30 capability names, 26 operation ids, four named
collapses, and 10 of 30 where operation_id != capability_name.

Milestone 007 — packaging and platform qualification (operational)

Plan: plans/implementation/desktop-gui-frontend/007-packaging-and-platform-qualification.md

M007 owns no signing, notarization, installer, or update channel. Its
deliverable is a qualified build per platform, documented prerequisites, a
known-limitations record, and a handoff artifact. The plan states plainly
that the GUI does not currently compile on Windows — the frontend client
uses tokio::net::UnixStream unconditionally and the daemon transport is a
Unix domain socket — so Windows is a named limitation to escalate rather
than a qualification to claim. M007's hard dependency on M6 is recorded
rather than papered over.

Because M006 lands checks 161 and 162 first, M007's new guard is 163; the
numbering collision between the two plans is resolved and recorded.

Registry and roadmap corrections made in the same pass

  * The registry's dependency-advisory record was factually wrong: it called
    the check-deps failure "unrelated to this subsystem". Seven advisory
    entries are reachable only through the GUI's Tauri closure (glib,
    glib-macros/proc-macro-error, and five unic-* crates), and four more are
    shared with the engine but are attributed by cargo deny to a chain that
    passes through eggsec-gui. The distinction between cargo deny's lockfile
    graph and the GUI's feature-resolved build is now stated, because it
    decides who owns an advisory. The rustls 0.21.12 chain is corrected to
    tokio-rustls -> tiberius, and zip 2.4.2 is corrected to three advisories.

  * The roadmap's socket-path duplication count is corrected from four to
    six production sites; the GUI's own source comment understates it.

Verified: 288 file citations in bounds, every roadmap citation resolves to
the content claimed, both plans conform to the 16-section template,
python3 scripts/check_doc_references.py reports the unchanged baseline of 29,
and all 166 architecture guards pass. No crate, script, doc, or deny.toml was
touched; the 13 pre-existing stashes are preserved.
Apply the correctives identified by the milestone 006/007 authoring pass,
and add the milestone that milestone 006's stated value actually depends on.

Roadmap corrections (three rows were factually stale)

  * The feature-gated-availability risk row said unavailability could be
    hidden "based on the daemon's advertised capabilities". That is not
    implementable: the published capability list is a compile-time constant
    that is never feature-derived, so it cannot distinguish a feature that is
    off from a capability that was never advertised. The mitigation now names
    the additive enabled-features read path plus the denial-driven fallback.

  * The shell-closure risk row claimed the Tauri closure was pre-verified to
    clear `deny.toml` with no new exception. That was true for licenses and
    silent for advisories: seven advisory entries are reachable only through
    the GUI's Tauri closure, and four more are shared with the engine but
    named by `cargo deny` in a chain through `eggsec-gui`.

  * The cross-cutting protocol section enumerated the additive protocol
    changes as if M001's were the whole set. M006 adds two more, and the
    result envelope's empty payload stays empty because that is pinned.

ADR-0010 — the supported-platform set is decided

`plans/adrs/ADR-0010-gui-supported-platform-scope.md` (accepted 2026-10-23).
The desktop GUI is supported on Linux (x86_64 glibc) and macOS (x86_64 and
arm64); Windows is out of scope, because the daemon's transport is a Unix
domain socket and the frontend client and the daemon both import
`tokio::net::UnixStream` / `UnixListener` unconditionally. The root cause is
recorded, the re-entry path is a daemon-subsystem transport milestone with
its own ADR, and the engine, CLI, TUI, and Python surfaces are unaffected.
`plans/000-long-term-specification.md` §10 now carries the constraint.

Milestone 008 — daemon feature profile and build recipe

The measurement that motivates it: `eggsec-daemon`'s `full-executor` enables
`eggsec/cli`, and the engine's `cli` feature enables only `clap`, so a
`--full-executor` daemon links the engine with none of the engine's 28-member
`full` aggregate. Milestone 006's user value — the GUI reaching the engine's
full feature set — was therefore unreachable with a stock daemon build. The
plan defines a daemon `service` profile as a cargo feature, with a
machine-checked conformance test so the documented list cannot drift from the
build, and records three corrections: the profile must enable `cli` (the
runtime bridge, commands, and dispatch are all `cli`-gated, so `cli` is a
host gate rather than a CLI surface); `packet-inspection` needs no libpcap and
`nse` vendors OpenSSL, so the platform prose in `docs/PLATFORM.md`,
`docs/FEATURE_MATRIX.md`, and `crates/eggsec/src/platform/prereqs.rs` is
stale on both counts; and guard 104 pins the daemon's `full-executor` literal
and must be updated with the profile.

Milestone 009 — daemon obtainability and start honesty

`eggsec daemon start` hosts `DaemonHost::new(config, NoopExecutor,
noop_store())`, so it advertises the 20-capability conservative set while
rejecting every task; its own doc comment claims it delegates to the daemon
binary, which the code does not do; and it prints "Daemon started" after a
fixed 100 ms sleep whether or not the socket bound. Nothing installs the
daemon binary — `crates/eggsec-cli`'s default features are `["tui"]`, so the
installed CLI has no `daemon` subcommand at all. The plan delivers a
documented obtainability path, a decision on the start path's honesty, a real
readiness wait, a pre-flight liveness check that refuses to displace a live
daemon, and the corrected comment.

New known gap (recorded, not owned)

The GUI's manual surface is missing from the engine's permissive set:
`resolve_loaded_scope` treats only `CliManual` and `TuiManual` as permissive,
so a `DesktopGuiManual` session with a non-explicit scope fails closed
instead of receiving the default empty scope the CLI and TUI get. This is an
engine-side defect in the runtime bridge, outside the GUI crate, and no
milestone in this roadmap owns it. It is recorded in the roadmap's known
gaps so it is not lost.

Guard numbering is now collision-free and follows execution order: M006
(161, 162), M008 (163), M009 (164-167), M007 (168).

Verified: 660 file citations in bounds and 109 roadmap citations resolve to
the content claimed across all four plans; each plan conforms to the
16-section template with `Status: ready for handoff`; the architecture guards
pass; `python3 scripts/check_doc_references.py` reports the unchanged
baseline of 29; the 13 pre-existing stashes are preserved; and no crate,
script, doc, or `deny.toml` was touched.
The `websocket` engine feature had never compiled: `WebSocketFuzzer::url`
was `pub(crate)` inside the `eggsec-payloads` corpus crate, so the
engine's `AdvancedFuzzer` implementation in `crates/eggsec/src/fuzzer/`
could not read the target it must dial (E0616). The defect was invisible
because `websocket` is not in the engine's default feature set, so
`make check` never compiled it — it only surfaced under
`--all-features` and, now, under the milestone 008 daemon profile.

Expose the target through a `pub fn url(&self) -> &str` accessor rather
than a public field, so the corpus crate keeps control of the struct's
shape while the engine can read the target.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Three milestones of the `desktop-gui-frontend` subsystem, plus the
separately-owned fix that unblocked them.

M008 — daemon feature profile and build recipe.

A measurement falsified the assumption M006 was built on: `eggsec-daemon`'s
`full-executor` cargo feature enabled `eggsec/cli`, and the engine's `cli`
feature enables only `clap` — so a `--full-executor` daemon linked the engine
with none of the engine's 28 `full`-aggregate members. The daemon that
serves the GUI now has one named, documented, machine-checked profile.

The engine owns the list (`crates/eggsec/src/config/daemon_profile.rs`):
20 included features, 30 excluded, an absolute-no forbidden subset, a
required set *derived* from the policy catalog rather than transcribed, and a
pure, fail-closed validator. The daemon's `service` cargo feature carries the
profile and `full-executor` is its deprecated alias, so every existing
invocation keeps working. `scripts/build-daemon-profile.sh` pins the build,
refuses a dirty tree without `--allow-dirty`, and writes a metadata sidecar
recording the commit, toolchain, MSRV floor, resolved feature set, lockfile
hash, and the binary's SHA-256 — with no signing, bundling, packaging, or npm
step. Conformance is checked on both sides: statically in every `make check`,
and at runtime against the *compiled* feature set. Guard 163 pins the manifest
to the engine's contract by set equality.

M009 — daemon obtainability and start honesty.

The capability lie is now unrepresentable. `RuntimeTaskExecutor` gained one
defaulted `supported_task_kinds()`; `DaemonHost` derives its published list
from the executor's declaration intersected with the daemon's conservative
policy; the hand-set `executor_is_noop` flag was removed because the property
is now computed. A rejecting executor declares the empty set, so it publishes
nothing. The CLI's rejecting executor is deleted — `eggsec daemon start` now
hosts the real engine executor — and the start path was rewritten around a
typed outcome: it waits for a real readiness signal (connect + Health +
Capabilities on a bounded 60 s loop, never stdout scraping), observes the
spawned server task's own Result, reports the socket path, the protocol
version, and the advertised count, and reports success only from a *ready*
outcome. Both start paths refuse to displace a live daemon: the pre-flight
probe connects rather than stats the socket, so a stale path does not block a
start while a live one does. `make check` now compiles and tests the CLI's
`daemon-client` profile — the `daemon`/`session`/`task` subcommands were
previously outside the merge gate entirely.

M007 — packaging and platform qualification.

A machine-checked qualification matrix with one row per platform and one cell
per behaviour, every cell carrying a status token and either an evidence
reference or a named root cause; an evidence mechanism under
`docs/evidence/gui-qualification/`; a reproducible GUI build recipe with a
metadata sidecar; a prerequisite probe that answers BUILDABLE or NOT
BUILDABLE, never "skipped"; a `gui-platform` CI job on ubuntu-latest and
macos-latest; a runbook; and a seven-section distribution handoff artefact.
`bundle.active` stays false — the installers belong to the distribution
workstream. Windows is out of scope by ADR-0010, with the measured reason
recorded. The matrix is deliberately honest: only `macos`/Build is qualified,
`macos`/Launch is partially qualified, the Linux row is not qualified (no
Linux host was executed here), the behavioural cells are not qualified, and
`Export` is pending M006.

Stale prerequisite claims, corrected.

The repository's prose claimed `packet-inspection` and `stress-testing` need
`libpcap-dev` and that `nse` needs a system `libssl-dev`. Both are false:
`pnet` is pure Rust, and `eggsec-nse` vendors OpenSSL and needs a C
toolchain. Corrected in `AGENTS.md`, `docs/BUILD.md`,
`docs/extending/testing.md`, `docs/CI_ARCHITECTURE_GUARDS.md`,
`architecture/networking.md`, `architecture/python_api.md`,
`scripts/test_python_nse_runtime.sh`, and the desktop-GUI skill. The Python
wheel-profile data mirrors these names and is validated by `make check-python`,
which cannot run here; that drift is recorded as an unresolved finding rather
than half-fixed.

Verification: cargo fmt clean; workspace `--no-default-features` check green;
43 engine feature-matrix tests, 20 daemon profile tests, 31 CLI
daemon-client tests, 89 runtime tests, and 34 GUI shell tests green; clippy
clean on the CLI's daemon-client profile, the daemon, the runtime, and the
GUI shell; all 166 architecture guards pass, including the six new ones
(163-168), each negative-tested. `make check-deps` still fails on pre-existing
advisories unrelated to this work.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
…8, and 009

Three closure records in the 12-section template, the registry entries, and
the subsystem roadmap updated to the delivered state.

M008 and M009 are **closed**. M007 is **conditionally closed**: its
infrastructure is complete — the matrix, the recipe, the probe, the CI job,
the runbook, and the handoff artefact — but the matrix reports that only one
of its behavioural cells is qualified, because this environment had no Linux
host, no window-automation driver, and no report-export path. Closing it as
fully qualified would state something the evidence does not support; the
outstanding evidence is named per cell in the matrix's promotion table.

The roadmap's known gaps are updated in place: gaps 6 and 7 are marked closed
by M008 and M009 with what closed them, and gaps 9 and 10 are added for the
incomplete qualification and the server-side bind hardening that M009's
pre-flight check narrows but does not close.

The plans' roadmap citations were remapped after the roadmap's line numbers
moved — by content-matching, not by a uniform offset, because the citations
point into regions the roadmap edit also changed. Three quotations in the
M007 plan did not match the roadmap verbatim and were corrected; one of them
cited the status table while quoting the risk table, which was wrong before
this change too.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Make passes a recipe straight to the shell, so a backtick inside the echoed
string was read as a command substitution and silently expanded to nothing --
the help text printed "Daemon  profile" instead of "Daemon service
profile".

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The M007/M008/M009 closure updated the registry's per-plan entries and the
roadmap's section 4 and section 12, but left three summary lines claiming
the milestones were still planned:

- the roadmap's `Status:` header said "M6 and M7 not started";
- the registry's `desktop-gui-frontend` section heading said "M6-M9 planned";
- the registry's introductory paragraph still described M7-M009 as "planned
  and ready for handoff" and M7 as gated on all three.

`plans/registry.md` is the authoritative milestone/roadmap status, so these
lines were the ones an agent would read first and they contradicted the
entries below them. Corrected to: M7 conditionally closed, M8 and M9 closed,
M6 planned. M7's gate is now stated accurately as satisfied for M8 and M9 but
still open for M6 (its `Export` column is `pending M006`).

No code changed. Verified: architecture guards ALL PASSED; doc-reference
check at the unchanged baseline of 29 missing references.
Full operation coverage, report export, and an opt-in daemon lifecycle for
the desktop GUI, plus three defects the milestone found along the way.

The coverage model
------------------
The GUI now tells the operator WHICH of the daemon's published operations it
can reach and WHY, instead of hiding an unavailable one and saying nothing.
One row per published task kind, six verdicts (available, not_exposed,
not_advertised, feature_disabled, unverified, blocked), and every row carries
a human-readable reason.

The model is DERIVED, never transcribed: the variants, the operation ids, the
capability names, and the required-feature lists all arrive as arguments and
the verdicts are computed from them, so an operation the engine publishes
tomorrow is covered without a line being added.

The daemon publishes its enabled-feature set additively
(DaemonCapabilities::enabled_features, Option<Vec<String>>, None meaning
UNKNOWN -- never "nothing is enabled"), so the GUI can distinguish "the
daemon withholds this capability" from "the daemon was built without the
feature". A live FeatureMissing denial becomes a learned verdict that wins
over every static one: the engine's own word about the running daemon.

The report path
---------------
A new read-only GetTaskReport command and a TaskReport response. The report
document is produced by a PURE engine-side bridge
(runtime_bridge::report::report_for_result) and held in a BOUNDED store
(RuntimeReportStore, 64 entries, oldest-first eviction) behind a second
defaulted trait method. The result envelope's pinned empty payload is
untouched: TaskResultEnvelope.payload stays json!({}) and .artifacts stays
vec![].

The GUI exports six formats through eggsec-output with the TUI's write
discipline: an existing regular file is backed up to <path>.bak, a
non-regular-file destination is refused, and every failure is an Err.

The daemon lifecycle
--------------------
Opt-in, and only for a binary the operator names with --daemon-bin: there is
no PATH lookup and no sidecar convention, because nothing in the workspace
installs eggsec-daemon. The spawn is an argv vector, never a shell string.
The pre-flight check is a CONNECTION attempt, so a stale socket file does not
block the spawn and a live daemon is never displaced. The readiness wait is
bounded and completes the protocol handshake rather than scraping the child's
stdout. Teardown sends SIGTERM first and escalates to SIGKILL after a bounded
grace period, and a readiness timeout terminates the child rather than leaving
an orphan. The default still attaches to an operator-started daemon.

Three defects fixed
-------------------
1. The DesktopGuiManual surface was missing from the engine's permissive set,
   so a GUI session with no explicit scope took the strict branch and EVERY
   GUI TASK WAS DENIED. The policy crate had always classified the desktop
   GUI as a peer of the CLI and the TUI manual surfaces; the engine's scope
   resolution was the outlier. One arm in one match, and no other surface was
   widened. The regression test was demonstrated to fail before the fix.

2. The daemon answered a command it did not know with InvalidRequest and an
   EMPTY request id. Because the client routes responses by request id, the
   pending request was never resolved and the client waited out its 30-second
   timeout instead of learning the command was refused. It now answers
   UnsupportedCommand with the request id echoed, reserving InvalidRequest
   for a malformed command.

3. The GUI's Content Security Policy forbids embedding the engine's HTML
   document: frame-src 'none' rules out a frame, and script-src 'self' and
   style-src 'self' mean the document's inline script and style do not apply.
   The report content is ATTACKER-INFLUANCED -- banners and service names come
   from the target -- so the CSP was NOT relaxed to make an embedded document
   work. The GUI renders the report's structured content as text in its own
   DOM, the frontend has no innerHTML at all, and the HTML format is
   export-only.

New guards
----------
161 pins the derived coverage model: the GUI's production sources and its
frontend may not name an operation id or a capability name. The names are
read from their owners, not transcribed in the guard.
162 pins the report display: the CSP may not gain 'unsafe-inline', frame-src
must stay 'none', no GUI source or frontend file may reference a remote
origin, the frontend may not gain a markup-injection sink, and the GUI may
not consume an engine-produced HTML document.

Both were demonstrated to fail under a deliberate violation and to pass again
after the restore.

The plan was amended before implementation: milestone 008 falsified its
measurement that full-executor enables only the engine's cli feature, and its
"embedded HTML display that satisfies the CSP" was unsatisfiable under the
GUI's own CSP. Both corrections are recorded in the plan's amendment section
rather than implemented as written.

Verified: cargo fmt clean; cargo check --workspace --no-default-features
pass; 95 runtime, 89+7 protocol, 13 frontend-client, 73+7+12 output,
108+1+10+20 daemon, 80 engine runtime_bridge, 76 GUI (no-shell) and 80 GUI
(shell) tests pass; clippy clean on every crate touched; 133 architecture
guards ALL PASSED; doc references at the unchanged baseline of 29 missing.
The closure record for milestone 006 — full operation coverage, report export,
and the opt-in daemon lifecycle — together with the registry and roadmap
status updates that go with it.

The closure is honest about three things the milestone found rather than
assumed:

- The DesktopGuiManual surface was missing from the engine's permissive set,
  so every task the GUI dispatched through the daemon-hosted executor was
  denied. The policy crate had always classified the desktop GUI as a peer of
  the CLI and the TUI manual surfaces; the engine's scope resolution was the
  outlier. The user directed the fold-in.
- The daemon answered a command it did not know with an EMPTY request id, so
  the client waited out its 30-second timeout instead of learning the command
  was refused. It now answers UnsupportedCommand with the request id echoed.
- The GUI's Content Security Policy forbids embedding the engine's HTML
  document — frame-src 'none' rules out a frame, and script-src 'self' and
  style-src 'self' mean the document's inline script and style do not apply.
  The report content is attacker-influenced, so the CSP was NOT relaxed; the
  GUI renders the report's structured content as text and the HTML format is
  export-only.

Two of the plan's own premises were falsified before implementation and the
plan was amended rather than implemented as written: milestone 008 falsified
its measurement that full-executor enables only the engine's cli feature, and
its "embedded HTML display that satisfies the CSP" was unsatisfiable under
the GUI's own CSP.

The registry and the roadmap now record M006 as implemented, mark known gaps
2, 3, and 8 closed with what closed them, and add two new known gaps — the
report bridge's coverage of the result families, and the GUI's twelve-command
IPC surface. Milestone 007's dependency on M006 is met, so its Export cell
needs only its own evidence; the milestone stays conditionally closed because
the Linux row and the behavioural cells still need theirs.
Planning only. This commit records the research and the planning
artefacts for the maintainer's directive that no capability may be
blocked for manual execution, and for the remaining roadmap gaps. No
production code changes.

The directive is blocked at four independent layers, not one, and the
naive reading points at the wrong code:

  1. Publication   -- what the daemon advertises (host.rs:104-110):
                       daemon_conservative() INTERSECT executor declaration
  2. Executor declaration -- the trait default (runtime.rs:68-70):
                       daemon_conservative()
  3. Runtime admission -- what Runtime::submit accepts
                       (runtime_config.rs:32): full_lab(), 29 of 30
  4. Engine enforcement -- whether the operation may run at all
                       (policy.rs:106-128, decision.rs:1003-1013): the
                       operator's [execution_policy] risk flags, default deny

Two consequences follow, and both were measured rather than assumed.
The daemon already admits more than it advertises -- layer 3 is
full_lab() -- so widening only the daemon's policy is inert, because
the executor declaration is conservative too. And widening publication
does not unblock the hazard families, because layer 4's denial is a
hard deny excluded from the confirmation path (decision.rs:1361-1372);
no --yes or --allow-* flag can downgrade it.

ADR-0011 records the decision: one derived capability list replacing
the two hand-written ones, publication and admission made the same
object, enforcement left untouched, and daemon-mediated approval
promoted from a follow-up to a prerequisite -- because a manual daemon
client currently cannot answer a confirmation at all
(ClientCommand::ApprovePolicy answers ErrorCode::Unsupported at
host.rs:928-932, and nothing raises RuntimeEvent::PolicyDecisionRequired).

The ADR also records the live security finding that made the naive fix
unsafe: TaskKind::WirelessActive maps to the passive "wireless"
operation (risk SafeActive, capability PassiveFingerprint) while the
CLI resolves deauth against the catalog's "wireless-deauth" (risk
Intrusive, capability RawPacketProbe). No runtime task kind maps to
wireless-deauth, so a daemon-submitted deauth would be authorised under
the passive operation's risk level. That is closed before
wireless-active is published.

The ADR is proposed, not accepted: the roadmap makes its acceptance a
hard dependency of milestone 010, and the plan makes it a stop
condition.

Artefacts:

  - plans/adrs/ADR-0011-daemon-manual-capability-policy.md
    (new) -- the durable decision, with four options considered and
    Option D (flipping the ExecutionPolicy defaults) rejected.
  - plans/implementation/desktop-gui-frontend/
    010-daemon-full-manual-capability-policy.md (new) -- the M10 plan,
    16 sections, seven ordered work packages, four proposed guards
    (169-172), and eleven stop conditions. It does NOT implement
    ApprovePolicy; that is milestone 011.
  - plans/subsystems/desktop-gui-frontend-roadmap.md -- milestones 10
    through 15 added, each with a gap owner, plus the gap-owner table
    and the updated completion definition.
  - plans/registry.md -- ADR-0011 and the 010 plan registered.

The remaining gaps are decomposed into six independently releasable
milestones rather than one large one: M10 full manual capability
policy, M11 daemon-mediated policy approval, M12 the daemon's socket
path and bind contract, M13 the report bridge's full coverage, M14 the
GUI's qualification driver and runbook, M15 the dependency advisory
backlog. Gap 1 (the TUI's schema migration) stays explicitly out of
scope and ADR-gated; gap 12 is informational.

No canonical long-term document is amended: plans/000, 001 and 002
contain no mention of "conservative", "capability set", "hazard",
"manual surface" or "ManualPermissive", so the conservative set is a
runtime and policy-crate detail rather than a long-term direction.

Verification run on the artefacts: 122 file:line references in the plan
were checked to exist and to be in range, and the load-bearing ones
were checked against the source; python3 scripts/check_doc_references.py
reports the unchanged baseline of 29 missing references.
The daemon's "conservative policy" was four independent layers, not one,
and only one of them was actually a policy. This milestone closes the one
the maintainer asked about — no capability is withheld from manual execution
— without weakening any of the others.

ADR-0011 is accepted and implemented.

**Publication.** The hand-written 20-kind list is gone. The workspace now
has exactly one capability list, derived from the canonical TaskKind set and
covering all 30 canonical names, resume and the hazard families included.
The derivation is exhaustive by construction: the task-kind set is declared
once, in a define_task_kinds! table, which generates the enum, the
capability-name match, the variant enumeration, and the published
description table. A new variant cannot reach the enum without reaching the
derived list, so the compiler — not a convention — is the guarantee.
daemon_conservative(), full_lab(), and the private task_kind_name() table
are deleted.

**Admission.** The daemon's published set and the runtime's enforced set are
now the same object: the host computes the published list first and hands it
to the runtime as its capability set. The daemon cannot advertise a
capability it will refuse. DaemonHost::with_runtime now refuses to construct
when the two disagree, rather than narrowing silently. A recovered session
enforces what a fresh session enforces — hydration no longer substitutes
the retired conservative set.

**Enforcement — untouched, deliberately.** The operator's [execution_policy]
risk flags remain the sole gate for the hazard families. A hazard submission
is refused by the policy, naming the risk tier, never as an unsupported
capability; the enforcement error now carries the decision's own reasons so
the refusal is reportable. The risk-flag defaults are unchanged. ADR-0011
records the option of flipping them as rejected.

Three defects were found and closed on the way:

- The wireless-active wire kind was authorised under the PASSIVE wireless
  operation's risk level. It now resolves to wireless-deauth in the wire
  table, the engine's canonical table, and the executor routing table, so
  the daemon and the CLI authorise the same work at the same risk.
- Four interface-bound kinds (a local interface, a BSSID) had no target, so
  their descriptor could not build and they were unrunnable. TargetPolicyKind
  gained an InterfaceBound value: it accepts no network target, it carries
  the local identifier into the descriptor and the audit record, it keeps
  the explicit-scope requirement, and it does not match the identifier
  against the scope's remote target rules. The packet family was split so
  the capture owns its own operation; packet still serves packet-send and
  pipeline still serves resume, and both keep ExplicitScopeRequired.
- resume's target lives in the checkpoint, not in its params. The bridge
  resolves it and binds it to pipeline. An unreadable or target-less
  checkpoint is a hard failure; a resume is never authorised against no
  target.

The GUI reports a policy refusal as such — a published-but-policy-denied
kind is blocked with the risk tier named, never reported as available — and
says when an operation binds to a local interface. The verdict set and the
twelve-command IPC surface are unchanged.

Four new architecture guards, 169 to 172: the capability list is derived;
publication and admission are the same object; wireless-active resolves to
wireless-deauth; the interface-bound target policy is coherent and no shared
operation was relaxed to OptionalTarget. Each was negative-tested.

Verified: cargo fmt clean; cargo check --workspace --no-default-features
clean; 102+22 runtime, 88 policy, 89+7 protocol, 13 frontend-client, 73+7+12
output, 108+1+10+20+4 daemon, 1401 engine, 79+83 GUI, 31 CLI, 237 Python
tests green; clippy clean on every crate the make clippy set lints; all
architecture guards pass; doc references unchanged at 29 missing; make
check-msrv exits 0.
The closure record for milestone 010 — the daemon's full manual capability
policy — together with the registry and roadmap status updates that go with
it. ADR-0011 moves from proposed to accepted, and milestone 010 from planned
to implemented and closed.

The closure is honest about three things the milestone found rather than
assumed:

- The "conservative policy" the maintainer asked about was four independent
  layers, not one. Only one of them was a policy at all: the publication
  layer was a hand-written 20-kind list that withheld ten kinds from manual
  execution, while the runtime already admitted 29. Publication and
  admission are now the same object by construction.
- Widening the capability set did not weaken enforcement, and the closure
  proves it rather than asserting it: a stress-test submitted to a daemon
  with the default execution policy is still refused, by the policy, naming
  the risk tier, and never as UnsupportedTaskKind. The risk-flag defaults
  are unchanged, and ADR-0011 records the option of flipping them as
  rejected.
- One scope relaxation is recorded in full, because it is the only one. The
  scope model has no local-host subject, so an interface-bound operation's
  local identifier is not matched against the scope's remote target rules,
  while the operator's explicit scope is still required. The closure says
  plainly that this is NOT "the scope check now applies to the local host" —
  the model cannot say that.

The record also states what was not run: make check stops at the inherited
check-deps advisory backlog, make check-python needs a venv this environment
does not have, and the service profile and the policy and Python crates are
not clippy-clean at the --all-targets level for pre-existing reasons in
lines this milestone did not add.
Wires the daemon's `ApprovePolicy` command to the runtime's
pending-approval registry, so a manual daemon client can answer a
policy confirmation and the held operation then runs (ADR-0012).

The runtime owns the hold: a pending decision is registered *before* the
prompt is announced, so a client that answers immediately never races
the registration, and the entry cannot outlive its task. The runtime
stays policy-neutral — the registry holds a prompt and returns an
answer, and only `eggsec-policy` decides what an answer permits.

The answer is bounded by the policy, not by the client. The kernel's
`ConfirmationRequired` already carried the confirmation classes it
demanded; the runtime bridge now preserves them across the crossing,
and the engine's executor re-runs the *same* authorisation path with an
override built from exactly those classes. A strict surface never holds
a decision, so a strict client is still refused.

Also in this change:

- `ManualOverride::permitting_classes` in `eggsec-policy` is the single
  place a confirmation class maps onto the override field that permits
  it; the TUI's local copy of that table is deleted.
- The daemon audits every answer under the action `approve-policy`, and
  refuses an answer for a task with nothing pending as
  `ErrorCode::InvalidState` — a truthful refusal, where the old
  `Unsupported` was the same refusal for every input.
- The daemon's REST approval route was unreachable: one path parameter
  was declared and two were extracted. It now matches the sibling
  cancel route's shape.
- `RuntimeClient` gains `approve_task`; the GUI gains its thirteenth IPC
  command and shows the policy's own prompt with Approve and Reject.
- Guards 173–176 pin the wiring, the runtime's neutrality, the single
  mapping, and the audit record.
The closure record for the milestone that wired the daemon's
`ApprovePolicy` command to the runtime's pending-approval registry.

It records the design decision the milestone had to make — the runtime
owns the hold, and the operator's answer is bounded by the confirmation
classes the policy kernel demanded — alongside the measured evidence:
the end-to-end proof over a live Unix socket, the strict-surface
refusal, the bounded-override proof, the four guards' negative-test
results, and the residuals this milestone accepts rather than claims.

One deviation from the plan's wording is recorded explicitly: the
daemon's audit trail records the answering client, the session, the
session's surface, and the outcome, but **not** the task id or the
operator's reason — the audit schema has no column for either, and
adding one would need a real migration.

ADR-0012 is left `proposed`. The milestone implemented it as written;
acceptance is the maintainer's to ratify.
Three statements in the roadmap still described the approval path as
unwired after milestone 011 wired it:

- the cross-cutting security requirement said a GUI "MUST fail closed on
  any operation requiring interactive approval until the daemon's
  ApprovePolicy is wired";
- the milestone status table still listed milestone 11 as planned;
- the same table listed milestone 11's implementation plan and closure
  record as absent.

All three now describe the wired behaviour and the delivered records.
The desktop GUI subsystem had four milestones left on the roadmap with no
implementation plan: M012 (the daemon's socket path and bind contract), M013
(the report bridge's full coverage), M014 (the GUI's qualification driver and
runbook), and M015 (the dependency advisory backlog). This change authors all
four against the 16-section template in `plans/implementation/README.md` —
including the six sub-headings of section 10 — and registers them in
`plans/registry.md` and the roadmap's milestone status table.

Each plan was written against a measured baseline, and each measurement
corrected something the milestone's own roadmap entry still claimed.

M012 — corrective against milestone 009's deferral and milestone 004's
explicit deferral of the duplication. Half the milestone's exit condition is
already met: both start paths run a pre-flight liveness probe that refuses to
displace a live daemon, and the probe connects rather than stats the socket,
so a stale path does not block a start. What remains open is the server-side
bind — `run_server` still unlinks the socket path before binding, so the
refusal is raced — and the canonical default, which is transcribed six times
while `scripts/build-daemon-profile.sh` already reads an `EGGSEC_DAEMON_SOCKET`
override no Rust code honours. The canonical constant goes in
`eggsec-runtime`, measured as the unique dependency intersection of the
engine, the daemon, and the GUI.

M013 — corrective against milestone 006. The bridge maps 9 of the engine's 35
`TaskResult` variants, five unconditionally and four behind cargo features, so
26 variants fall through to `None`. The export path's "no report available"
wording already exists and becomes a preservation obligation rather than new
work.

M014 — capability, and the milestone that closes milestone 007's conditional
close. The qualification matrix is 21 cells; eight are blocked on the absence
of a driver and two on a procedure that was never written. The matrix is also
stale: it claims the GUI has no `export` reference in `app.js` (it has 50) and
cites a moved line for the daemon's bind. The plan chooses the operator
procedure over a headless driver, because a hosted runner has no display
server and the matrix's own promotion rule already routes through the runbook.

M015 — corrective against the inherited advisory backlog that stops `make
check` from completing. The backlog measures 23 entries across 20 advisory IDs
and splits three ways: 9 cleared by a lockfile refresh alone, 7 blocked by
this repository's own ring-only TLS rule, the exact `tauri` pin, or the MSRV
floor, and 7 with no safe upgrade.

Three roadmap statements are corrected because measurement contradicts them:
the M012 value claim, the M013 exit condition, and the M015 "a majority"
claim, which is a plurality (9 of 23). The M001 registry entry's operation-id
count is corrected from 26 to 28 — `PacketCapture` and `WirelessActive` have
their own operations since milestones 008 and 010.

The four plans reserve disjoint architecture-guard ranges in milestone order
(177–179, 180, 181–189, 190), following milestone 007's precedent, so an
implementer taking them out of order re-derives the numbers rather than
colliding.

Verified: `python3 scripts/check_doc_references.py` reports the unchanged
baseline of 29 missing references; `bash scripts/check-architecture-guards.sh`
reports ALL PASSED with no architecture drift.
The drift inventory is section 3.5, not 3.6; section 3.6 is the socket
default's six production sites. Three cross-references pointed at the old
number.

Verified: `python3 scripts/check_doc_references.py` reports the unchanged
baseline of 29 missing references; `bash scripts/check-architecture-guards.sh`
reports ALL PASSED with no architecture drift.
…ables

Two corrections the plan authors made against their own drafts:

Milestone 013 — the excluded-variant arithmetic. Twelve excluded kinds produce
seventeen variants, not eighteen; the terminal `Error` shape is the eighteenth.
With that, the 35 TaskResult variants divide as 17 with a clean mapping, 17
excluded, and the terminal error shape. The excluded list holds exactly 18
names.

Milestone 014 — the matrix drift table gains a third stale claim ("milestone
006 owns the export path" as the reason the Export column is blocked, now that
the milestone is closed) and the correction table records the guard-number
reservation: four milestones planned in parallel reserve disjoint ranges, so
M014 takes 181-189 rather than 177-185. The section cross-references follow the
renumbering (the drift inventory is 3.5, the guards are 3.8).

Verified: `python3 scripts/check_doc_references.py` reports the unchanged
baseline of 29 missing references; `bash scripts/check-architecture-guards.sh`
reports ALL PASSED with no architecture drift.
Implements the last four milestones of the desktop GUI frontend subsystem:
the daemon's socket-path and bind contract (012), the report bridge's full
coverage (013), the GUI's qualification procedure and runbook (014), and the
dependency advisory backlog (015).

Milestone 012 (ADR-0013) gives the daemon's socket path one owner. The
default, the environment variable's name and the precedence rule now live in
`crates/eggsec-runtime/src/daemon_endpoint.rs`; the daemon binary's
`--socket-path`, the engine's global `--socket`, the daemon's `DaemonConfig`
and the GUI's `GuiOptions` all resolve through that one resolver, and the
GUI's webview holds no copy of the default at all. The server now binds
before it removes the socket path and refuses to displace a live daemon, so
the guarantee lives in the bind rather than in the start path's pre-flight
check — the race the milestone set out to close is closed by construction.
Guards 177-179.

Milestone 013 gives the report bridge a coverage table. The engine's 35
`TaskResult` variants are accounted for exactly once in one table that lives
in `crates/eggsec/src/runtime_bridge/report_coverage.rs`; the eight families
that had no arm gain one; the daemon republishes the table verbatim in
`DaemonCapabilities.report_forms`; and the GUI renders the verdict together
with the daemon's own reason. The canonical report model is unchanged, the
bridge stays clock-free, and no authorisation decision changes. Guard 180.

Milestone 014 makes the GUI's qualification matrix checkable. A hermetic
procedure (`scripts/gui_qualification.sh`), an assertion harness
(`crates/eggsec-gui/tests/qualification.rs`) and a validator
(`scripts/check_gui_qualification.py`) that reads the promotion rules from the
matrix itself; the missing export procedure in `docs/GUI_BUILD.md` §5.7; and
a regenerated matrix whose stale blockers are corrected. The behavioural cells
are promotable, not promoted: they need an operator attestation that no CI
run can supply, so they stay `not qualified`. Guards 181-189.

Milestone 015 closes the dependency advisory backlog that milestone 010
recorded but did not own. The 23 inherited advisories are cleared: 9 by a
lockfile refresh, 3 by the `zip` 9.x major bump, and the rest recorded as
owned, dated exceptions in `docs/DEPENDENCY_EXCEPTIONS.md`. The `zip` feature
set is narrowed to `["deflate", "time"]` rather than widened with a licence
allowance. Guard 190.

The guard ranges are disjoint and reserved in milestone order, following
milestone 007's precedent. ADR-0013 is authored as `proposed`: its decision
is implemented exactly as the milestone specifies, and the ratification is
the maintainer's.

Verified: `make check` exits 0 for the first time on this branch — 4315 tests
across 77 test binaries, 190 architecture guards with no drift, `cargo deny
--workspace --all-features check` green, clippy clean, `cargo fmt --all
--check` clean; `make check-msrv` exits 0; `python3
scripts/check_doc_references.py` reports the unchanged baseline of 29 missing
references.
Milestone 010 split the packet family into `packet-capture` and `packet`,
added `wireless-deauth`, and moved the interface-bound operations' scope
requirement from descriptor construction onto the descriptor. It updated the
policy catalog's own self-tests but not the three integration tests that
asserted the old shape. `make check` had never reached them, because it
stopped at the inherited `check-deps` advisory backlog that milestone 015
cleared; with that gate green, the contract reached the engine's and the
TUI's integration tests for the first time and found all three.

`crates/eggsec/tests/canonical_dispatch_ownership.rs` asserted that all three
packet wire kinds map to the `packet` operation. The capture half owns its own
operation, because a capture binds to a local interface while `packet` serves
`traceroute` and `packet-send`, which address a remote host. The test now
asserts the deliberate split and is renamed, because its old name stated a
truth the milestone had already retired.

`crates/eggsec/tests/enforcement_matrix.rs` asserted that an interface-bound
operation fails descriptor construction on a target-less run. The refusal
moved: such an operation now accepts the run and carries
`requires_explicit_scope` on the descriptor. The test now asserts the same
posture as the catalog's own `interface_bound_operations_still_fail_closed`,
and — the property its name and doc comment are about — that a strict
automated surface still refuses the operation with `ScopeMissing` once a local
identifier is supplied and no explicit scope manifest is loaded.

`crates/eggsec-tui/src/parity.rs` requires every canonical operation to have
a TUI tab or an intentional CLI-only classification, and it names the
exceptions in a set. `packet-capture` was in neither, because the TUI's
Packet tab declares `packet` while its capture path drives `packet-capture`
— so the operation is covered by a tab, not CLI-only. The check now carries a
third coverage set, `covered_via_tab`, naming the operations a tab drives
without declaring them as the tab's own operation. The invariant keeps its
strength: an operation that no tab drives and that is not classified still
fails the check.

No product behaviour changes. All three were stale with respect to decisions
milestone 010 had already made and self-tested in
`crates/eggsec-policy/src/catalog.rs` and in the TUI's own tab specs.

Verified: `make check` exits 0 — 4315 tests across 77 test binaries, 190
architecture guards with no drift, `cargo deny --workspace --all-features
check` green, clippy clean, `cargo fmt --all --check` clean.
… smoke script

`scripts/smoke-daemon-local.sh` started the daemon with the socket path as a
positional argument, while the daemon binary has always taken it as the
`--socket-path` option. The script therefore failed at every run with

    error: unexpected argument '/var/folders/.../eggsec-smoke-XXXXXX.sock' found

and stopped at "Daemon socket not found … after 10s". The defect is
pre-existing and reproduces against the unmodified script at HEAD; it is
fixed here because milestone 012 touched the daemon's socket-path handling
and the script is the local smoke check for it.

Verified: `make check` exits 0; the smoke script's own shell syntax checks
(`bash -n`).
… 015

Closes the desktop GUI frontend subsystem's last four milestones with a
closure record each, in the 12-section template, and moves the registry and
the roadmap's milestone status table from "planned" to "implemented".

Milestone 012 (corrective) — the daemon's socket path has one owner. The
default, the `EGGSEC_DAEMON_SOCKET` name and the precedence rule live in
`crates/eggsec-runtime/src/daemon_endpoint.rs`; the webview holds no copy;
and the server's bind refuses to displace a live daemon, so the guarantee
lives in the bind rather than in the start path's pre-flight check. The
milestone's deviation is recorded as finding F1: ADR-0013 is authored as
`proposed`, because ratification is the maintainer's — the same route
milestone 011 took with ADR-0012.

Milestone 013 (corrective) — the report bridge's coverage table accounts for
the engine's 35 `TaskResult` variants exactly once, and the daemon publishes
it so the operator learns the coverage rather than guessing. The plan's own
finding is carried forward rather than closed: twelve of the thirty-five
report documents still carry no timestamp, because closing it means either
adding a timestamp to twelve engine result types or giving the bridge a
clock, and neither is a mapping.

Milestone 014 (capability) — the qualification matrix is now checkable, with
a hermetic procedure, an assertion harness and a validator that reads the
promotion rules from the matrix itself. The behavioural cells are
**promotable, not promoted**: they need an operator attestation that no CI
run can supply, so they stay `not qualified`. The record states that plainly
rather than claiming a promotion it did not earn.

Milestone 015 (corrective) — the dependency advisory backlog is closed and
the mandatory contract completes for the first time on this branch. The
`zip` 9.x upgrade was taken with a narrowed feature set rather than with a
licence allowance; that deviation, its reason and its revert recipe are
recorded as finding F1.

Three integration tests that milestone 010 had left stale were found by that
first complete `make check` run and corrected in `dcfcd4e2`; the correction
is recorded as a dated addendum on milestone 010's closure record rather than
by rewriting its findings. A pre-existing defect in
`scripts/smoke-daemon-local.sh` — the daemon's socket path was passed
positionally where the binary takes `--socket-path` — is fixed in `42e3534b`.

Verified: `make check` exits 0 — 4315 tests across 77 test binaries, 190
architecture guards with no drift, `cargo deny --workspace --all-features
check` green, clippy clean, `cargo fmt --all --check` clean; `make check-msrv`
exits 0; `python3 scripts/check_doc_references.py` reports the unchanged
baseline of 29 missing references.
…lification

The desktop GUI's platform-qualification matrix promotes the behavioural
columns on rule P1, which requires both a scripted outcome of `pass` and an
operator outcome of `pass`. Nothing could write that second value: the harness
emitted `not-performed` at every one of its sites, and the only documented
route to a promotion was a hand edit of the record's json block -- which a
later run silently overwrites. That is a promotion with no tooling behind it.

This adds the missing machinery rather than weakening the rule. An operator
writes an attestation file of their own (schema
`eggsec-gui-operator-attestation/v1`) naming who observed the behaviours, when,
on which platform, against which commit, and what they saw for each column.
The procedure merges it into the record in the same write that produces the
record, so the record has one writer and a later run cannot erase the
attestation. The validator refuses an unattributed `pass`, an attestation that
names another platform or another commit, and an attestation that claims a
column passed whose scripted outcome was not `pass`.

`--run-label` lets a day with two runs keep two records rather than one
overwriting the other.

Guard 191 pins the three facts that make the machinery real and the two that
keep it honest: the procedure accepts an attestation and passes it to the
record writer, the validator knows the schema and refuses an unattributed
pass, no code path defaults an operator outcome to `pass`, the harness never
self-attests, and the matrix's own rule P1 still requires the operator's
`pass`. It was negative-tested against five injected violations -- the
procedure losing the flag, the flag not reaching the writer, P1 weakened to
`not-applicable`, the harness emitting a pass, and the validator defaulting
an outcome to `pass` -- and it caught every one of them.

Verified: `python3 scripts/check_gui_qualification.py --self-test` (17 cases),
`python3 scripts/check_gui_qualification.py` (the existing CI-mode record
stays valid), `bash scripts/check-architecture-guards.sh` (191 guards).
The maintainer ratified `plans/adrs/ADR-0013-daemon-endpoint-default-and-bind-contract.md`
on 2026-10-24. The ADR now carries `Status: accepted` and a `Ratified:
2026-10-24` line, and its Decision section opens in ADR-0009's house form.
The decision text is untouched -- the Context, drivers, options, Decision,
Consequences, compatibility, security and verification sections are
byte-identical to the proposed version milestone 012 was implemented against,
because an accepted ADR is a historical record.

Milestone 012's closure record gains a dated addendum recording that
finding F1 -- that the ADR was proposed rather than accepted -- is closed,
and giving the disposition of the remaining findings (F2 and F4 accepted,
F3 closed by the owner's integration run, F5 an accepted residual) without
rewriting the record's completion account.

`plans/registry.md` lists ADR-0013 among the durable decisions as accepted
2026-10-24, and the subsystem roadmap's milestone-012 row records the ADR as
met.
…he window

Two defects in the qualification procedure, both found by running it in
operator mode on a host with a real GUI window open.

**The launch column could never pass.** The status chain tested
`LAUNCH_STATUS == "not-performed"` first, and the status starts life as
`not-performed`, so every run took the failure branch however many windows
the probe had found. A run whose record said "the probe found 1 window(s)
titled `Eggsec`" was still filed as `fail`. The count decides now, and the
branches are ordered so that is what decides.

**The launch screenshot was a photograph of the operator's desktop.** On
macOS the procedure captured the whole screen, so the artefact it proposed to
commit was whatever else was open — other windows, other applications. The
capture is now of the GUI's own window rectangle, taken from the window's
accessibility geometry.

The probe also learned two things. It brings the application forward before
asking, because a window that is not on the current Space reads as absent —
that is how the probe found the window the operator could see. And it counts
windows *titled* `Eggsec`, which is the runbook's criterion, rather than
counting the window's `name`, which is the owning application's name and says
nothing about the title bar.

The attestation's commit binding was relaxed from equality to ancestry: an
attestation names the commit the behaviours were observed against, and the
run that carries it must be that commit or a descendant of it. Equality made
the attestation impossible to write at all, because the file that carries it
would have to be committed before the run that cites it.

Verified: `bash scripts/gui_qualification.sh --platform macos --mode operator
--socket <path> --run-label operator` now reports every column's scripted
outcome as `pass`; the launch artefact is the GUI's window (2400x1600) rather
than the desktop (3024x1964); `python3 scripts/check_gui_qualification.py
--self-test` passes; the guards pass.
The operator-mode run of the qualification procedure on a macOS host with the
GUI's window open: the tree was clean, the record names the commit it was
made at, and every column's scripted outcome is `pass` -- build, launch,
connect, submit, cancel, render and export.

The launch artefact is the GUI's own window (2400x1600), not a photograph of
the operator's desktop. The record's operator outcomes are `not-performed`:
the machine measured the scripted half and nobody has yet attested to the
human half. The attestation that promotes the behavioural cells is a separate
file, merged into the record by the same procedure.
…cells

David Bowman observed the desktop GUI's behaviours on this macOS host and
confirmed them: the window painted and titled Eggsec; the badge read
CONNECTED with the daemon's published catalogue and a session id; the
schema-driven form assembled a request the daemon accepted; the cancel
control reached the daemon and the daemon's answer was surfaced verbatim;
the report rendered as data; and the export wrote the daemon's report to the
chosen destination.

The attestation names the commit the behaviours were observed against
(309d77d, the tree the operator ran) and what was seen for each column. The
procedure merges it into the run record in the same write that produces the
record, so the record has one writer and a later run cannot erase the
attestation.
The `gui-platform` job on ubuntu-latest installs
`libayatana-appindicator3-dev`, which ships the pkg-config module named
`ayatana-appindicator3-0.1` -- the Debian and Ubuntu spelling drops the `lib`
prefix that the library itself keeps on every distribution. The probe knew
only `libayatana-appindicator3-0.1` and the pre-ayatana `appindicator3-0.1`,
so it reported a distribution that has the library as one that does not, and
the Linux leg of the qualification failed its own prerequisite probe before
it could produce a record.

The probe now accepts the Debian and Ubuntu spelling as well, and says which
one it found.
…ed run

The desktop GUI's macOS row now carries `qualified` for `Launch`, `Connect`,
`Submit`, `Cancel`, `Render` and `Export`, on the strength of a run the
operator attested to.

The run is `docs/evidence/gui-qualification/macos-2026-10-24-operator.md`:
made on a clean tree at commit d0cf5bc, every column's scripted outcome
`pass`, and the launch artefact is the GUI's own window rectangle rather than
a photograph of the operator's desktop. The attestation is
`docs/evidence/gui-qualification/macos-2026-10-24-operator.attestation.json`
-- David Bowman, 2026-10-24, macos, against commit 309d77d -- and the
procedure merged it into the record in the same write that produced the
record, so the record has one writer and a later run cannot erase it.

The Linux behavioural cells stay `not qualified`, and the matrix says why: a CI
run cannot attest, because the job has nobody to observe with, so every column
it produces carries `operator: not-performed` while rule P1 asks for `pass`.
Promoting the Linux behavioural cells needs an operator at a Linux desktop.

Milestone 014's closure record gains a dated addendum: what was missing (the
attestation had no tooling behind it, and the only route was a hand edit a
later run would overwrite), what was added, and the three defects the
promotion found -- a launch column that could never pass because the status
chain tested `not-performed` first, a launch screenshot that was a photograph
of the operator's desktop, and a Linux prerequisite probe that could not see
the appindicator module Debian and Ubuntu name `ayatana-appindicator3-0.1`.

Verified: `python3 scripts/check_gui_qualification.py` (the matrix is
consistent with its evidence), `bash scripts/check-architecture-guards.sh`
(191 guards, all passed).
OpenCode Agent and others added 23 commits October 24, 2026 23:44
…motion

The GUI skill's guard range moves to 155-191 (guard 191 is the attestation
machinery), and both the skill and `architecture/desktop_gui.md` now say how a
promotion's human half is recorded: an operator-written attestation file,
merged into the record by the procedure that writes it, with the validator
refusing an unattributed `pass`. Both also carry the standing gap the
promotion did not close -- the Linux behavioural cells need an operator at a
Linux desktop, because a CI run has nobody to observe with.
The distribution hand-off cited the CI-mode record for the export procedure's
recorded run. The operator-mode record carries the same digests and the
operator's attestation, and it is the record the matrix's macOS row now
cites.
The self-test hard-coded `macos-2026-10-24.md` as the evidence file it
mutates. When the matrix's macOS row moved to the operator-mode record, every
case that touched a record began to fail with "the self-test's mutation
target is absent" -- a failure of the test, not of the thing it tests.

The self-test now reads the evidence file the matrix actually cites, so
renaming or repointing a record does not silently break it. Two cases also
needed their meaning made explicit: "no attestation" now *removes* the
attestation block rather than leaving whatever the record carried, and "no
observation" now *removes* the observation. Both were no-ops on a record that
already had an attestation, which is why the cases stopped testing what they
were written to test.

Verified: `python3 scripts/check_gui_qualification.py --self-test` (18
cases), `python3 scripts/check_gui_qualification.py` (the matrix is
consistent with its evidence), `bash scripts/check-architecture-guards.sh`
(191 guards).
The `gui-platform` job has now run on both legs for the first time: run
`https://github.com/eggstack/eggsec/actions/runs/40143483040`, at commit
`d0cf5bc3`. The Linux leg needed the prerequisite probe's fix to get that
far -- it was failing on the appindicator module's Debian and Ubuntu name --
and it then produced a record in which every behavioural column's scripted
outcome is `pass`.

That record is committed beside the index, with its build sidecar and its
exported report, so the Linux row's `Build` cell is now **qualified** on a
checked record rather than on a citation: the validator re-checks the
sidecar's SHA-256 against the file it committed.

The Linux behavioural cells stay `not qualified`, and the matrix now says why
with the measurement beside it: the scripted half passed, and the missing
part is the operator's attestation, which a CI run cannot supply because the
job has nobody to observe with.

The matrix's `Last regenerated` commit and the Linux record's commit are both
`d0cf5bc3`, so the record is the one the matrix was regenerated against.
The committed macOS CI-mode record was the one the previous session's CI run
produced, at commit 0f5dbb2 — before the launch probe was fixed, so its
`launch` column was filed by a procedure that could never pass that column.
The `gui-platform` job has since run on both legs and published a fresh
macOS record, at commit d0cf5bc on a clean tree, whose launch column reads
`not-performed` for the honest reason: the job never launches the GUI.

That record replaces the old one, with its build sidecar and its exported
report. The four export artefacts the old run published and this one did not
(`.csv`, `.html`, `.sarif`, `.xml`) are removed rather than left beside a
record that does not name them — a stale artefact next to a current record is
evidence of a run nobody made.

Both records' artefacts' SHA-256 digests were re-checked against the digests
their records carry, before and after the swap.
…osure

Finding F3 -- that the integration contract was the session owner's step and
was unproven -- is discharged: make check exits 0 over the tree with all
four milestones landed, with 4315 tests across 77 test binaries, cargo deny
green, clippy and fmt clean, and 191 guards passing.

Also recorded: clearing the advisory backlog unblocked the repository's CI to
reach a step it had never reached, where it found three pre-existing failures
in the TUI's web-proxy-gated Intercept tab. The defect and its attribution
are recorded as facts; the fix is a separate step.
The tab is gated on the `web-proxy` cargo feature, so the crate's default
build never compiles it and the default-build test suite is green. The
`db-pentest,web-proxy,c2` profile that `make check-full` exercises does
compile it, and three tests there failed. Both defects are production
defects, not test bugs, and both are the class the Intercept tab's own
audit commit (8ecd17a) was meant to close -- the audit's tests ran without
the feature, so the tab was never in the set they checked.

The session stamp

`InterceptSession::new` pre-fills `ended_at` with the same stamp as
`started_at`, and `finalize` re-stamps `ended_at` from `chrono::Utc::now()`.
`start_session` and `stop_session` call those back to back, and the wall
clock ticks far coarser than that gap: 2000 consecutive `CLOCK_REALTIME`
reads on this host produced only 122 distinct values, while the monotonic
clock produced 1952. Both stamps therefore land on the same tick and render
as the same RFC 3339 string, so a session that ran reported a zero-length
interval.

That is why the failure is timing-dependent. The same profile failed three
tests locally and two in CI run 40143483040, where
`test_intercept_tab_start_stop` passed: the defect is present on both, the
clock only decides whether the collision is visible.

The tab now records a monotonic `Instant` when the session starts and, on
stop, keeps the wall-clock end when it is strictly later and otherwise
re-stamps the end from the monotonic measurement with a one-millisecond
floor. A session that ran can no longer record an equal start and end.

The focus contract

`is_input_focused()` was a hard-coded `false` and the tab never implemented
`ensure_input_focus()`, so it fell through to the trait's default no-op. The
app therefore held the tab in Normal mode, where the global shortcuts own
the printable keys: `r` reset the tab, `p` jumped to the previous tab and
the digits jumped tabs, while the tab's own bindings (`r` toggles the rule
view, `p` toggles performance mode, `/` opens the filter) and the edit
modal's text entry were unreachable. The tab also lacked the
`#[cfg(test)] fn set_state` hook every other tab has, so the mid-run guard
could not even establish its `Running` precondition.

The tab now focuses the flow list -- this tab's selector -- on entry unless
a text surface owns the focus, and reports it through `is_input_focused()`,
the shape the selector-first siblings (Proxy, Cluster, Report, Packet)
already use. `j`/`k` pass through to the flow list while it is focused, so
the list stays drivable now that the tab owns the focus; the arrows already
worked in both modes.

One test is added, `test_stop_session_keeps_the_end_stamp_after_the_start_stamp`,
which drives the clock collision directly and so proves the guarantee
deterministically instead of waiting for the wall clock to collide. No
existing test was changed, weakened or deleted: the two shared guard files
and `tabs/mod.rs` are untouched, because the defect was in the tab and not
in the contract.

Verified: `cargo test -p eggsec-tui --features db-pentest,web-proxy,c2 --lib
--no-fail-fast` reports 1074 passed and 0 failed, against 1070 passed and 3
failed before. `make check` exits 0 -- 4315 tests across 77 test binaries,
cargo deny green on all five sub-checks, clippy and fmt clean, 191 guards
passing.
The previous addendum on this record raised the exposure: clearing the
dependency-advisory backlog unblocked the repository's CI to reach the
deep-check job's TUI feature profile, where it found three pre-existing
failures in the web-proxy-gated Intercept tab. CI run 40143483040 is that
run -- every job green except Deep Checks.

The defect is now repaired, on the branch that exposed it, so the exposure
does not become a hand-off. This addendum records the two root causes, the
change, and the evidence: 1074 passed and 0 failed on the feature profile,
and `make check` exiting 0 with 4315 tests, cargo deny green, clippy and fmt
clean, and 191 guards passing.

Two residuals are stated rather than left implicit: the engine's pre-existing
clippy debt behind `#[cfg(feature = "db-pentest")]`, which the contract's own
lint invocation never compiles, and the macOS clipboard round-trip test,
which was observed failing once across a twelve-run sweep and is unrelated
to this change.
The registry's desktop-GUI cell said the cleared dependency-advisory backlog
lets `make check` run past `check-deps` for the first time on this branch.
That is true but it left the consequence implicit: the CI run the unblocking
reached (40143483040) failed the deep-check job on three pre-existing
failures in the TUI's web-proxy-gated Intercept tab.

The defect is repaired on this branch, so the exposure this workstream
opened is closed on the branch that opened it. The cell now says so, and
points at the closure record for the root causes, the change and the
evidence.
The §Test Counts section published "1,128 test attributes across 121 `.rs`
files" and stamped it as re-verified. Re-measuring against source showed the
totals were already stale before the Intercept repair: the tree carried 1,131
test attributes across 118 `.rs` files. The seven per-file counts listed
beside it were re-measured too and remain correct, so only the totals were
wrong.

The totals now read 1,132 across 118, and `tabs/intercept/tests.rs` is
listed with the fact that matters most about it: the file is only compiled
under the `web-proxy` feature, so the crate's default build never runs it.
That is the blind spot that let the Intercept tab's session-stamp and
focus-contract defects sit in the tree unnoticed -- the default-build test
suite is green because the tab is not in it, and the defect only surfaces in
the `db-pentest,web-proxy,c2` profile that `make check-full` exercises.

The document's verification stamp records this pass.
CI run 40147251811 failed its Deep Checks job at guard 188, the promotion
validator, on all seven qualified macOS cells. The message accused the
operator's attestation of belonging to another run:

  the `macos` row's `Build` cell says `qualified`, but
  `macos-2026-10-24-operator.md`'s `attestation` names the commit
  `309d77d1...`, which the run (`d0cf5bc3...`) does not descend from; an
  attestation of one run cannot be read as an attestation of another

The accusation was false. `309d77d1` IS an ancestor of `d0cf5bc3`, and both
are on the pushed branch; what CI could not do was ask. The validator
decides that binding with `git merge-base --is-ancestor`, and
`actions/checkout` fetches the tip alone by default, so on a runner neither
commit is in the object store. git exits 128 -- "Not a valid commit name" --
and the validator read that non-zero exit as "not an ancestor".

A depth-1 clone of the branch reproduces all seven problems byte for byte,
and `git fetch --unshallow` makes all seven disappear.

Two changes, because the environment was at fault and the reporting was
wrong too.

The checkout now carries the history

All nine `actions/checkout` steps across ci.yml and deep-checks.yml set
`fetch-depth: 0`. The rule is uniform rather than per-job on purpose: a job
that forgets the history is exactly the failure just repaired, and the cost
is a 29 MB clone instead of an 8.8 MB one.

The verdict is three-valued

`is_ancestor` now distinguishes "is not an ancestor" (git exits 1) from
"cannot be told" (git exits 128). One shared function -- used by the
matrix's cell check and by the record writer's own check, so both say the
same thing about the same commit -- reports the two differently. A genuine
contradiction still reads as one; a checkout that cannot answer names the
cause and the remedy:

  ... and this checkout cannot say whether the run (`d0cf5bc3...`) descends
  from it: the checkout is shallow and does not carry the commit's history;
  fetch it (`git fetch --unshallow`) and check again

The verdict still fails closed: an undecidable binding is a rejection, not
a pass. What changed is the truthfulness of the failure, not its
strictness, and no promotion rule was weakened.

Guard 192 pins the environment half, so the cause cannot return unnoticed:
every checkout in the workflows must ask for the full history. It is
negative-tested -- `fetch-depth: 1` and a missing `fetch-depth` are both
rejected, and the unmutated tree passes.

The validator's self-test grows five cases that build a real shallow clone
(`git clone --depth 1 file://...`) and prove the three answers stay apart:
a full checkout says the run descends, a shallow checkout says it cannot
tell, a shallow checkout is recognised as shallow, a shallow checkout does
not accuse the attestation of another run, and a full checkout accepts it.

Why it surfaced now

The failure was latent. Guard 188 runs in the LAST step of `make check`,
after every test, so run 40143483040 failed earlier -- at the TUI tests --
and never reached it. The Intercept repair let CI get further, and the
latent failure became visible.

The matrix is unchanged: its "Last regenerated" commit stays `d0cf5bc3`,
because `check_commit` requires a cited record's commit to be the matrix's
commit or a descendant of it, and the macOS record and its attestation are
bound to `d0cf5bc3`. The promoted cells stay promoted.
CI run 40147251811 reached guard 188 for the first time -- it is the last
step of `make check`, and the earlier run failed at the TUI tests before it
got there. The guard rejected the matrix's seven qualified macOS cells,
reporting that the operator's attestation named a commit the run "does not
descend from".

That report was false. The validator decides the binding with `git
merge-base`, which can only answer when the checkout carries the history,
and `actions/checkout` fetches the tip alone by default. CI therefore could
not find the commit the operator had observed, and the validator read "cannot
tell" as "does not descend from" -- a false accusation, caused by the
checkout rather than by the evidence. A depth-1 clone reproduces all seven
problems byte for byte; `git fetch --unshallow` makes all seven disappear.

The addendum on milestone 014's closure record states the root cause, the
two-part fix (the checkout now carries the history; the verdict is
three-valued and says so honestly when it cannot decide), the new guard 192
that pins the environment half, and the evidence.

The registry's desktop-GUI cell carries the same finding in one line, next
to the Intercept repair that preceded it: the branch that opened the
exposure also closes it.

What was not changed is recorded too: the matrix is not edited, its
"Last regenerated" commit stays `d0cf5bc3`, rule P1 still requires an
operator outcome of `pass`, and the Linux behavioural cells stay `not
qualified`. Nothing here changed what a CI run can attest.
…mmit

`git merge-base --is-ancestor` fails when *either* commit is absent, so the
validator's "this repository does not contain" message could name the wrong
one. It always named the attestation's commit, even when the record's own
commit was the missing object -- the same false accusation the three-valued
verdict was introduced to remove, one step sideways.

The validator now looks before it speaks: `commit_in_repository` checks the
attestation's commit first, and a record whose own commit the repository
does not carry is reported as such. The attestation's commit keeps its own
message, because that is the one an attestation is responsible for.

The self-test grows a sixth case for this path: a missing run commit is not
blamed on the attestation. Twenty-two cases pass.

No rule was weakened and no promotion changed. This is a diagnostic's
accuracy, and it is the same accuracy the previous commit bought for the
shallower case.
…stalled one

Milestone 015's closure recorded finding F4: local `cargo-deny` is 0.20.2,
CI installs `cargo-deny@0.19.0`, and "a local green is not proof of a CI
green". It was filed at `low`, on the theory that a version difference could
only reorder diagnostics.

It hung CI instead.

After the Intercept repair, the deep-check job stopped at `make check-full`
-- but not at a test and not at a guard. It hung, with no output and no
error, inside `cargo deny --workspace --all-features check bans`. Two runs on
two different runners stalled at the same byte of the same dependency tree
(the inclusion graph for `r-efi`), and the log did not move for 47 minutes
before the run was cancelled.

It was not this repository's code. The Rust inputs to `cargo deny` are
byte-identical between the head where CI's `cargo deny` completed (run
40147251811, head 27fe3a9) and the head where it hung (head a3b40ae):
`Cargo.lock`, every `Cargo.toml` and `deny.toml` are unchanged between
them, and `cargo deny` reads nothing else. The changed files were the
workflows, the validator, the guard script and the docs -- none of which
had run yet, because `make check-deps` is Makefile:179 and the architecture
guards are Makefile:193.

The mechanism is upstream's. cargo-deny's changelog for 0.19.9 records PR#870
resolving #868 "by spawning scoped threads directly, allowing forward
progress even on severely constrained thread pool counts". A GitHub-hosted
runner has a small core count, and this workspace has 194 duplicated crates,
each with an inclusion graph for the `bans` check to print. Locally, where
the tool is 0.20.2, the same command finishes in about a second, every
time.

So all three CI pins move from `cargo-deny@0.19.0` to `cargo-deny@0.20.2`:
the version the local contract has been running all along, which is what
makes a local green worth anything. The advisory result is unchanged under
it -- `cargo deny --workspace --all-features check` reports `advisories ok,
bans ok, licenses ok, sources ok` on this workspace with 0.20.2, so the 23
cleared advisories stay cleared and the owned exceptions stay owned.
`deny.toml` does not move: the policy did not change, the tool that
measures it did.

Guard 193 pins both facts, where a version bump cannot forget them: every
`tool: cargo-deny` must name an exact version, every workflow's version must
be the same, and that version must be at least 0.19.9 -- the release that
fixed the stall. It is negative-tested against four violations: drift
between the workflows, a version below the floor, an unpinned
`tool: cargo-deny`, and a missing pin.

A tool that decides policy must be one tool at one version.
Finding F4 recorded the skew between the local `cargo-deny` (0.20.2) and
CI's (0.19.0) at `low` severity, on the theory that a version difference
could only reorder diagnostics. It hung the deep-check job instead, and the
addendum on milestone 015's closure record says so, with the upstream
mechanism (cargo-deny #868, fixed in 0.19.9), the evidence that the Rust
inputs to `cargo deny` were byte-identical between the head where CI's deny
completed and the head where it hung, and the fact that `deny.toml` did not
move -- the policy did not change, the tool that measures it did.

The registry carries the same finding in one line, in the desktop-GUI
subsystem cell and in the milestone-015 entry: the CI now decides the
dependency policy with one tool at one version, and guard 193 keeps it that
way.
The Deep Checks job has been hanging since the Intercept repair: it stops
inside `cargo deny --workspace --all-features check bans`, with no output and
no error, while printing the inclusion graph for `r-efi`. The log did not
move for 47 minutes before the run was cancelled.

Two candidate causes were eliminated rather than assumed:

- The checkout depth. A control branch (`diag/shallow-control`) reverted only
  `fetch-depth: 0` and stalled at the same crate. The deep checkout is not the
  cause.
- The cargo-deny version. The stall reproduces on 0.19.0 *and* on 0.20.2, at
  slightly different points in the same subtree.

What is left is the rendering itself. `cargo deny --workspace --all-features
check` prints 15,254 lines, of which 14,539 are inclusion-graph trees, one per
duplicated crate -- 98 of them in this workspace. The renderer walks a cyclic
subtree there and stops making progress. `--hide-inclusion-graph` removes
that path and nothing else: the same 98 duplicate warnings are printed and the
same four verdicts are reached (`advisories ok, bans ok, licenses ok, sources
ok`). The policy result is unchanged; `deny.toml` is unchanged.

So all five `cargo deny` invocations in the Makefile's `check-deps` target now
pass `--hide-inclusion-graph`, and guard Check 194 keeps the flag on every
invocation -- as an exact token, since a substring test would wave
`--hide-inclusion-graphs` through. It is negative-tested against six
violations: the flag dropped from the first, a middle and the last
invocation, the flag misspelled two ways, and the invocation removed.

Guard Check 193's floor is re-grounded from 0.19.9 to 0.20.2. The previous
floor was justified by cargo-deny's thread-pool bug (#868) and claimed to
prevent the stall; that justification was wrong, and no version prevents it.
The floor now says what it actually enforces: CI must not fall behind the
version the local contract runs, so the same tool decides the same policy
everywhere. That is milestone 015's finding F4, and it is unchanged by this
commit.

The version pin to `cargo-deny@0.20.2` stays, on F4's own terms and not as a
stall fix: the local tool was 0.20.2 while CI ran 0.19.0, so "a local green
is not proof of a CI green" was true before this work and is false now.

The workflow comments that repeated the disproven thread-pool attribution are
corrected in place.
The previous addendum on milestone 015's closure record attributed the CI
stall to cargo-deny 0.19.0's thread-pool starvation (#868), and the same
claim was repeated in `plans/registry.md` and in the guard's own comment. The
attribution was inferred rather than measured, and it is wrong: the stall
reproduces on 0.20.2 as well, and it is in the inclusion graph's rendering,
not in the thread pool.

The addendum is appended rather than rewritten -- it is pushed history, and
the correction is dated. It records what was wrong, the three pieces of
evidence that contradict it (the version bump did not fix the stall; a
control branch isolated the checkout depth; the flag removes the stall site
while preserving every warning and every verdict), what changed, and what did
not: the version pin stands on F4's own terms, `deny.toml` is unchanged, and
the policy verdict is unchanged.

Two figures in the earlier record were imprecise and are corrected: the
workspace duplicates 98 crates, not 194 (the CI logs show a larger line count
only because the Makefile runs both `check` and `check bans`, printing each
warning twice), and the full `check` output is 15,254 lines against 715 with
the graph hidden.

`plans/registry.md` is a live control surface, so its two cells state the
corrected mechanism and point at the addendum rather than leaving a claim
known to be false.

The lesson is recorded too: a control that isolates one variable at a time is
what turns a plausible story into a proven one. The version bump was the
right repair for F4, and it was tested against the wrong variable.
…re compiling

`crates/eggsec-tui/src/tabs/vuln.rs` defined `ensure_input_focus` by hand and
also invoked `tab_input_custom!`, which emits `ensure_input_focus`. Two
definitions of one method in one `impl` block is E0201, so the
`vuln-management` feature did not compile at all:

    error[E0201]: duplicate definition
      --> crates/eggsec-tui/src/tabs/vuln.rs:477:5
       |
    477 |     fn ensure_input_focus(&mut self) {
       |  previous definition here
       |  in this macro invocation
       |  ::: crates/eggsec-tui/src/tabs/mod.rs:663:5

The hand-written copy is removed and the macro's stands. The two were
behaviourally identical, so nothing changes: `core::ensure_first_field_focused
(&mut core)` is exactly `core::ensure_group_field_focused(&mut core.inputs)`,
and `TabCore` owns precisely one input group. The comment left in `vuln.rs`
records why.

This defect was not introduced here. `tabs/{mod.rs, macros.rs, vuln.rs}` are
byte-identical between `main` and this branch, and `main` has the same
duplicate: it entered with c66f094 ("kill two dead-input paths that made tabs
look frozen"), which is on `main`. `main` has not compiled `--features
vuln-management` since.

It survived because `make check` builds `eggsec-tui` with default features,
and `eggsec-tui`'s `default` is `[]`. `tabs/vuln.rs` is behind
`#[cfg(feature = "vuln-management")]`, so no tab module is compiled by the
per-PR contract at all. The per-feature sweep is the oracle that compiles them,
and it could not run -- the deep-check job hung in `cargo deny` before it ever
reached the sweep. The stall was hiding a compile failure that had been on
`main` the whole time.

Guard Check 195 makes the class statically visible. For every `impl TabInput
for ...` block under `crates/eggsec-tui/src/tabs/`, it compares the
hand-written method names against the methods the macros that block invokes
actually emit, and fails on the intersection. It parses `tabs/macros.rs` for
each `macro_rules!` body's `fn` names, so it tracks the macros rather than a
hand-kept list of them. A tab that invokes no macro cannot collide; a tab that
defines a method no invoked macro emits is fine -- only the overlap is a
defect. It fails closed: an unreadable or macro-free `macros.rs` is a
failure, not a pass.

Negative-tested against four collisions (the real one; a second method of the
same macro; `hunt.rs` redefining a method `tab_input_boilerplate!` emits;
`fingerprint.rs` redefining one `tab_escape!` emits) and against three cases
that must not trip it (a tab invoking no macro; a tab keeping a method its
macro does not emit; a tab defining a method no macro emits). The embedded
guard was negative-tested on the real tree with `cp` backups, never
`git checkout --`.

The wider gap is recorded rather than papered over: a feature-gated TUI tab
that fails to compile for any other reason is still only seen by the weekly
sweep, because `make check` builds the TUI with default features. Check 195
narrows the gap to the class that actually bit; it does not close it.
With the cargo-deny stall fixed, the deep check's per-feature sweep ran for
the first time on this branch and failed on two profiles:
`eggsec-tui/vuln-management` and `eggsec-tui/full`. The cause was a duplicate
definition of `ensure_input_focus` in `crates/eggsec-tui/src/tabs/vuln.rs` --
a compile failure that had been on `main` since commit c66f094, before this
branch started.

The addendum records the whole chain, because the chain is the point: the
`vuln-management` feature did not compile at all; no fast check built it,
because `make check` compiles `eggsec-tui` with default features (`[]`) and
every tab module is feature-gated; the weekly per-feature sweep is the only
oracle that compiles them; and the sweep could not run because the deep-check
job hung in `cargo deny` first. The stall was not only a stall -- it was
hiding a compile failure that had been on `main` the whole time.

The three files involved are byte-identical between `main` and this branch,
so the record says plainly that the branch did not introduce it, and that the
fix is a repair of an inherited defect rather than new work.

The addendum also states what is *not* closed: a feature-gated TUI tab that
fails to compile for any other reason is still only seen by the sweep. Guard
Check 195 narrows the gap to the class that actually bit; closing it properly
means compiling the TUI under its feature aggregates inside the per-PR
contract, which costs the engine a full-feature build on every push -- a cost
worth deciding deliberately rather than paying by accident in a deep check
that runs weekly.

`plans/registry.md` is a live control surface, so its two cells carry the
finding and point at the addendum rather than leaving the branch's history
reading as though the sweep had been green.
`scripts/check-features-individual.sh` declared its companion feature sets
with `declare -A`, which needs bash 4. macOS ships `/bin/bash` 3.2, where
that line aborts the script with `db: unbound variable` before a single
profile is compiled. So the repository's exhaustive oracle could not be run
locally at all.

That is not a papercut. The sweep is the only thing that compiles the
feature-gated TUI tab modules -- `make check` builds `eggsec-tui` with
default features, which is `[]`. So the one check that could have seen the
duplicate `ensure_input_focus` in `tabs/vuln.rs` was the one that could not
start, and that defect sat on `main` from `c66f0943`.

The mapping is now a `case` function, `engine_feature_set`, with the same six
mappings and the same default (the bare feature name). It behaves identically
under bash 3.2 and bash 5. Verified on bash 3.2: 92 passed, 0 skipped, 0
failed -- the same result CI produced on bash 5.

The sibling `declare -A` in `scripts/check-architecture-guards.sh` had the same
trap. There it sits inside a block that only runs when `crates/eggsec-nse` is
present, which is why the guard script never aborted on macOS in this tree --
but that block exists precisely so that branches still carrying the local
crate keep the historical checks, and on such a branch on a Mac the guard
script would have aborted at the declaration. It is now `nse_rust_modules`,
with the same two mappings and the same empty default that
`${NSE_NAME_MAP[$NAME]:-}` produced for an unmapped name.

Guard Check 196 keeps the trap from coming back. It scans every shell script
under `scripts/` and at the repository root for the bash-4 constructs --
associative arrays, `mapfile`, `readarray`, `${var,,}` / `${var^^}`, `wait -n`,
`[[ -v ]]`, `coproc` -- and fails on any of them. It ignores comments, so a
script may *mention* the construct it refuses to use (two now do, in the
comments explaining the conversion), and it exempts its own detection block,
which necessarily names them. It fails closed: a script it cannot read is a
failure, not a pass.

Negative-tested against nine real violations (each construct, plus the
repository-root script being in scope) and against four cases that must not
trip it (a full-line comment mentioning the construct, a trailing comment
mentioning it, a `#` inside quotes, and the exemption block). The embedded
guard was negative-tested on the real tree with `cp` backups, never
`git checkout --`.

The wider gap is unchanged and stays open by decision: the per-PR contract
still does not compile the feature-gated TUI tabs. The maintainer directed on
2026-10-25 that compiling the TUI under its feature aggregates is not to be
added to `make check` for now, so that remains recorded as a known limitation
rather than paid for silently.
The previous addendum on milestone 015's closure record recorded that the
per-feature sweep could not be run locally -- `declare -A` needs bash 4 and
macOS ships `/bin/bash` 3.2 -- and that the local verification had been done
with a temporary copy of the script rather than the repository's own.

This addendum says plainly what has changed since: the temporary
transformation is now the repository's own script, and the sibling
`declare -A` in the guard script was converted the same way. The sweep runs on
bash 3.2 with 92 passed, 0 skipped, 0 failed -- the same result CI produced
on bash 5.

It also records why the trap mattered more than a portability detail. The sweep
is the only thing that compiles the feature-gated TUI tab modules, and the
one check that could have seen the duplicate `ensure_input_focus` was the one
that could not start. The defect it would have seen sat on `main` from
`c66f0943`.

Guard Check 196 is recorded with its negative-test coverage: nine real
violations caught, four cases that must not trip it left alone, and the
embedded guard negative-tested on the real tree with `cp` backups.

The wider gap is restated as still open, by decision rather than by oversight:
the maintainer directed on 2026-10-25 that compiling the TUI under its feature
aggregates is not to be added to `make check` for now.

`plans/registry.md` is a live control surface, so both the subsystem cell and
the milestone entry carry the repair and point at the addendum.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant