Card Artifact Tags
Clickable Card Artifacts
Structured artifact tags on activity cards, opened through the existing TUI pager.
0 milestones 4 tasks 10 agents
2 plan 4 execute 4 review
227k peak context
113k median execute
1h 10m total 13m 8s per task
2m 53s plan 44m execute 8m 37s review
45 edits 328 commands
codex harness
This run made Gantry's activity cards point directly at the files behind the work they describe. The central rule was that tags come from structured run and card data plus real artifact existence checks, while generated card prose stays readable and no longer carries raw filesystem destinations.
The work split cleanly into a resolver, a rendering and hit-region layer, feed activation, and prose cleanup. That separation let each sprint add one contract for the next surface to consume instead of asking a fresh worker to reason about derivation, layout, input routing, and copy hygiene all at once.
How this walkthrough is structured
Feature
What did the run build and ship?
The current TUI still derives card artifact tags from structured state, renders only visible clickable regions, opens them in the shared pager, and suppresses path noise in card text.
Build
How did Gantry structure the work?
The run stayed green while moving from a pure artifact resolver through rendering and activation to a final prose cleanup pass.
Tag Data Model
2 agents 13m 27s wall time 113k peak context
The resolver still lives in the TUI artifact module. It maps structured card stages to human tag kinds such as environment, plan, sprint, report, log, and ledger, and it checks each candidate path before returning a tag. Agent log tags are added from the card's own log source, so absent files do not become dead entries.
This sprint carried the lowest-level contract: given a card and a run artifact directory, return the ordered tags that actually have files behind them. Its brief explicitly excluded prose parsing, rendering, and interaction, which made the work small enough for a fresh agent to prove with focused model tests. The recorded run stayed green, with review followed by another gate pass before the next sprint leaned on the contract.
Render Card Tags
2 agents 12m 48s wall time 109k peak context
Activity-card rendering still asks the resolver for tags, adds them to the footer line, and records hit regions from the same layout data used to draw the text. Narrow cards stop adding tags before they would be clipped, and cards without artifacts avoid empty footer space. The registry is rebuilt with the feed blocks, so overlays and clipping keep hidden tags from being treated as clickable.
This sprint consumed the resolver without changing what artifacts mean. Its boundary was layout and registration: draw compact footer tags for cards that have artifacts, and record only the tag regions that were fully painted in the current frame. The gate and review stayed green, which showed the data contract could be wired into rendering without reopening the resolver.
Open Feed Tags
2 agents 24m 35s wall time 227k peak context
Mouse handling still tracks a press that starts on a visible artifact tag and opens only when the release lands on the matching tag without becoming a drag. Keyboard action dispatch still exposes open-card-artifact behavior for the selected card, opening directly for a single tag and using the View menu chooser when several are available. Every path goes through the shared artifact reader and pager rather than a separate file viewer.
This was the highest-risk sprint because it joined the previous contracts to mouse and keyboard behavior on the live feed. The brief kept it out of viewer design and general clickable text, so the worker only had to route visible tag activation into the existing read-only pager. It passed without a recorded repair, which means the hit-region boundary held under the interaction cases the sprint had to cover.
Clean Card Prose
2 agents 7m 21s wall time 109k peak context
Card rendering still suppresses path-shaped text before descriptions, notes, and footer status words are displayed. The tagged-card tests still assert that the destination is visible as a tag while the raw path is absent from card prose. The opening model remains structured-data based, so the display guard removes clutter without becoming an input parser.
This closing sprint depended on tags already carrying the file destination, so it could focus on display hygiene instead of opening behavior. Its brief paired prompt cleanup with a defensive render-side guard, while preserving the rule that tags are never derived from prose. The recorded gate and review stayed green, so the cleanup landed as a narrow finishing pass rather than a rework of the feature.