Repository navigation
Conversation
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).
…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.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
feat/auto-20261022-76692679on currentmain.m005c-eggsec-http-adapterwork isolated.Verification
CARGO_PROFILE_DEV_DEBUG=0 CARGO_PROFILE_TEST_DEBUG=0 CARGO_INCREMENTAL=0 make checkpassed locally.Dependabot review