Files
archie/cmd/archie-messaging/architecture_test.go
T
sam a7d6cc8c9d refactor(messaging): sever the Messaging Service from the store and workflow runtime
The PRD's deletion gate for the Messaging Service could not pass: go list -deps
./cmd/archie-messaging linked modernc.org/sqlite, internal/store,
internal/domain/workflow and internal/agentexec -- all through one import,
archiemessaging/run.go -> internal/app/controlplane, from which the service used
three symbols. The decision was to sever rather than amend the gate, because a
boundary you whitelist around is no longer a boundary (archie-core-1ng1, recorded
in docs/architecture/migration-decisions.md).

Measured before touching anything: internal/app/controlplane was the ONLY direct
import of the service that dragged those runtimes -- every other one was clean --
so severing this one dependency is sufficient for the gate.

Moved into the new internal/infrastructure/controlplanerpc: the generic resource
client (NewRPCClient, Query), the RuntimeChatConfig projection, the reader
interface (now the exported ResourceReader), the wire sentinels, the status
mapping (now ClientError), and the channel-settings document with its decode --
ChannelSettings, TelegramSettings, WebhookChannelSettings, EmailSettings,
RateLimitSettings, ChannelDuration, DecodeRenamingLegacyKeys.

internal/app/controlplane keeps the store-backed server, the Definition registry,
every kind's seed/validator/Normalize, the schema derivation, and its
resource-specific reads and watches. Its Client embeds the new one, so the read
path has one implementation while the workflow, persona and cronstore reads stay
with the processes that already link those engines. The documents are type-aliased
back into this package so the store-backed side reads them by the names it has
always used: one definition, not a copy on each side of the boundary.

The gate is now enforced by cmd/archie-messaging/architecture_test.go, measuring
the linked binary against the PRD's banned list, with one exception checked in
both directions: internal/domain/workflow/task, the Task status and view
vocabulary whose own dependency set holds none of the banned runtimes. The UI gate
carries the same entry for the same reason, and the fleet skill names it as the
precedent.

Verified: task check exit 0. The gate was red-proofed twice -- banning
internal/channels fails it, and removing the workflow/task exception fails it --
so neither the loop nor the exception is decorative.
2026-09-22 07:26:55 +10:00

126 lines
4.6 KiB
Go

// This file enforces the objective half of the Messaging Service deletion gate
// (docs/prds/messaging-service-boundary.md, "Deletion Gate and Verification"): the
// linked binary carries no state-store, daemon, workflow, forge, gateway or
// dashboard runtime. 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. That is exactly how this package came to link the
// SQLite driver, the workflow engine and agentexec through one import of
// internal/app/controlplane (archie-core-1ng1).
package main
import (
"os/exec"
"strings"
"testing"
)
const modulePath = "github.com/samcharles93/archie-core/"
// bannedCategory is one class of runtime the Messaging Service 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
}
// deletionGate is the PRD's list, one entry per category it names. Two deliberate
// absences:
//
// - internal/channels is NOT here. The Messaging Service hosts those adapters;
// it is the process they live in, not a consumer of them.
// - internal/gatewayrpc needs no exception. It is the Gateway's contract, not
// its runtime, and it does not sit under the internal/gateway prefix -- the
// check below would catch it if it ever did.
var deletionGate = []bannedCategory{
{"state store", []string{
"modernc.org/sqlite",
modulePath + "internal/store",
}},
{"daemon runtime", []string{
modulePath + "internal/daemon",
modulePath + "internal/app/archied",
modulePath + "internal/container",
modulePath + "internal/worktree",
}},
{"workflow engine", []string{
modulePath + "internal/domain/workflow",
modulePath + "internal/agentexec",
modulePath + "internal/taskrun",
}},
{"forge client", []string{
modulePath + "internal/forge",
modulePath + "internal/forgerpc",
}},
{"gateway runtime", []string{
modulePath + "internal/gateway",
}},
{"dashboard", []string{
modulePath + "internal/webui",
}},
}
// gateExceptions are packages under a banned prefix that carry only contract,
// vocabulary or view types, so linking them is the intended end state rather
// than a tolerated leak. internal/domain/workflow/task is the Task status and
// view vocabulary the Messaging Service renders; its own dependency set holds
// none of the banned runtimes, which is what makes the exception defensible
// rather than a hole. cmd/archie-ui/architecture_test.go carries the same entry
// for the same reason.
//
// Each one must stay linked: an exception nothing needs any more is a hole in
// the fence, so this list is checked in both directions.
var gateExceptions = []string{
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 TestMessagingProcessLinksNoRuntimeItOnlyDials(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)
}
linked := make(map[string]bool, len(gateExceptions))
for importPath := range strings.FieldsSeq(string(listed)) {
if excepted(importPath, linked) {
continue
}
for _, category := range deletionGate {
for _, prefix := range category.prefixes {
if !under(importPath, prefix) {
continue
}
t.Errorf("archie-messaging links %s (%s); the Messaging Service reaches that capability over a contract, never in-process (docs/prds/messaging-service-boundary.md, deletion gate)", importPath, category.name)
}
}
}
for _, exception := range gateExceptions {
if !linked[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)
}
}
// A gate that cannot fail, and a `go list` that returns nothing usable, both
// read as a pass. This pins the one thing the loop above assumes.
if !strings.Contains(string(listed), modulePath+"cmd/archie-messaging") {
t.Fatal("go list -deps returned a list that does not even name this package: the gate asserted nothing")
}
}
// excepted reports whether importPath sits under an excepted package, recording
// the ones actually linked so a stale exception fails.
func excepted(importPath string, linked map[string]bool) bool {
for _, exception := range gateExceptions {
if under(importPath, exception) {
linked[exception] = true
return true
}
}
return false
}