task check's proto:check and ui:check verify committed artifacts rather than
the build, so both fail on correct but unstaged work and both read as a broken
generator. Cost this session twice.
A registered service client always resolves to a non-empty target, so
Services.Get(name).Target != "" proves nothing: a guard meaning "only dial when
configured" dials always, and a test that sets no target reaches for a real
process on the developer's machine.
Also corrects the config skill's input-path table, which still described the
dashboard runtime overlay deleted in 2311529d. The rest of that stale surface
is archie-core-b7dn.
PRD headers carry 26 distinct status strings across docs/prds/. Draft,
Approved and Finalised are the only three, and a finalised PRD is superseded
rather than edited.
runtime-control-plane.md still read "Draft -- not approved" after it was
approved to proceed.
resource_history has carried a row per change since the control plane landed
(value, version, actor, source, request ID, both versions, timestamp), but
nothing could read it. The audit trail existed and was invisible, and the PRD's
"shows failed changes and can correct or roll them back" had nothing to stand
on.
Restoring is deliberately not a command of its own. A revision carries the
value it held, so putting one back is an ordinary replace against the version
currently stored: the restore lands in the same history as every other edit,
under the same optimistic concurrency, instead of rewriting the past.
The revision value crosses the HTTP boundary as raw JSON rather than the base64
a proto bytes field renders as, because the dashboard sends it straight back as
the replace payload.
ResourceStore is exported from the controlplane package and the State Store
composition asserts against it, replacing the inline anonymous interface that
had started to drift from the real requirement.
The control plane replaces this, rather than extending it
(docs/prds/runtime-control-plane.md, "First implementation"). Until now both
paths existed: overlay kept dashboard edits in its own SQLite file beside
archie.db and layered them over the file config at boot and on every reload,
which is the duplicate configuration authority the PRD set out to remove.
Gone with it: the --no-config-overlay flag and ARCHIE_SKIP_CONFIG_OVERLAY
recovery hatch, which existed because a bad overlay row could brick the boot;
ReloadStatus.OverlayUnavailable; and the reload controller's overlay source.
The -config-overlay file overlay is a different thing and stays.
The dashboard's three write seams went too. UpdateConfig, ResetConfig and
UpdateRepoField were assigned only in internal/webui's own tests, so in
production they answered 503 and ConfigView.Editable was permanently false
(archie-core-j28m). Removing Editable would otherwise have flipped the SPA's
controls on, since configEditable read a missing field as true, so the config
pages become what they already were in practice: a read of what each process
is running with. Configuration is written through the control plane.
apply.go survives this deliberately; archie-core-xrux carries the question of
whether its map merge is still guarding the file overlay path.
internal/webui hardcoded the control-plane actor as "operator:web", so every
audit row a dashboard edit wrote to resource_history named a constant rather
than an identity the repository can resolve. The identity API next door already
had the answer: the dashboard authenticates with one shared token and carries
no per-user session, so the actor is the System identity.
Both dashboard paths now derive attribution from one webAudit helper, which
also stops swallowing the request ID error that would otherwise write an empty
idempotency key.
Messaging said the same thing but only checked the sender string was non-empty
before passing it through as the actor. Its set and replace paths now resolve
the sender to an identity and record its ID, on the same resolver the identity
subcommand uses, so a sender that does not resolve cannot change settings.
The Web UI and messaging channels now read and write Archie's runtime
settings through one versioned, audited control-plane API hosted on the
State Store's existing gRPC server: catalog, query, command, watch. Each
feature owns its resource, validation and commands; storage only writes
versions and audit records.
Workflows move with it. Definitions become portable YAML compiled through
a closed, typed step registry and stored as a control-plane resource, so
the yaegi interpretation paths (internal/gate, wfeval, wfextract,
gateeval, gateextract, skillbuild) are deleted rather than carried.
The UI process reads definitions as data: the JSON projection lives in
internal/domain/workflow/task so a dashboard decodes the stored
collection without linking the workflow engine, which cmd/archie-ui's
deletion gate forbids. Shipped definitions ride the catalog descriptor
rather than a bespoke REST route, keeping the API to its four operations.
archie-messaging gains -state-store-target/-state-store-token and reads
channel settings from the database, failing closed when the State Store
is unreachable: the database is authoritative for those settings.
The pane was capped against the viewport, which let it grow taller than the
box it lives in on a short list -- and a sticky element taller than its
container is a sticky element that cannot stick. It is now capped by the
list's own measured height and by the room the window has, whichever is
smaller: both are sizes the pane does not influence, so filling the cap
cannot feed back into it. Stacked, where there is no sibling to be bound by,
the panel caps itself at 62vh the way the task log does, so one large
payload is a scrolling payload rather than a ten-thousand-pixel page.
The capture detail was the app's only sheet: it covered the list it was
opened from, had to be dismissed between rows, and held no address. It is
now a pane that sits with the list -- sticky and internally scrolling on the
wide layout, stacked under the list below 1100px, where selecting scrolls it
into view. The selection rides in the URL (?capture=N) with replace, so a
capture survives a reload and can be linked, and a page opened without a
selection shows the newest event rather than an empty box.
Posts to /webhooks/capture/{source} with a realistic GitHub, Sentry, form or
large payload (or an exact body), reads the capture back so a silent drop is
visible immediately, and names the intake's rate and size limits when it
hits them. Wired as task webhook:send.
A keyed read whose request never settles pinned the panel's loading line
forever; after a quiet minute the read is declared broken so the retry
button appears, and the started-dedupe is released so it can run again.
Also drops the download button from the log's empty state -- a log with
nothing recorded has nothing to download -- and the leftover imports from
the empty-state cuts.
A title that states the fact does not need a description that derives it:
the log, panels, lifecycle lists, dashboard cards, stages, skills and
captures empty states now say the fact once, and keep only the
descriptions that carry an action, a cause, or a distinct reading.
The selects' first options already say All levels / All stages, so the
uppercase captions restated them; the screen-reader names stay. The
no-stage-names notice restated the filter's obvious emptiness and is gone.
The head strip breaks into a full-width control row -- Back, Refresh, and
Start a new run on the left, the forge coordinates pushed to the far edge
-- and the meta row pairs the lifecycle badge with the attempt pager, which
rides in from TaskMetaBar's slot. TaskMetaBar narrows to the served status
badge; the forge links move out of it into the control row where the other
navigation lives.
The attempt selector becomes an icon-ended pager from the registry
pagination primitive: chevrons walk run history, numbers land on an
attempt, and the active page is the attempt on screen. It sits top-right
above the tab card, and the meta line loses the attempt text fact since
the control now carries it.
The page stacked five chrome strips before its content and every state
wrote an essay. The head is now one strip -- title, workflow, actions, a
single meta line -- the retry explainer is gone (the confirm dialog already
carries the commit-discard consequence), and empty states say the fact in
the title without a paragraph re-deriving it.
The bright violet passed the contrast ratio on paper and failed in the
hand: black-on-purple vibrated at button and FAB sizes. The primary surface
is now deep enough for white labels, and link text on the canvas uses a
dedicated lighter tint, since one violet cannot be both a dark-enough
surface and a light-enough text colour. Also drops an empty-state
description that restated its title.
Ctrl/Cmd+K opens a palette over the capability-gated nav entries; the tasks
board refreshes from the shared event stream; config tooltips are
keyboard-reachable; live activity announces politely; and missing event
timestamps render an em-dash instead of a fabricated now.
Task rows render one primary control with the rest in an overflow menu
instead of every catalog action at once; dangerous-action approvals and the
daemon-restarting install confirm by name; the Needs-you tile reads the
served attention statuses instead of a hardcoded pair; and dangerous.go
stops calling the 24-hour approval permanent.
Empty states and card descriptions no longer explain the consequence the
main clause already implies, page descriptions match between the router and
the chat page-index tool, and the Appearance cards lose descriptions that
restated their controls.
Two things reported from use.
The topbar dropdowns shifted the whole page on click. reka's DropdownMenu is
modal by default, which locks body scroll; losing the scrollbar widens the
layout by its width (measured: 15px at 1440), so everything moved sideways. It
also blocked clicking the page while a menu was open. Non-modal is now the
default for every dropdown, not just the nav's: a menu is not a dialog.
Hover descriptions became a preference on /system/appearance, applied in the
Tooltip primitive so a tooltip added later honours it without each call site
remembering. On by default; nothing depends on a tooltip to be usable.
Appearance also lost its duplicated copy: the page, its first card, and that
card's field each said "Appearance" or "Theme" in turn.
The transcript scrolled itself with a watcher that set
`scrollTop = scrollHeight` on every new message and streamed token, reaching
into ScrollArea's internals through `[data-slot="scroll-area-viewport"]` to find
the element that actually scrolls.
That follows the tail and nothing else. It has no notion of the reader having
scrolled away, so every streamed token yanked them back, and no way down for
someone who had deliberately scrolled up.
shadcn-vue's MessageScroller is the component for exactly this, so the surface
is composed from it instead: the provider owns autoscroll, the viewport reports
its edges, the content is a `role="log"` region, and the item carries the scroll
anchor. It buys the part the watcher could not express: once the reader
scrolls, autoscroll stops rather than fighting them, and a "Scroll to end"
button appears.
Verified in the browser: at the tail the root reports `data-scrollable="start"`
and the button is inert; after a wheel scroll it reports `data-scrollable="end"`,
autoscroll disengages, and the button is visible at opacity 1 and reachable. A
programmatic scrollTop does not count as intent, which is right: autoscroll
reclaims the tail unless a person asked for something else.
Every page from the deleted Preact dashboard, rebuilt in Vue 3 + shadcn-vue.
The navigation restructure landed earlier on this branch; this is the surfaces
behind it, and the two are now one app.
Dashboard, Tasks (list and detail), Configuration split six ways, Logs,
Inspector, Mappings, Bindings, Workflows, Skills, Curators, Channels, chat.
Components, not files: docs/prds/dashboard-port-brief.md requires one
component, one job, one file, with shared state in a module beside it. So a
page file composes and holds nothing, and a shape repeated across panes becomes
its own component (LogRow, PageHeader, PanelLoading, WorkflowBar).
Behaviour that had to survive, because each was a fix:
- Live activity's detail is clamped to one line with the payload on the title.
Unclamped, one row made the dashboard 7,481px tall.
- Each health card takes its own height. Equalising left a mostly-empty box
taking a quarter of the first screen once setup was done.
- Tasks: `tab`/`attempt` live in the query string and are written with
router.replace, so a tab click adds no history entry and does not remount.
The list's deep-link reveal honours prefers-reduced-motion.
- LOG_LEVELS is a wire contract (the server matches that CSV server-side), used
unchanged by both log panes.
- The chat panel's Phase 5 list: a FAB that is the only toggle, a morph whose
scale, radius and position interpolate together, no scrim, no close button,
Escape returning focus to the launcher, Stop only while streaming.
- Unconfigured is not broken. A 501 on /api/version or the log stream renders
what is true ("Not configured on this deployment") rather than blank, and a
read-only Configuration says so instead of offering controls that cannot work.
Three things the port decided rather than carried:
- Button gains an `attention` variant and Badge the five status tones, in the
project's own cva. The pill's dot did not come across: the Badge's shape is
the affordance, and the same tone now covers a trend indicator.
- The icon module is not ported. Its name-to-glyph lookup is the pattern
shadcn-vue's rules call out as wrong, so icons come from @lucide/vue at the
call site. The five bespoke glyphs have no consumer yet and become components
if a page draws them.
- The theme control left the topbar for /system/appearance, per the approved
navigation design. ThemeToggle.vue and Placeholder.vue are deleted rather
than orphaned: every route now resolves to a real page.
Also fixes the bundle freshness check failing on the first build after every
change. ui/dist is committed, so nothing ignores it and Tailwind's content
detection scanned it, making each build an input to the next.
The control room, on the primitives from the previous commit. Being the first
page it also settles the shape of the rest: shadcn components for chrome, one
feature folder per page, Lucide imported at the call site.
Carried across deliberately, because each was a fix rather than a layout:
- Live activity's detail is cut to one line and clamped again in the cell, so a
long unbroken token (a path, a URL, a hash) cannot widen the column past the
table. Unclamped, one agent_finish row made the dashboard 7,481px tall.
- Each HEALTH card takes its own content height. Matching them was right while
both held a checklist; once setup is done that card is a title and a line
while Gate pulse carries a gauge and four rows, so equalising them left a
mostly-empty box taking a quarter of the first screen.
The task links are router paths now, not the `#/tasks` hashes the Preact build
used. History routing means a hash is not a route any more, so one that
survived here would navigate nowhere.
Also in this change:
- Button gains an `attention` variant, in the project's own cva. An action that
exists because something needs a human has to look unlike one that is always
present, and `destructive` would overstate it: nothing is broken, it is
waiting.
- The setup panel branches on the state machine rather than on "is setup
present at all". Guarding on presence showed a 100% checklist with every step
struck through where the complete state belongs.
The Preact tree's ui/src/base/ was deleted with the dashboard. This rebuilds
what depended on it, on the shadcn layer rather than as new bespoke markup.
Badge and Card come from the shadcn-vue CLI, so they match the already-vendored
components, and the composed pieces sit on top of them:
- Badge gains the five status variants the pills used, over the palette's status
tokens. The pill's dot did not come across: the Badge's own shape is the
affordance, and the same variant now covers a trend indicator, where a dot
reads as noise.
- base/StatTile.vue uses full Card composition instead of dumping everything
into one content slot, with base/Sparkline.vue and the goodDirection logic
that says whether "up" is good news.
- base/Gauge.vue and base/SegmentBar.vue, both of them: the original exported
two components from one file and budget composition uses the second.
- base/LogRow.vue over lib/log.ts, which holds the LOG_LEVELS wire contract
(the server matches that CSV server-side, so it is not a display choice).
- lib/status.ts, so status colour has one home: a task state, a gate result, a
log level and a trend all draw from the same five kinds.
Two deliberate departures:
The icon module is not ported. Its name-to-glyph string lookup is the pattern
shadcn-vue's rules call out as wrong, and nothing consumes the five bespoke
glyphs anyway: the navigation is text with tooltips. Icons come from @lucide/vue
at the call site, and the five become components if a page draws them.
The gauge's aria-label announces the rounded percentage. It announced the raw
one, so a screen reader read 71.38461538461539% where the screen showed 71%
(bead 86au).
Also lands the four modules the checklist marks copy-verbatim, which encode
bugs fixed just before the delete: dashboard/activity-detail, chat/
command-scroll, workflows/workflow-rows and logs/logs-empty.
Two Vue branches were in flight and looked like competing versions of the same
change. They were not: this branch had the navigation restructure (Phase 4)
and the route table, and the other worktree had the Phase 1 foundation, still
uncommitted. Neither had ported a page. This reconciles them.
What came across from the foundation:
- lib/api.ts, the one client every request goes through, so the CSRF and
Content-Type headers live in a single place, plus the four framework-free
modules it needs: uuid, stream-state, format, task-meta.
- loadTaskMeta() at boot, so /api/task-meta replaces the freeze-dried
lifecycle defaults instead of the catalogue being frozen into the bundle.
- capabilities.ts keeps the other branch's pure hiddenRoutes, but reads
route.meta.section. The other version read route.section, which is always
undefined for this route table, so its capability gating was silently dead.
The route table stays this branch's: internal/gateway's registry test holds it
in parity with the agent-facing page index in both directions, and the other
branch's table fails it with seven errors.
The frame is Tailwind on the shell, not a ported stylesheet. layout.css
described a shell, a topbar and a nav as authored classes, but the topbar is a
Vue component like every other surface and emits none of them, so two thirds
of that file had no consumer. What the frame needs is now the shell element's
own utilities plus the canvas, focus floor and motion preference in
style.css's base layer, where a global element rule belongs. Verified equal to
the stylesheet it replaces: 20px radius, hairline border, blur(28px)
saturate(1.2), and the narrow-screen collapse.
Also fixes the bundle freshness check failing on the first build after any
change, which had cost both branches of this port a rebuild-and-retry. ui/dist
is committed, so nothing ignores it and Tailwind's content detection scanned
it, making every build an input to the next: class strings left in the bundle
generated utilities for classes nothing references any more, so an unchanged
tree built a different bundle. Excluding it also drops ~12KB of dead CSS.
Takes style.css, lib/theme.ts and index.html's pre-paint script from the
palette work on worktree-groovy-imagining-widget (73e602a7..72034249), leaving
its flat topbar and route table behind. The theme is a data-theme attribute set
before the first paint, so a reload does not flash the wrong palette, and
color-scheme moves with it.
The outlet takes the viewport height below the topbar so an empty state has
somewhere to sit.
Five top-level items instead of eleven flat ones: Dashboard as a link, then
Work, Agent, Events and System as dropdowns, with each item's one-line
description on a hover tooltip. Configuration dissolves into /system/{status,
appearance,tasks,models,repos,advanced} and /settings redirects to the first of
them, so existing bookmarks still land somewhere. Logs gets a nav entry for the
first time.
The bar is composed from named components rather than one file: Brand (Logo,
BrandName), Nav (NavTrigger, NavGroup, NavItem), SearchBar, SupportLink,
ThemeToggle, ProfileDropdown. The nav model reads the route table, so a route
and its nav entry cannot disagree, and a group whose every child is gated off
is dropped while a group left with one child stays a dropdown.
The Go page registry moves with it, which its parse-the-route-table test
enforces.
createWebHistory with base "/". The Go server already falls back to index.html
for any unmatched path and [web] has no path-prefix option, so the dashboard is
always at the root.
legacy-hash-redirect.ts rewrites `#/path` links minted before this change.
Verified against archie-ui rather than the Vite dev server: /tasks, /tasks/42
and /settings all serve index.html with assets resolving, and #/settings lands
on /settings.
Four review agents checked the bootstrap and the migration checklist against
the deleted tree and the Go handlers. Three found real problems.
The shadcn-vue CLI's default font resolved to a Google Fonts @import. archied
is deployed on LAN-only and air-gapped hosts, where that silently falls back to
a generic sans and makes an admin tool that otherwise has no third-party calls
start making one. Now @fontsource-variable/geist, self-hosted: five woff2 files
in dist and no external URL left in the bundle.
vite.config.ts used __dirname for the @ alias, which Vite 8 already warns is
unsupported under its native config loader. Now import.meta.url. Dropped the
leftover template vite.svg.
The checklist gained what the review found missing, most of it consequential:
- main.jsx was never named as a source, so the jump-to search, the `soon:`
nav treatment, the boot-time task-meta re-render and the route-keying rule
(keyed on path+params but NOT the query, so a tab switch does not remount)
had no home. vue-router needs an equivalent key strategy.
- css/layout.css is 498 lines and holds the shell, the chat dock and morph,
and every breakpoint Phase 5 described only in prose. Named as the source
to port from rather than left to reverse-engineering.
- Six further CSS files carried behaviour with no mapping: focus-visible,
.sr-only, the global prefers-reduced-motion override, and the pill colours
a Badge port has to match.
- Chat's content features -- session switching, persona and model selectors,
inline tool-call rendering -- were absent; Phase 5 described only chrome.
- Configuration's editable-vs-read-only dual mode (503 when the process only
holds a published snapshot) is architecture, not styling.
- Tasks writes tab/attempt state with history.replaceState specifically to
avoid a remount per tab click.
- statTile also exports Sparkline, gauge also exports SegmentBar, and five
icons have no 1:1 Lucide equivalent, so those swaps are design calls.
- LOG_LEVELS is a wire contract matched by splitCSV server-side.
Corrections: the API surface is 48 methods plus two SSE subscribers, not ~45.
Mutations require both X-Archie-CSRF: 1 and Content-Type: application/json,
answered 403 and 415 -- the likeliest silent breakage after the port, now
stated exactly. My claim that a test enforced "no second fetch()" was wrong:
that text-scan was deliberately removed upstream for testing the file's wording
rather than its behaviour. The real guard was per-method header classification,
flagged as the one test worth bringing back first.
The 106px clipping figure is a live measurement and not recoverable from git,
so it now carries the viewport and both edge positions.
Records what has to exist again, the contracts that break silently if missed
(embed output shape, the Go route registry, capability gating, the single
fetch path, SSE teardown), and the behaviour shipped today that lives only in
the deleted tree -- the chat launcher, the topbar shrink rules, the clamped
activity detail, the corrected contrast tokens, the readyState-derived stream
state.
Five deleted modules are framework-free and port by rename; each encodes a bug
fixed today, so re-deriving them by hand is how those bugs come back.
Sam owns this codebase and reads Vue fluently, not Preact; a UI its maintainer
cannot read is the liability that outweighs the port. shadcn-vue is Vue-only,
so adopting it means the framework moves with it.
Scaffolded per the official Vite guide: `npm create vite --template vue-ts`,
Tailwind v4 via @tailwindcss/vite, `shadcn-vue init` (Reka UI, Lucide, neutral
base, CSS variables). Button and DropdownMenu are added, the latter being what
the pending navigation restructure needs.
Two deviations from the guide, both forced:
- The guide sets `baseUrl` alongside `paths`. TypeScript 6 deprecates
`baseUrl` and errors on it, and this project is heading for TS 7 native, so
`paths` stands alone and resolves relative to the config file. Not a
downgrade: the scaffold's typescript ~6.0.2 is untouched.
- vite.config.ts keeps `base: "./"` and unhashed asset names. ui/embed.go
embeds a committed dist/, served from a path the build does not know;
hashed names would also orphan a file in git on every rebuild.
The Preact app and its 43 test files are deleted rather than ported, on Sam's
instruction: tests return when there is behaviour worth pinning rather than a
port to re-assert. `task test:ui` is now a vue-tsc typecheck, which is what
would actually catch a broken component; an empty `npm test` would pass
vacuously.
ui/src/router/index.ts carries the route table and is the new source of truth
for TestDashboardPagesRegistryCoversEveryRoute, which parsed main.jsx before.
Keeping that contract alive matters: it is what caught the stale /chat entry
earlier today. Every route resolves to a named placeholder view, so an unported
page is visibly unported rather than blank.
golangci-lint now excludes ui/node_modules. The dashboard toolchain pulls in
`flatted`, which ships a Go implementation beside its JavaScript, and the gate
was failing on complexity in a vendored third-party file.
The shadcn MCP server is registered in the root .mcp.json. `shadcn-vue mcp init`
writes it to the directory it runs in, which for a nested ui/ is a path Claude
Code never reads.
Four P1 findings from the audit.
Workflows claimed "No workflow runs yet" directly above stage tables listing
those runs (archie-core-rcbf). The rows were built from the definition list
alone, so a workflow with statistics but no definition produced no row at all.
workflow-rows.js now merges both sides: a run is evidence the workflow exists.
The producer is also at fault -- /api/workflows returns definitions: [] from
the archie-ui composition while the daemon logs a registry of seven -- which
also means "Start work" never renders there. Filed as archie-core-3tij.
The logs page said "Durable history unavailable" twice and promised live logs
from a stream that had stopped (archie-core-c5bz). EventSource fires onerror
both for a retry and for a give-up; readyState tells them apart, so a dead
stream now reports "unavailable" in red instead of "reconnecting" in amber
forever. The toolbar says "Live only" and the empty state carries the
explanation, each once. An unconfigured update check (501) now says so on
Configuration rather than rendering nothing at all.
Contrast (archie-core-umdn). --fg-subtle was 3.37:1 dark and 2.72:1 light,
used for every KPI caption and column header; both move to values clearing
4.5:1 on every surface they actually land on, down to surface-hover at 4.51.
White on the dark accent was 3.2:1 on the active nav item and every primary
button: --accent-fg becomes near-black at 5.96:1 and the accent itself is
untouched, since it is also the link colour and reads correctly on the canvas.
Swept four routes in both themes: no remaining failures outside elements
painted on a gradient, which a compositing check cannot judge and which are
white on blue-purple anyway.
The HEALTH cards take their own height again
(archie-core-1786637500926-421-7c63bcd3). Equalising them was right when both
held a checklist; once setup completes, that card is a title and one line
while Gate pulse carries a gauge and four rows, so matching heights left a
~400px empty box in the first screen.
Installing a release and approving a gated action are things you do to the
deployment, not things you say to Archie. They lived in the chat surface only
because that is where they were first built, and in a launcher panel a few
hundred pixels wide they crowded out the conversation (archie-core-tf20).
Both are new cards in ui/src/settings/operator-cards.jsx, wired into
Configuration beside the read-only UpdateStatusCard that was already there.
Behaviour is unchanged from the chat panel, including accepting both the
capitalised and lowercase checkpoint field shapes the API has returned.
A 501 from either endpoint renders no card at all rather than an error: a
deployment that does not wire update-checking should show nothing, which is
what the dev stack does.
Reload Telegram deliberately did not move. It was never an API call -- the old
handler sent the "/restart" chat command as a message -- so a Configuration
button would have to post a chat message to reach the adapter. It stays as
/restart in the palette until the cross-process restart RPC exists
(archie-core-ry4k); archie-core-oif3 tracks landing it here afterwards.
Remediation from testing the launcher (archie-core-ifay), plus the morph Sam
asked for.
The panel grows out of the launcher rather than fading in beside it: closed, it
is collapsed to a pill the size of the button and translated over it; open, it
is the full panel. Scale, border-radius and position interpolate together, and
the contents fade in once the shape has mostly arrived, so the button reads as
becoming the panel. The launcher stays visible throughout and is the only
control that opens and closes it, so the panel carries no close button.
- Header shows the open conversation's name; ChatApp owns the header now,
because the title and the actions that change it belong to the same
component.
- New chat became the Lucide message-circle-plus glyph and moved into the
header. Added to the icon set, which is the same 24-grid stroke system.
- The commands accordion is gone. The composer's slash palette was already
the command surface and floats above the input; having both was two
answers to one question.
- Arrow keys scroll the palette so the selection stays visible. The decision
is pure arithmetic in command-scroll.js, including the case of an option
taller than the list, which aligns to its top so the command name is not
the part scrolled out of sight.
- The settings popover closes on any pointerdown or focus outside it.
- Stop renders only while a reply is streaming.
- The composer keeps focus and stays writeable during a send, so the next
message can be typed while one streams. It was `disabled`, which also made
the focus() in the send's finally block a silent no-op. sendMessage already
refuses a second concurrent turn via isSendingRef.
- Composer actions sit at the right of the input row, the resize handle is
gone, and the Enter/Shift+Enter hint is removed.
- Message bubbles dropped their "Archie"/"You" labels; side and colour
already say who spoke.
- Fixed an empty band under the composer: the panel still declared two grid
rows from when the launcher owned the header.
Four P0 defects from the frontend audit, plus the one-line theme fix that was
making every one of them look worse.
Chat is a floating launcher and the panel it opens, not a route
(archie-core-yuvg, archie-core-hesx). /chat rendered an empty page with a
drawer over it, and that drawer hosted the full-page chat workspace: a page
title, a conversations column, a four-control action row and a command-help
column, all inside 440px. Measured at 1440x900, .chat-workspace was 174px wide
holding 270px of content and the composer ran off the viewport.
- The Chat nav entry, the /chat route and the topbar chat icon are gone;
the launcher is the single way in.
- The panel anchors to the launcher and opens leftward from it, sharing its
bottom edge, so the button never moves. No scrim and no scroll lock: the
page stays readable and clickable, which is the point of asking Archie
about the page you are on.
- Conversations became a switcher in a compact bar; personality, provider
and model moved into a disclosure beside it; the empty state and composer
dropped to panel type scale.
- The launcher renders outside .shell because .shell's backdrop-filter is a
containing block for fixed positioning, which otherwise pinned the button
to the scrolling shell instead of the viewport.
- Update-check, Dangerous actions and Reload Telegram left the panel; their
api.* calls are untouched for the rehome to Configuration
(archie-core-tf20).
The topbar no longer clips its utility cluster (archie-core-mkb3). brand, nav
and topbar-end were all flex:none with no wrap above 1220px, and .app sets
overflow:hidden, so between 1221px and ~1582px the avatar, theme toggle and
documentation button were cut off with no way to reach them. The nav is now
the one region allowed to shrink, the search collapses to its icon below
1500px, and the nav wraps to its own row below 1270px where it stops fitting.
Live activity clamps its detail column (archie-core-qo7f). An agent_finish
payload rendered raw turned one row into six viewports and the dashboard into
7,481px. The cell shows the first meaningful line; the full text stays on the
title.
color-scheme is bound to the active theme (archie-core-nm0y), so scrollbars
and native controls stop rendering light inside the dark UI.
cockpit binds 9090 by default on this host, so task dev could not start the
State Store and every service came up without one. dev.toml's own comment
says to move the listen/target pair when that happens.
The generated symbol tables carried 25 hand-added nil guards across three
packages, re-applied by hand after every regeneration because `yaegi extract`
does not emit them. Regeneration silently dropped them, and three package docs
instructed the next agent to put them back.
The guards also answered the wrong way. A nil WResolve returned ("", nil), so a
malformed secret engine served an empty secret and reported success; a nil
WStop reported a clean shutdown for a module that never ran one.
Reject the wrapper where it enters the daemon instead. Yaegi type-checks
"var X Iface = impl{}" and refuses an incomplete impl on its own, but the
wrapper type is exported into the symbol table, so interpreted code can build
one directly and struct-literal semantics leave the omitted method nil.
Resolve now names the missing method and skips the plugin.
Generated tables are used verbatim again. Also names the wanted type on a
failed assertion, which formatted as "want <nil>" for every interface target.
`git merge-base --is-ancestor` answers a topology question, so it reports a
landed repair as never-landed for every squash merge and for any rebase merge
that had to replay commits. This repository squash-merged its last fifteen
pull requests (everything merged up to 2026-09-18 used merge commits), so the
check documented in the failure-archaeology skill is a false negative for all
of them.
Add scripts/on-main.sh: `--is-ancestor` stays the offline fast path, and a
non-ancestor falls back to the GitHub API, where merge state is recorded
independently of the commit graph. It separates landed (0) from not-landed (1)
from undetermined (2) instead of folding an unanswered question into a
negative -- `if on-main.sh <ref>; then` is the mistake it exists to prevent.
Verified against live data: ancestor -> 0, squash-merged PR #899 -> 0, closed
unmerged PR #896 -> 1, commit in no pull request -> 1, local-only commit
GitHub has never seen -> 2, bad ref / bad base / no args / bad option -> 2.
Registry carried no plugin identity, discovery, compatibility or
lifecycle, so it was never the seed for the approved internal/domain/plugin
package. Host, Manifest and Module are, and they stay.
Regenerating pluginextract strips the interface-wrapper nil guards, so
those are restored by hand; the only intended change to the generated
table is dropping the Registry symbol.
Completes 856c6a8f. The measurement belongs next to the omission: without it
the next person to notice goimports missing re-adds it and pays ~135s per
gate run.
* fix: address the Greptile findings on the merged PRs
Four valid review findings from PRs #892, #893, #898 and #899, which were
merged without the comments being read.
- Config.Clone left the new diff-cap pointers aliased (#899, mine). Clone
deep-copies every reference field, including the *bool beside it, so a
clone could write the cap through to the published snapshot. Both the
top-level field and the identity overrides are copied, with the clone test
extended to cover them.
- providerOutcomeRecorder.record could report an older call as the latest
(#892). The completion time is taken before the lock, so two concurrent
calls can reach the lock in the opposite order to their completion and the
unconditional store overwrote the newer outcome. It now keeps the newer,
via a recordAt seam that makes the reordering testable.
- Curator model calls bypassed the recorder (#892). curatorLLMRunner calls
the runtime directly, so a daemon whose only recent model traffic was
curator work reported "no calls attempted yet" while the provider was
demonstrably reachable. It records at its own adapter, and sendChatTurn's
"single choke point" comment is corrected to say there are two.
- A provider error reached /status raw (#892), unlike channel details, so a
multiline or oversized error broke the one-line-per-fact layout. Both now
share one bounded formatter.
Found while fixing the curator path: agentexec.NewRuntime returns nil when no
provider is configured, and a nil *runtime.Runtime panics on its first method
call, so a curator asking for a completion took the daemon down. It now
returns an error, and records nothing -- a local misconfiguration is not a
provider call.
Not fixed, filed instead: the shared lastPollAt masking a stuck identity, the
container max-uptime callback resurrecting teardown bookkeeping, the
dashboard dropping a served-only status filter on cold load, and the route
registry test's line-by-line parser.
* fix(build): drop goimports from the gate's formatter set
`task check` spent 136 of its 167 seconds in `task fmt`, and 134 of those
136 in one formatter: goimports alone over the tree.
golangci-lint's goimports formatter calls imports.Process once per file,
which builds a fresh x/tools ProcessEnv each time, so
internal/imports.getFixesWithSource re-reads modindex.Read($GOMODCACHE) per
file. On this machine that index is 62.7 MiB / 2,081,070 lines (an 11 GiB
module cache), and modindex's in-process memo does not take effect: 3 files
read 187.9 MiB back, 15 files open the payload 15 times. That is ~53 GiB of
I/O and CSV parsing per run, and it is linear at ~155 ms per file (122 files
-> 18.8s, 864 -> 133.8s). Pointing the index cache elsewhere drops the same
command to 3.9s.
The same analyzer runs under `golangci-lint run`, so a cold cache pays it
again: 169s cold with goimports, 31s without -- which is what CI and archied's
own PR gate see, since only `fmt` never caches locally.
Removing it costs no enforcement. gofumpt and gci remain, `task lint` still
reports formatter drift as an issue, and the whole-tree fmt is now 2.2s with
the tree byte-identical. What is given up is goimports' convenience of
adding and removing import lines, which compile errors already cover.
The examples/secret-engines exclusion stays: gofumpt and gci leave those
Yaegi programs alone today, but the exclusion is the stated invariant that a
formatter must not rewrite the imports of files it cannot type-check, and
TestFormattersExcludeInterpretedSecretEngines holds it. Its comment no longer
pins the reason to the formatter that was dropped.
* fix(gateway): stop /status promising and mis-reporting health it cannot see
Two findings from the cloud review of #892.
Title generation no longer records chat-model health. It runs detached after
a first turn under its own 30s bound and its error is swallowed by the
caller, but it shared the process-wide outcome recorder, so a title that
merely timed out overwrote the health line with "failed" -- reporting a
broken provider on the strength of a call no user was waiting for.
The /status command description no longer claims "workers" and "channels".
Neither can render: newStatusHealth reads the container pool and the poll
loop from boot, but the only production router.Health assignment is in
setupGatewayChat, which runs solely in the archie-gateway process, where
neither exists; channels is nil since the Messaging Service took the
front-ends. Only the broker and chat-model lines actually appear, so that is
what the help text now says.
The underlying split -- daemon owns the facts, Gateway owns the Router -- is
filed rather than patched here: it needs either a cross-process health
contract or a ratified two-section /status, not a quick wire-up.