test(ui): enforce the UI process deletion gate on every check

The severance that cut archie-ui's package closure from 68 to 26 was a
one-time measurement: nothing re-ran go list -deps, so the next import of
a type sitting beside a runtime would have relinked that runtime silently
and left the suite green.

TestUIProcessLinksNoDaemonRuntime re-measures the closure and fails on any
package in a banned category, with the categories named as the PRD names
them. Its two exceptions are checked in both directions so the allowlist
cannot decay into an open prefix. database/sql is matched exactly rather
than as a subtree: database/sql/driver arrives from google/uuid's
Valuer/Scanner and brings no driver with it.

Verified by violation: one blank import of internal/store relights eleven
banned packages across three categories.
This commit is contained in:
sam committed 2026-09-11 20:00:41 +10:00
1 parent 1ec08a73dc
commit 51234eaed4
2 files changed
+171 -3

No files matched your search

+153
View File
@@ -0,0 +1,153 @@
// This file enforces the objective half of the UI Service deletion gate
// (docs/prds/ui-service-boundary.md, "The deletion gate is objective"). The
// composition half -- no config.Holder, no concrete *store.Store, no Gateway
// runtime type -- is pinned by internal/app/archieui's
// TestComposeUIServerHoldsNoDaemonState. This pins the claim that test cannot
// see: that the linked binary carries no daemon runtime at all. Go imports
// are atomic, so a single reference to a type living beside a runtime relinks
// the runtime, and the severance holds only while something re-measures it.
package main
import (
"os/exec"
"strings"
"testing"
)
const modulePath = "github.com/samcharles93/archie-core/"
// bannedCategory is one class of runtime the UI process must not link. The
// names are the PRD's wording; the prefixes are how that class appears in
// this module.
type bannedCategory struct {
name string
prefixes []string
}
var deletionGate = []bannedCategory{
{"SQL/store implementation", []string{
"modernc.org/sqlite",
modulePath + "internal/store",
}},
{"daemon runtime", []string{
modulePath + "internal/daemon",
modulePath + "internal/app/archied",
modulePath + "internal/container",
modulePath + "internal/worktree",
modulePath + "internal/worktreerpc",
}},
{"workflow engine", []string{
modulePath + "internal/domain/workflow",
modulePath + "internal/taskrun",
modulePath + "internal/agentexec",
}},
{"forge client", []string{
modulePath + "internal/forge",
modulePath + "internal/forgerpc",
}},
{"channel runtime", []string{
modulePath + "internal/channels",
}},
{"model runtime", []string{
modulePath + "internal/gateway",
modulePath + "internal/infrastructure/modelcatalog",
modulePath + "internal/domain/embedding",
modulePath + "internal/infrastructure/embedding",
}},
{"secret runtime", []string{
modulePath + "internal/secret",
}},
{"agent tooling", []string{
modulePath + "internal/tools",
modulePath + "internal/skill",
modulePath + "internal/skillscript",
modulePath + "internal/yaegiutil",
modulePath + "internal/plugin",
}},
{"memory and curator runtime", []string{
modulePath + "internal/memory",
modulePath + "internal/domain/memory",
modulePath + "internal/infrastructure/memory",
modulePath + "internal/domain/curator",
modulePath + "internal/infrastructure/sessioncurator",
modulePath + "internal/infrastructure/skillcurator",
}},
{"broker transport", []string{
modulePath + "internal/eventbus",
modulePath + "internal/infrastructure/eventbus",
modulePath + "internal/natsrpc",
}},
}
// bannedExact is banned as a package rather than as a subtree. Nothing may
// reach the database through the UI process, but database/sql/driver and its
// support package arrive from github.com/google/uuid's Valuer/Scanner methods
// and bring no driver with them.
var bannedExact = map[string]string{
"database/sql": "SQL/store implementation",
}
// gateExceptions are packages under a banned prefix that carry only contract,
// vocabulary or view types. The severance moved the UI's references here so
// the parent runtime would stop linking, which makes them the intended end
// state rather than a tolerated leak.
//
// Each one must stay linked. An exception the UI no longer needs is a hole in
// the fence, so this list is checked in both directions.
var gateExceptions = []string{
modulePath + "internal/channels/status",
modulePath + "internal/domain/workflow/task",
}
// under reports whether importPath is prefix or a package below it.
func under(importPath, prefix string) bool {
return importPath == prefix || strings.HasPrefix(importPath, prefix+"/")
}
func TestUIProcessLinksNoDaemonRuntime(t *testing.T) {
listed, err := exec.CommandContext(t.Context(), "go", "list", "-deps", ".").CombinedOutput()
if err != nil {
t.Fatalf("go list -deps .: %v\n%s", err, listed)
}
linkedExceptions := make(map[string]bool, len(gateExceptions))
for importPath := range strings.FieldsSeq(string(listed)) {
if excepted(importPath, linkedExceptions) {
continue
}
if category, banned := bannedExact[importPath]; banned {
reportLink(t, importPath, category)
}
for _, category := range deletionGate {
for _, prefix := range category.prefixes {
if under(importPath, prefix) {
reportLink(t, importPath, category.name)
}
}
}
}
for _, exception := range gateExceptions {
if !linkedExceptions[exception] {
t.Errorf("%s is excepted from the deletion gate but is no longer linked; drop the exception instead of leaving its prefix open", exception)
}
}
}
func reportLink(t *testing.T, importPath, category string) {
t.Helper()
t.Errorf("archie-ui links %s (%s); the UI process reaches that capability over a contract, never in-process (docs/prds/ui-service-boundary.md, deletion gate)", importPath, category)
}
// excepted reports whether importPath is allowed past the gate, recording
// which exception admitted it so a stale one is reported.
func excepted(importPath string, linked map[string]bool) bool {
for _, exception := range gateExceptions {
if under(importPath, exception) {
linked[exception] = true
return true
}
}
return false
}
+18 -3
View File
@@ -230,9 +230,24 @@ severed, each at the producer:
into `internal/domain/workflow/task`; the pipeline engine stays in package
`workflow`, which keeps aliases. The UI process links the vocabulary only.
Remaining for Phase 3 closure: the architecture tests asserting the absence of
`config.Holder`, concrete store/gateway runtime types, and direct SQLite imports
in the UI service, plus the end-to-end smoke suite over real processes.
The gate is enforced, not just measured. `cmd/archie-ui/architecture_test.go`
re-runs `go list -deps` on every `task check` and fails on any package in a
banned category, so a single reference to a type sitting beside a runtime
cannot quietly relink it. Its exception list (`internal/channels/status`,
`internal/domain/workflow/task`) is checked in both directions: an exception
the UI stops needing is reported, so the allowlist cannot decay into an open
prefix. `internal/app/archieui`'s `TestComposeUIServerHoldsNoDaemonState`
covers the composition clauses, failing on a non-nil `config.Holder`, a
concrete `*store.Store`, or a Gateway that is not the gRPC client.
One piece of residue remains visible: `webui.Server` still declares
`Cfg *config.Holder`, because the daemon keeps a `webui.Server` as the renderer
that builds the published `ConfigView` snapshot. The UI process never receives
a holder, and the composition test fails if it ever does, but removing the
field outright means moving that renderer and the readiness probes off
`webui.Server` onto the daemon's own configuration owner.
Remaining for Phase 3 closure: the end-to-end smoke suite over real processes.
## Non-goals and open work