feat(webui): add the per-run task detail page

A per-task page at #/tasks/{id} with tabs for the attempt's stages and log, changed
files, configuration and a raw debug view. Reachable from the task list, deep
linkable via ?tab= and ?attempt=, and reload safe. Existing URLs (#/tasks?task=N
and #/tasks?status=...) are unchanged.

- A stage rail per attempt: name, duration, terminal status and error text, with
  unattributed events surfaced and the agent's own verdict shown separately.
- No pass/fail badge and no exit code anywhere: the backend has neither, and a stage
  that returned nil after producing a poor diff is a success. Status word, duration
  and error text are shown instead.
- The log pane filters by attempt, stage and level, states the coverage caveat for
  stage filters (agent and tool output records no stage), and keeps the three read
  outcomes distinct: no log reader in this deployment, no file for this attempt, and
  no entries matching the filter.
- Retry is labelled as a new run and its confirm says the previous attempt's commits
  are discarded, because it hard-resets the branch onto the base.
- An absent capture reads "not captured for this run" rather than implying nothing
  changed, and no elapsed-run figure is shown since only per-stage durations exist.
- The events cache is invalidated on retry (it previously kept the ended attempt's
  events) and the log cache is keyed by attempt, so two attempts cannot be conflated.
- ui/dist is rebuilt and committed: the gate runs the node tests but never rebuilds
  the bundle, so a stale one would otherwise ship behind a green gate.
- docs/prds/task-run-detail.md records the surface and its limits, and
  docs/architecture/observability.md describes it alongside the read endpoints.

Both new vocabularies are pinned by tests on each side (config schema, change
statuses) so a one-sided rename fails a test instead of silently degrading the page.
This commit is contained in:
sam committed 2026-09-18 18:33:03 +10:00
1 parent 862ac46e8b
commit 7414713d61
33 files changed
+4195 -91

No files matched your search

+25
View File
@@ -44,6 +44,9 @@ const READS = [
["tasks", []],
["taskMeta", []],
["task", [1]],
["taskAttempts", [1]],
["taskChanges", [1, { attempt: 2 }]],
["taskDebug", [1, { attempt: 2 }]],
["setup", []],
["capabilities", []],
["workflows", []],
@@ -191,6 +194,28 @@ test("a 415 keeps the server's explanation and reads as refused", async () => {
);
});
// The run detail page's reads. `qs` drops empty values, so an attempt the page
// has not resolved yet must not be sent as an empty string: the server treats an
// absent attempt as "the task's current attempt", and `attempt=` would be a
// different, malformed request.
test("the run detail reads build their URLs with absent filters absent", async () => {
stubFetch(okResponse);
await api.taskAttempts(42);
await api.taskChanges(42, { attempt: 2 });
await api.taskDebug(42, { attempt: 0 });
await api.taskChanges(42, {});
assert.deepEqual(
calls.map((call) => call.path),
[
"/api/tasks/42/attempts",
"/api/tasks/42/changes?attempt=2",
"/api/tasks/42/debug?attempt=0",
"/api/tasks/42/changes",
],
);
});
test("every api method is classified by this suite", () => {
const classified = new Set([
...MUTATIONS.map(([name]) => name),
+111
View File
@@ -0,0 +1,111 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup } from "@testing-library/preact";
import { AttemptConfig, CONFIG_SCHEMA, selectConfigEvent } from "../src/tasks/attempt-config.jsx";
const EVENTS = [
{
kind: "config_captured",
attempt: 1,
at: "2026-09-18T07:00:00.100Z",
stage: "",
data: { schema: CONFIG_SCHEMA, document: { BotUser: "archie-attempt-one", Models: { main: "openai/gpt" } } },
},
{
kind: "config_captured",
attempt: 2,
at: "2026-09-18T07:05:00.100Z",
stage: "",
data: { schema: CONFIG_SCHEMA, document: { BotUser: "archie-attempt-two", Models: { main: "openai/gpt" } } },
},
];
function mount(props) {
const { container, unmount } = render(<AttemptConfig {...props} />);
return { root: container, unmount };
}
// Selecting by kind alone would show the newest attempt's configuration on
// every attempt -- the merge-attempts bug the attempt column exists to prevent.
test("the configuration is selected by kind and attempt together", () => {
const { root, unmount } = mount({ events: EVENTS, attempt: 1 });
assert.match(root.textContent, /archie-attempt-one/);
assert.doesNotMatch(root.textContent, /archie-attempt-two/);
assert.match(root.textContent, /attempt 1's effective task-runtime configuration/);
unmount();
});
test("an attempt with no config event of its own says so, never another attempt's", () => {
const { root, unmount } = mount({ events: EVENTS, attempt: 3 });
assert.equal(root.querySelector(".empty-title").textContent, "Not captured for this run");
assert.doesNotMatch(root.textContent, /archie-attempt-one|archie-attempt-two/);
assert.match(root.textContent, /Nothing here says the run used the defaults/);
unmount();
});
test("the document is passed through verbatim, pretty-printed", () => {
const { root, unmount } = mount({ events: EVENTS, attempt: 2 });
const json = root.querySelector(".run-json").textContent;
assert.match(json, /"BotUser": "archie-attempt-two"/);
assert.match(json, /"Models"/);
unmount();
});
// The page must not imply this document is the whole configuration: it is the
// non-secret task-runtime subset.
test("the panel states the scope of what was captured", () => {
const { root, unmount } = mount({ events: EVENTS, attempt: 1 });
assert.match(root.textContent, /non-secret subset/);
assert.match(root.textContent, /not the dashboard configuration view/);
assert.match(root.textContent, /providers, repositories, identities, credentials and lock state/);
unmount();
});
test("an unrecognised schema is named and its payload is still shown", () => {
const events = [
{ kind: "config_captured", attempt: 2, at: "2026-09-18T07:05:00.100Z", data: { schema: "archie/task-config@9", document: { future: true } } },
];
const { root, unmount } = mount({ events, attempt: 2 });
assert.match(root.textContent, /unknown schema \(archie\/task-config@9\)/);
assert.match(root.querySelector(".run-json").textContent, /"future": true/);
unmount();
});
test("a config event with no data at all renders the raw payload rather than guessing", () => {
const events = [{ kind: "config_captured", attempt: 2, at: "2026-09-18T07:05:00.100Z" }];
const { root, unmount } = mount({ events, attempt: 2 });
assert.match(root.textContent, /unknown schema/);
assert.ok(root.querySelector(".run-json"));
unmount();
});
test("loading and failure states are distinct, and the failure offers a retry", () => {
const loading = mount({ events: undefined, attempt: 1 });
assert.match(loading.root.textContent, /Loading this task's events/);
loading.unmount();
const failed = mount({ events: null, attempt: 1, onRetry: () => {} });
assert.match(failed.root.textContent, /Could not load this task's events/);
assert.equal(failed.root.querySelector("button").textContent, "Retry");
failed.unmount();
});
test("selectConfigEvent ignores other kinds and other attempts", () => {
const events = [
{ kind: "stage_finish", attempt: 2, data: {} },
...EVENTS,
];
assert.equal(selectConfigEvent(events, 2).attempt, 2);
assert.equal(selectConfigEvent(events, 3), null);
assert.equal(selectConfigEvent(undefined, 1), null);
});
// CONFIG_SCHEMA mirrors events.ConfigCapturedSchema (internal/events/events.go),
// which the Go suite pins by the same literal. Pinning both sides is what makes
// a one-sided rename a failing test rather than every attempt rendering as
// "unknown schema".
test("the config schema is the one the producer stamps", () => {
assert.equal(CONFIG_SCHEMA, "archie/task-config@1");
});
test.after(() => cleanup());
+169
View File
@@ -0,0 +1,169 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup } from "@testing-library/preact";
import { ChangedFiles, fileStatusLabel } from "../src/tasks/changed-files.jsx";
const CAPTURE = {
captured_at: "2026-09-18T07:03:00.000Z",
captured_after: "commit",
stage: "commit",
owner: "o",
repo: "r",
base: "main",
branch: "feat/42-x",
head_sha: "abcdef1234567890",
base_sha: "0987654321fedcba",
pr_number: 7,
totals: { files: 3, additions: 40, deletions: 5 },
truncated: false,
files: [
{ path: "internal/x.go", old_path: "", status: "modified", additions: 12, deletions: 3, binary: false },
{ path: "bin/app", old_path: "", status: "added", additions: 0, deletions: 0, binary: true },
{ path: "internal/new.go", old_path: "internal/old.go", status: "renamed", additions: 1, deletions: 1, binary: false },
],
};
const TASK = {
id: 42,
repo_url: "https://forge.example.internal/o/r",
pr_number: 7,
pr_url: "https://forge.example.internal/o/r/pull/7",
};
function mount(props) {
const { container, unmount } = render(<ChangedFiles {...props} />);
return { root: container, unmount };
}
function rowFor(root, path) {
return [...root.querySelectorAll(".run-changes-table tbody tr")].find((row) =>
row.querySelector(".run-changes-path")?.textContent.includes(path),
);
}
// F5: nothing predating the capture has one, and the forge cannot supply one, so
// an empty view must not read as "this run changed nothing".
test("no capture recorded is not reported as no files changed", () => {
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: false, captures: [] } });
assert.equal(root.querySelector(".empty-title").textContent, "No change capture was recorded for this attempt");
assert.match(root.textContent, /not the same as "no files changed"/);
assert.doesNotMatch(root.textContent, /Nothing changed/);
unmount();
});
test("a capture renders its per-file counts and statuses", () => {
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [CAPTURE] }, task: TASK });
const modified = rowFor(root, "internal/x.go");
assert.match(modified.textContent, /Modified/);
assert.doesNotMatch(modified.textContent, /modified/, "the raw status code must not be shown as a word");
assert.match(modified.textContent, /\+12/);
assert.equal(root.querySelector(".run-capture-totals").textContent, "3 files · +40 · −5");
unmount();
});
// found:true with no readable capture is a READ failure, not "nothing was
// captured": the server reports found from the capture event's existence, so
// conflating the two tells the operator no capture was recorded when one
// demonstrably was.
test("a capture that was recorded but could not be read is not reported as missing", () => {
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [] } });
assert.match(root.textContent, /could not be read/i);
assert.doesNotMatch(root.textContent, /No change capture was recorded/);
unmount();
});
test("a renamed file shows the path it came from", () => {
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [CAPTURE] } });
const renamed = rowFor(root, "internal/new.go");
assert.match(renamed.textContent, /Renamed/);
assert.match(renamed.textContent, /internal\/old\.go → internal\/new\.go/);
unmount();
});
// A zero-hunk file is "no textual hunks", which is what the capture actually
// recorded -- not a claim about the file's type on disk.
test("a file with no textual hunks is described that way, not as a binary", () => {
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [CAPTURE] } });
const binary = rowFor(root, "bin/app");
assert.match(binary.textContent, /no textual hunks/);
assert.match(binary.textContent, /Added/);
assert.doesNotMatch(binary.textContent, /binary/i);
unmount();
});
test("a truncated capture says so while still reporting complete totals", () => {
const truncated = { ...CAPTURE, truncated: true, totals: { files: 210, additions: 900, deletions: 40 } };
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [truncated] } });
assert.match(root.textContent, /Showing the first 3 of 210 files/);
assert.match(root.textContent, /210 files · \+900 · −40/);
unmount();
});
test("the capture links to the repository and the pull request", () => {
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [CAPTURE] }, task: TASK });
const hrefs = [...root.querySelectorAll("a")].map((a) => a.getAttribute("href"));
assert.ok(hrefs.includes("https://forge.example.internal/o/r"));
assert.ok(hrefs.includes("https://forge.example.internal/o/r/pull/7"));
assert.match(root.textContent, /feat\/42-x → main/);
assert.match(root.textContent, /abcdef12/);
unmount();
});
// A link is only rendered when there is a URL behind it: a capture with no forge
// coordinates shows its owner/repo and PR number as text rather than a dead link.
test("a capture with no forge URL shows plain text instead of a dead link", () => {
const bare = { ...CAPTURE, pr_number: 9 };
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [bare] } });
assert.match(root.textContent, /PR #9/);
assert.equal(root.querySelectorAll("a").length, 0);
unmount();
});
test("multiple captures in one attempt all render, oldest first", () => {
const second = {
...CAPTURE,
captured_at: "2026-09-18T07:06:00.000Z",
captured_after: "commit-push",
stage: "push",
};
const { root, unmount } = mount({ state: { task_id: 42, attempt: 2, found: true, captures: [CAPTURE, second] } });
const heads = [...root.querySelectorAll(".run-capture-when")].map((n) => n.textContent);
assert.deepEqual(heads, ["Captured after commit in stage commit", "Captured after commit-push in stage push"]);
unmount();
});
test("loading and failure states are distinct, and the failure offers a retry", () => {
const loading = mount({ state: undefined });
assert.match(loading.root.textContent, /Loading changed files/);
loading.unmount();
const failed = mount({ state: null, onRetry: () => {} });
assert.match(failed.root.textContent, /Could not load this attempt's changed files/);
assert.equal(failed.root.querySelector("button").textContent, "Retry");
failed.unmount();
});
test("the status vocabulary is words, and an unknown status is passed through", () => {
assert.equal(fileStatusLabel("added"), "Added");
assert.equal(fileStatusLabel("typechange"), "Type changed");
assert.equal(fileStatusLabel("submodule"), "submodule");
});
// The five statuses are the producer's own vocabulary
// (internal/domain/workflow/task/changes.go), pinned by literal in the Go suite.
// This pins the dashboard half to the same five strings: without it, a rename on
// one side renders raw status codes beside words and both suites stay green.
test("the status vocabulary matches the strings the producer persists", () => {
const persisted = {
added: "Added",
modified: "Modified",
deleted: "Deleted",
renamed: "Renamed",
typechange: "Type changed",
};
for (const [status, label] of Object.entries(persisted)) {
assert.equal(fileStatusLabel(status), label, `${status} must be a known status, not passed through`);
}
});
test.after(() => cleanup());
+93
View File
@@ -0,0 +1,93 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { waitFor } from "@testing-library/preact";
// The router as the browser actually uses it: main.jsx is imported once (it
// starts on import), and every step below navigates by changing the hash and
// waiting for the app to follow. This is the only place the wiring between the
// route table, the matcher and the navigation highlight is exercised -- the
// matcher's own unit tests cannot see whether `show` hands the nav the section
// path or the detail path.
//
// archied is absent on purpose: every request fails, which is itself a state
// these pages must render honestly rather than blankly.
globalThis.fetch = async () => {
throw new Error("no daemon in this test");
};
// jsdom has no EventSource, and the dashboard subscribes to the daemon's event
// stream the moment it mounts. An inert stand-in keeps this test about routing
// rather than about the stream.
class InertEventSource {
close() {}
}
globalThis.EventSource = InertEventSource;
function navCurrent(path) {
return document.querySelector(`a.nav-item[href="#${path}"]`)?.getAttribute("aria-current");
}
function title() {
return document.querySelector(".page-title")?.textContent;
}
async function navigate(hash) {
location.hash = hash;
// jsdom queues its own hashchange for the assignment; waitFor lets it land.
await new Promise((resolve) => setTimeout(resolve, 0));
}
test("the app routes deep links and keeps the navigation highlight honest", async (t) => {
document.body.innerHTML = '<div id="app"></div>';
location.hash = "#/tasks/42";
await import("../src/main.jsx");
await waitFor(() => assert.equal(title(), "Task #42"));
await t.test("a per-task route renders the run page and keeps Tasks current", () => {
assert.equal(title(), "Task #42");
assert.ok(document.querySelector(".run-restart"), "the run controls should render");
assert.equal(
navCurrent("/tasks"),
"page",
"W9: a detail route must hand the nav its section, or Tasks silently loses aria-current",
);
});
await t.test("the tasks list route still works", async () => {
await navigate("#/tasks");
await waitFor(() => assert.equal(title(), "Tasks"));
assert.equal(navCurrent("/tasks"), "page");
assert.equal(document.querySelector(".tab-bar"), null, "the run page is no longer mounted");
});
// W10: #/tasks?task=N and #/tasks?status=... are pinned deep links. The steps
// below enter this route from the run page on purpose: the query string is an
// entry state, so a navigation that only changes the query of the page already
// mounted keeps the operator's own filter selection instead.
await t.test("a tab and attempt in the query string open that panel", async () => {
await navigate("#/tasks/7?tab=log&attempt=1");
await waitFor(() => assert.equal(title(), "Task #7"));
const selected = [...document.querySelectorAll('[role="tab"]')].find(
(tab) => tab.getAttribute("aria-selected") === "true",
);
assert.equal(selected.textContent, "Log");
// The panels read one attempt, and this deployment answered no reads at
// all -- so the panel says that rather than claiming there is no attempt.
await waitFor(() => assert.match(document.body.textContent, /Could not load this task's attempts/));
assert.equal(navCurrent("/tasks"), "page");
});
await t.test("the existing task deep links keep working", async () => {
await navigate("#/tasks?task=7&status=needs_you");
await waitFor(() => assert.equal(title(), "Tasks"));
assert.equal(document.querySelector(".task-filter").value, "needs_you");
assert.equal(navCurrent("/tasks"), "page");
});
await t.test("an unmatched path falls back to the dashboard", async () => {
await navigate("#/nope/deep");
await waitFor(() => assert.ok(document.querySelector(".hero-title"), "the dashboard should render"));
assert.equal(document.querySelector(".tab-bar"), null);
assert.equal(navCurrent("/"), "page");
});
});
+57
View File
@@ -0,0 +1,57 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { matchRoute, navPath } from "../src/routing.jsx";
// The route table mirrors main.jsx's: a literal section and the parameterised
// detail page declared after it, which is the ordering that stops /tasks/:id
// from swallowing /tasks.
const routes = [
{ path: "/", label: "Dashboard" },
{ path: "/tasks", label: "Tasks", view: () => null },
{ path: "/tasks/:id", label: "Task run", view: () => null, nav: false, navPath: "/tasks" },
{ path: "/logs", label: "Logs", view: () => null },
];
test("a literal path matches its own route, not a parameterised one", () => {
const match = matchRoute(routes, "/tasks");
assert.equal(match.route.path, "/tasks");
assert.deepEqual(match.params, {});
});
test("a path segment is captured as a route param", () => {
const match = matchRoute(routes, "/tasks/42");
assert.equal(match.route.path, "/tasks/:id");
assert.deepEqual(match.params, { id: "42" });
});
test("the query string is not part of the path", () => {
const match = matchRoute(routes, "/tasks/42?tab=changes&attempt=2");
assert.equal(match.route.path, "/tasks/:id");
assert.equal(match.params.id, "42");
});
test("a trailing slash names the same route", () => {
assert.equal(matchRoute(routes, "/tasks/").route.path, "/tasks");
assert.equal(matchRoute(routes, "/tasks/42/").params.id, "42");
});
// A prefix rule would send every unknown path under a section to that section's
// page, so a typo would render something plausible instead of the dashboard.
test("an unmatched path matches nothing rather than the nearest prefix", () => {
assert.equal(matchRoute(routes, "/nope"), null);
assert.equal(matchRoute(routes, "/tasks/42/extra"), null);
assert.equal(matchRoute(routes, "/task"), null);
});
test("an encoded segment is decoded into the param", () => {
assert.equal(matchRoute(routes, "/tasks/a%20b").params.id, "a b");
});
// W9: a detail route is not a nav entry, so it names the section it belongs to.
// Without this the Tasks item loses aria-current the moment the operator opens
// a run, and the whole nav reads as "nothing is current".
test("a parameterised route reports the section it keeps current", () => {
assert.equal(navPath(routes[2]), "/tasks");
assert.equal(navPath(routes[1]), "/tasks");
assert.equal(navPath(undefined), "/");
});
+229
View File
@@ -0,0 +1,229 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup } from "@testing-library/preact";
import { StageRail } from "../src/tasks/stage-rail.jsx";
// The frozen shape of GET /api/tasks/{id}/attempts. Attempt 1 failed on
// `implement`; attempt 2 is still running. The attempt-level duration_ms is
// present on purpose: the rail must not render it.
const ATTEMPTS = {
task_id: 42,
current_attempt: 2,
unattributed_events: 3,
attempts: [
{
attempt: 1,
status: "failed",
started_at: "2026-09-18T07:00:00.000Z",
finished_at: "2026-09-18T07:04:00.000Z",
duration_ms: 1_000_000,
event_count: 14,
stages: [
{ name: "prepare", seq: 0, status: "ok", started_at: "2026-09-18T07:00:00.123Z", duration_ms: 1200, error: "" },
{
name: "implement",
seq: 1,
status: "failed",
started_at: "2026-09-18T07:00:01.323Z",
duration_ms: 230000,
error: "stage implement: builder exited 1",
},
],
},
{
attempt: 2,
status: "running",
started_at: "2026-09-18T07:05:00.000Z",
event_count: 2,
stages: [{ name: "analyse", seq: 0, status: "running", started_at: "2026-09-18T07:05:00.000Z" }],
},
],
};
function mount(props) {
const { container, unmount } = render(<StageRail {...props} />);
return { root: container, unmount };
}
function stageRow(root, name) {
return [...root.querySelectorAll(".run-stage")].find(
(row) => row.querySelector(".run-stage-name")?.textContent === name,
);
}
test("each stage renders its name, duration and terminal status", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events: [] });
const prepare = stageRow(root, "prepare");
assert.ok(prepare, "the prepare stage should render");
assert.match(prepare.textContent, /prepare/);
assert.match(prepare.textContent, /ok/);
assert.match(prepare.textContent, /ran for 1\.2 s/);
const implement = stageRow(root, "implement");
assert.match(implement.textContent, /ran for 3 min 50 s/);
assert.match(implement.textContent, /stage implement: builder exited 1/);
unmount();
});
// W2: merging attempts by stage name is the failure this whole feature exists to
// prevent.
test("the rail shows only the selected attempt's stages", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events: [] });
assert.ok(stageRow(root, "prepare"));
assert.ok(stageRow(root, "implement"));
assert.equal(stageRow(root, "analyse"), undefined, "attempt 2's stages must not appear in attempt 1's rail");
assert.match(root.textContent, /Attempt 1/);
unmount();
});
test("an interrupted stage is not labelled failed", () => {
const state = {
...ATTEMPTS,
attempts: [
{
attempt: 1,
status: "interrupted",
started_at: "2026-09-18T07:00:00.000Z",
stages: [{ name: "implement", seq: 0, status: "interrupted", duration_ms: 4200, error: "context canceled" }],
},
],
};
const { root, unmount } = mount({ state, attemptNumber: 1, events: [] });
const row = stageRow(root, "implement");
assert.match(row.textContent, /interrupted/);
assert.doesNotMatch(row.textContent, /failed/);
unmount();
});
test("a stage with no recorded start shows no invented duration", () => {
const state = {
...ATTEMPTS,
attempts: [
{
attempt: 1,
status: "ok",
stages: [{ name: "commit", seq: 0, status: "ok" }],
},
],
};
const { root, unmount } = mount({ state, attemptNumber: 1, events: [] });
const row = stageRow(root, "commit");
assert.match(row.textContent, /duration not recorded/);
assert.doesNotMatch(row.textContent, /ran for/);
unmount();
});
// F3: waiting_human can span days, so an attempt's wall time is not a duration
// of work and the page must not present it as one.
test("the attempt's own duration is never rendered", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events: [] });
assert.doesNotMatch(root.textContent, /ran for 16 min/);
assert.doesNotMatch(root.textContent, /1,000,000|1000000/);
unmount();
});
test("events with no attempt are reported rather than guessed at", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events: [] });
assert.match(root.textContent, /3 events on this task predate attempt attribution/);
unmount();
});
// F1: a stage is `ok` when its function returned without error. There is no
// exit code and no verification, and the agent's own verdict is a separate
// claim -- neither may be presented as a check result.
test("the agent's own verdict is shown separately from the stage's status", () => {
const events = [
{
kind: "agent_finish",
attempt: 1,
stage: "implement",
data: { status: "passed", iterations: 7, tokens: 1234, model: "openai/gpt-5.6-luna" },
},
];
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events });
const row = stageRow(root, "implement");
assert.match(row.textContent, /Agent's own report, not verified by archie/);
assert.match(row.textContent, /Agent passed: implement/);
assert.match(row.textContent, /failed/, "the stage keeps its own terminal status");
assert.doesNotMatch(row.textContent, /exit code|exit status/i);
unmount();
});
test("an agent report for another attempt is not attached to this attempt's stage", () => {
const events = [
{ kind: "agent_finish", attempt: 2, stage: "implement", data: { status: "passed" } },
];
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events });
assert.doesNotMatch(root.textContent, /Agent's own report/);
unmount();
});
test("the rail says what ok means instead of implying a gate ran", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 1, events: [] });
assert.match(root.textContent, /ok means the stage returned without error/);
assert.match(root.textContent, /does not verify/);
unmount();
});
test("an attempt with no stages says so instead of showing an empty rail", () => {
const state = {
task_id: 42,
current_attempt: 1,
unattributed_events: 0,
attempts: [{ attempt: 1, status: "unknown", stages: [] }],
};
const { root, unmount } = mount({ state, attemptNumber: 1, events: [] });
assert.match(root.textContent, /No stages recorded for this attempt/);
unmount();
});
test("a task with no attempts says so", () => {
const { root, unmount } = mount({
state: { task_id: 42, current_attempt: 0, unattributed_events: 0, attempts: [] },
attemptNumber: null,
events: [],
});
assert.match(root.textContent, /No attempts recorded/);
unmount();
});
test("a selected attempt that was never recorded is reported, not faked", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 9, events: [] });
assert.match(root.textContent, /Attempt 9 is not recorded for this task/);
assert.match(root.textContent, /attempt 1, 2/);
unmount();
});
// A deployment where every event predates the attempt column answers with no
// attempts at all -- but the events are still there, unattributed. The count
// must be surfaced in the EMPTY rail too, not only beside a populated one, or
// the page presents unattributable history as "nothing happened".
test("unattributed events are surfaced even when no attempt is recorded", () => {
const { root, unmount } = mount({
state: { task_id: 42, current_attempt: 0, unattributed_events: 4, attempts: [] },
attemptNumber: null,
events: [],
});
assert.match(root.textContent, /No attempts recorded/);
assert.match(root.textContent, /4 events on this task predate attempt attribution/);
unmount();
});
test("unattributed events are surfaced when the selected attempt is not recorded", () => {
const { root, unmount } = mount({ state: ATTEMPTS, attemptNumber: 9, events: [] });
assert.match(root.textContent, /Attempt 9 is not recorded/);
assert.match(root.textContent, /3 events on this task predate attempt attribution/);
unmount();
});
test("loading and failure states are distinct, and the failure offers a retry", () => {
const loading = mount({ state: undefined, attemptNumber: null, events: [] });
assert.match(loading.root.textContent, /Loading/);
loading.unmount();
const failed = mount({ state: null, attemptNumber: null, events: [], onRetry: () => {} });
assert.match(failed.root.textContent, /Could not load this task's attempts/);
assert.equal(failed.root.querySelector("button").textContent, "Retry");
failed.unmount();
});
test.after(() => cleanup());
+401
View File
@@ -0,0 +1,401 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup, fireEvent, waitFor } from "@testing-library/preact";
import { api, ApiError } from "../src/base/api.jsx";
import { taskDetailPage } from "../src/tasks/task-detail.jsx";
const CONFIG_SCHEMA = "archie/task-config@1";
const TASK = {
id: 42,
title: "Fix the flaky test",
status: "parked",
owner: "o",
repo: "r",
workflow: "tdd",
attempt: 2,
actions: ["retry", "abandon", "reject"],
repo_url: "https://forge.example.internal/o/r",
issue_url: "https://forge.example.internal/o/r/issues/5",
issue_number: 5,
pr_number: 7,
pr_url: "https://forge.example.internal/o/r/pull/7",
};
const ATTEMPTS = {
task_id: 42,
current_attempt: 2,
unattributed_events: 0,
attempts: [
{
attempt: 1,
status: "failed",
started_at: "2026-09-18T07:00:00.000Z",
finished_at: "2026-09-18T07:04:00.000Z",
duration_ms: 240333,
event_count: 3,
stages: [
{ name: "prepare", seq: 0, status: "ok", started_at: "2026-09-18T07:00:00.123Z", duration_ms: 1200, error: "" },
{ name: "implement", seq: 1, status: "failed", duration_ms: 230000, error: "stage implement: builder exited 1" },
],
},
{
attempt: 2,
status: "running",
started_at: "2026-09-18T07:05:00.000Z",
event_count: 1,
stages: [{ name: "analyse", seq: 0, status: "running", started_at: "2026-09-18T07:05:00.000Z" }],
},
],
};
const EVENTS = [
{
kind: "config_captured",
attempt: 2,
at: "2026-09-18T07:05:00.100Z",
stage: "",
data: { schema: CONFIG_SCHEMA, document: { BotUser: "archie", Models: { main: "openai/gpt" } } },
},
{ kind: "stage_start", attempt: 2, stage: "analyse", at: "2026-09-18T07:05:00.000Z", data: {} },
];
function install(overrides = {}) {
const original = {
tasks: api.tasks,
task: api.task,
taskAttempts: api.taskAttempts,
taskLogs: api.taskLogs,
taskChanges: api.taskChanges,
taskDebug: api.taskDebug,
taskAction: api.taskAction,
};
const calls = { tasks: 0, task: 0, attempts: 0, logs: [], changes: [], debug: [], actions: [] };
api.tasks = async () => {
calls.tasks += 1;
return [TASK];
};
api.task = async (id) => {
calls.task += 1;
return EVENTS;
};
api.taskAttempts = async (id) => {
calls.attempts += 1;
return ATTEMPTS;
};
api.taskLogs = async (id, params) => {
calls.logs.push(params);
return { found: true, attempt: params?.attempt ?? 2, disabled: false, entries: [{ level: "info", msg: "line", time: "2026-09-18T07:05:00Z" }] };
};
api.taskChanges = async (id, params) => {
calls.changes.push(params);
return { task_id: 42, attempt: params?.attempt ?? 2, found: false, captures: [] };
};
api.taskDebug = async (id, params) => {
calls.debug.push(params);
return { task_id: 42, attempt: params?.attempt ?? 2, task: TASK, events: EVENTS };
};
api.taskAction = async (id, action) => {
calls.actions.push({ id, action });
return {};
};
for (const [key, value] of Object.entries(overrides)) api[key] = value;
const restore = () => Object.assign(api, original);
return { calls, restore };
}
function mount(queryString, id = "42") {
const { container, unmount } = render(
taskDetailPage(new URLSearchParams(queryString), { id }),
);
return { root: container, unmount };
}
test("the page offers every panel as a tab and opens Stages by default", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=");
await waitFor(() => assert.ok(root.querySelector(".run-stages"), "the rail should render"));
const tabs = [...root.querySelectorAll('[role="tab"]')].map((tab) => tab.textContent);
assert.deepEqual(tabs, ["Stages", "Log", "Changed files", "Configuration", "Debug"]);
assert.equal(root.querySelector('[role="tab"]').getAttribute("aria-selected"), "true");
// The panel is bound to the selected tab.
const panel = root.querySelector('[role="tabpanel"]');
assert.equal(panel.getAttribute("aria-labelledby"), root.querySelector('[role="tab"]').id);
unmount();
restore();
});
test("the panel element is the selected tab's panel", () => {
const { root, unmount } = mount("tab=changes");
const selected = [...root.querySelectorAll('[role="tab"]')].find(
(tab) => tab.getAttribute("aria-selected") === "true",
);
assert.equal(selected.textContent, "Changed files");
assert.equal(root.querySelector('[role="tabpanel"]').id, selected.getAttribute("aria-controls"));
unmount();
});
// R8: the tabs are deep-linkable, so the query string alone decides which panel
// opens -- including on a reload with no client state.
test("?tab= decides which panel opens", async () => {
const { restore, calls } = install();
const { root, unmount } = mount("tab=debug");
await waitFor(() => assert.ok(root.querySelector(".run-json"), "the debug view should render"));
const json = root.querySelector(".run-json").textContent;
assert.match(json, /"title": "Fix the flaky test"/);
assert.match(json, /"attempt": 2/);
assert.match(root.textContent, /Attempt 2 is the one selected above/);
assert.deepEqual(calls.debug, [{ attempt: 2 }]);
// The debug envelope is only fetched for the visible tab.
assert.equal(calls.changes.length, 0);
unmount();
restore();
});
test("the debug view states that its event list is unfiltered", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=debug");
await waitFor(() => assert.ok(root.querySelector(".run-json")));
assert.match(root.textContent, /Events are unfiltered on purpose/);
unmount();
restore();
});
test("the default attempt is the task's current one", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
assert.match(root.textContent, /Attempt 2/);
assert.equal(
[...root.querySelectorAll(".run-stage-name")].map((n) => n.textContent).join(","),
"analyse",
"attempt 1's stages must not appear on the current attempt's rail",
);
const chips = [...root.querySelectorAll(".run-attempt")];
assert.equal(chips.length, 2);
assert.equal(chips[1].getAttribute("aria-pressed"), "true");
unmount();
restore();
});
test("?attempt= pins an earlier attempt and the rail follows it", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=stages&attempt=1");
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
assert.deepEqual(
[...root.querySelectorAll(".run-stage-name")].map((n) => n.textContent),
["prepare", "implement"],
);
assert.equal(root.querySelectorAll(".run-attempt")[0].getAttribute("aria-pressed"), "true");
unmount();
restore();
});
test("selecting another attempt re-reads the panels for that attempt", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
fireEvent.click(root.querySelectorAll(".run-attempt")[0]);
await waitFor(() =>
assert.deepEqual(
[...root.querySelectorAll(".run-stage-name")].map((n) => n.textContent),
["prepare", "implement"],
),
);
unmount();
restore();
});
test("the log pane sends the selected attempt and the filters to the server", async () => {
const { restore, calls } = install();
const { root, unmount } = mount("tab=log&attempt=1");
await waitFor(() => assert.ok(root.querySelector(".log-list")));
assert.deepEqual(calls.logs, [{ attempt: 1, level: "", stage: "", limit: 500 }]);
const stageSelect = [...root.querySelectorAll(".task-log-filter select")][1];
fireEvent.change(stageSelect, { target: { value: "prepare" } });
await waitFor(() => assert.equal(calls.logs.length, 2));
assert.deepEqual(calls.logs[1], { attempt: 1, level: "", stage: "prepare", limit: 500 });
await waitFor(() => assert.match(root.textContent, /A stage filter matches only log lines that record a stage/));
unmount();
restore();
});
// R4: the Config tab consumes the events response the page already holds, so it
// must issue no request of its own.
test("the configuration tab reads the captured document from the fetched events", async () => {
const { restore, calls } = install();
const { root, unmount } = mount("tab=config");
await waitFor(() => assert.ok(root.querySelector(".run-json")));
assert.match(root.querySelector(".run-json").textContent, /"BotUser": "archie"/);
assert.equal(calls.task, 1, "the events are fetched once, by the page");
assert.equal(calls.changes.length, 0);
assert.equal(calls.debug.length, 0);
unmount();
restore();
});
test("the configuration tab says nothing was captured for an attempt with no record", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=config&attempt=1");
await waitFor(() =>
assert.equal(root.querySelector(".empty-title").textContent, "Not captured for this run"),
);
unmount();
restore();
});
test("changed files are read for the selected attempt and say a capture is missing", async () => {
const { restore, calls } = install();
const { root, unmount } = mount("tab=changes&attempt=1");
await waitFor(() =>
assert.equal(root.querySelector(".empty-title").textContent, "No change capture was recorded for this attempt"),
);
assert.deepEqual(calls.changes, [{ attempt: 1 }]);
unmount();
restore();
});
// R6: the control is labelled as a new run, and the copy says what it destroys.
test("the new-run control states that the previous attempt's commits are discarded", async () => {
const { restore } = install();
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".run-restart")));
const button = root.querySelector(".run-restart button");
assert.equal(button.textContent, "Start a new run");
assert.match(root.textContent, /The previous attempt's commits are discarded/);
assert.match(root.textContent, /fresh worktree reset onto the base branch/);
unmount();
restore();
});
test("a declined confirmation starts no run", async () => {
const { restore, calls } = install();
const originalConfirm = window.confirm;
let asked = "";
window.confirm = (text) => {
asked = text;
return false;
};
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".run-restart button")));
fireEvent.click(root.querySelector(".run-restart button"));
assert.match(asked, /previous attempt's commits are discarded/);
assert.deepEqual(calls.actions, []);
unmount();
window.confirm = originalConfirm;
restore();
});
test("a confirmed new run drops the old attempt's caches and selects the new run", async () => {
const NEW_ATTEMPTS = {
task_id: 42,
current_attempt: 3,
unattributed_events: 0,
attempts: [
...ATTEMPTS.attempts,
{ attempt: 3, status: "running", started_at: "2026-09-18T07:09:00.000Z", event_count: 1, stages: [{ name: "bootstrap", seq: 0, status: "ok", duration_ms: 500 }] },
],
};
let attemptReads = 0;
const { restore, calls } = install({
taskAttempts: async () => {
attemptReads += 1;
return attemptReads === 1 ? ATTEMPTS : NEW_ATTEMPTS;
},
});
const originalConfirm = window.confirm;
window.confirm = () => true;
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
fireEvent.click(root.querySelector(".run-restart button"));
await waitFor(() => assert.equal(root.querySelectorAll(".run-attempt").length, 3));
await waitFor(() =>
assert.deepEqual(
[...root.querySelectorAll(".run-stage-name")].map((n) => n.textContent),
["bootstrap"],
"the new run's stages are shown, not the previous attempt's",
),
);
assert.deepEqual(calls.actions, [{ id: 42, action: "retry" }]);
assert.equal(root.querySelectorAll(".run-attempt")[2].getAttribute("aria-pressed"), "true");
assert.equal(calls.task, 2, "the ended attempt's events are refetched for the new run");
unmount();
window.confirm = originalConfirm;
restore();
});
test("a task outside the listed rows is reported honestly rather than blank", async () => {
const { restore } = install({ tasks: async () => [] });
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
assert.match(root.textContent, /not among the tasks this dashboard lists/);
assert.match(root.textContent, /Debug tab holds the stored record verbatim/);
assert.match(root.textContent, /operator controls could not be read/);
unmount();
restore();
});
test("a deployment that lists no tasks for this id still shows the recorded run", async () => {
const { restore } = install({ tasks: async () => [] });
const { root, unmount } = mount("tab=stages&attempt=1");
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
assert.match(root.textContent, /Task #42/);
assert.match(root.textContent, /prepare/);
unmount();
restore();
});
test("an unknown task renders an honest failure, not an empty page", async () => {
const { restore } = install({
taskAttempts: async () => {
throw new ApiError("no such task", 404);
},
});
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.ok(root.querySelector(".page-title")));
assert.match(root.querySelector(".page-title").textContent, /Task not found/);
assert.match(root.textContent, /No task with id 42/);
unmount();
restore();
});
test("a non-numeric id is refused without asking the server anything", () => {
const { restore, calls } = install();
const { root, unmount } = mount("tab=stages", "not-an-id");
assert.match(root.textContent, /is not a task id/);
assert.deepEqual(calls, { tasks: 0, task: 0, attempts: 0, logs: [], changes: [], debug: [], actions: [] });
unmount();
restore();
});
test("a task with no attempts says so on every panel", async () => {
const { restore } = install({
taskAttempts: async () => ({ task_id: 42, current_attempt: 0, unattributed_events: 4, attempts: [] }),
});
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.match(root.textContent, /No attempts recorded/));
fireEvent.click([...root.querySelectorAll('[role="tab"]')][3]);
await waitFor(() => assert.match(root.textContent, /No attempt recorded/));
unmount();
restore();
});
test("a failure to load the attempts offers a retry", async () => {
let reads = 0;
const { restore } = install({
taskAttempts: async () => {
reads += 1;
if (reads === 1) throw new Error("boom");
return ATTEMPTS;
},
});
const { root, unmount } = mount("tab=stages");
await waitFor(() => assert.match(root.textContent, /Could not load this task's attempts/));
fireEvent.click([...root.querySelectorAll(".run-error button")][0]);
await waitFor(() => assert.ok(root.querySelector(".run-stages")));
unmount();
restore();
});
test.after(() => cleanup());
+146 -3
View File
@@ -1,10 +1,20 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup } from "@testing-library/preact";
import { TaskLogPanel, taskLogDownloadURL } from "../src/tasks/task-logs.jsx";
import { render, cleanup, fireEvent } from "@testing-library/preact";
import { TaskLogPanel, logCacheKey, taskLogDownloadURL } from "../src/tasks/task-logs.jsx";
function renderPanel(state, opts = {}) {
const { container, unmount } = render(<TaskLogPanel state={state} onRetry={opts.onRetry} taskId={opts.taskId} />);
const { container, unmount } = render(
<TaskLogPanel
state={state}
onRetry={opts.onRetry}
taskId={opts.taskId}
attempt={opts.attempt}
filters={opts.filters}
onFilterChange={opts.onFilterChange}
stages={opts.stages}
/>,
);
return { root: container, unmount };
}
@@ -103,3 +113,136 @@ test("a panel for an attempt with no log offers no download", () => {
assert.equal(root.querySelector(".task-log-download"), null, "there is nothing to download");
unmount();
});
// W7: the filter controls must sit ABOVE the three read outcomes. Below the
// disabled early return they would replace the deployment-level message with an
// empty filtered pane in exactly the deployment that cannot read logs.
const FILTER_OPTS = { filters: { level: "", stage: "" }, onFilterChange: () => {}, stages: ["prepare"] };
test("the three read outcomes survive with the filter bar rendered above them", () => {
const disabled = renderPanel({ disabled: true, entries: [] }, FILTER_OPTS);
assert.ok(disabled.root.querySelector(".task-log-filters"), "the filter bar renders first");
assert.match(disabled.root.textContent, /No persisted log for this attempt/);
assert.match(disabled.root.textContent, /cannot read task logs/);
disabled.unmount();
const absent = renderPanel({ found: false, entries: [], attempt: 0 }, FILTER_OPTS);
assert.match(absent.root.textContent, /No log recorded for this attempt/);
assert.doesNotMatch(absent.root.textContent, /cannot read task logs/);
absent.unmount();
const filtered = renderPanel({ disabled: false, found: true, entries: [], attempt: 0 }, FILTER_OPTS);
assert.equal(filtered.root.querySelector(".empty-title").textContent, "Nothing recorded");
filtered.unmount();
});
// W6: one cache entry per task could not represent two attempts, so a retry
// served the previous run's log under the new run's id.
test("the log cache key is keyed by task, attempt and filters", () => {
assert.equal(logCacheKey(7, 1), "7|1||");
assert.notEqual(logCacheKey(7, 1), logCacheKey(7, 2), "two attempts must not share a cache entry");
assert.notEqual(logCacheKey(7, 1), logCacheKey(71, 1), "two tasks must not share a cache entry");
assert.notEqual(
logCacheKey(7, 1, { level: "ERROR", stage: "" }),
logCacheKey(7, 1, { level: "", stage: "" }),
"a filtered read is a different response and needs its own entry",
);
});
// F2: a stage filter narrows to lines a stage tagged and nothing more. Agent and
// tool output has no stage, so a sparse result must be explained next to the
// control rather than left to look broken.
test("a stage filter states its coverage limit beside the control", () => {
const { root, unmount } = renderPanel(
{ found: true, entries: [], attempt: 1 },
{ ...FILTER_OPTS, filters: { level: "", stage: "prepare" }, stages: ["prepare", "implement"] },
);
assert.match(root.textContent, /A stage filter matches only log lines that record a stage/);
assert.match(root.textContent, /Agent and tool output carries none/);
unmount();
});
test("an attempt with no recorded stage names says the stage filter has nothing to match", () => {
const { root, unmount } = renderPanel(
{ found: true, entries: [], attempt: 1 },
{ ...FILTER_OPTS, stages: [] },
);
assert.match(root.textContent, /recorded no stage names/);
unmount();
});
test("changing a filter reports the whole filter set to the page", () => {
const seen = [];
const { root, unmount } = renderPanel(
{ found: true, entries: [], attempt: 1 },
{ ...FILTER_OPTS, onFilterChange: (next) => seen.push(next) },
);
const level = root.querySelectorAll("select")[0];
const stage = root.querySelectorAll("select")[1];
fireEvent.change(level, { target: { value: "ERROR" } });
fireEvent.change(stage, { target: { value: "prepare" } });
assert.deepEqual(seen, [
{ level: "ERROR", stage: "" },
{ level: "", stage: "prepare" },
]);
unmount();
});
// The pane names the attempt it is showing so it can never present attempt 1's
// log as attempt 2's.
test("the pane names the attempt it is showing", () => {
const explicit = renderPanel({ found: true, attempt: 1, entries: [] }, { attempt: 1 });
assert.match(explicit.root.textContent, /Attempt 1/);
explicit.unmount();
const resolved = renderPanel({ found: true, attempt: 4, entries: [] }, { attempt: null, taskId: 42 });
assert.match(resolved.root.textContent, /Attempt 4/);
assert.equal(
resolved.root.querySelector(".task-log-download").getAttribute("href"),
"/api/tasks/42/logs/download?attempt=4",
"a download follows the attempt the pane is showing, not whatever is current",
);
resolved.unmount();
});
test("a panel without a page to act on a filter renders no filter controls", () => {
const { root, unmount } = renderPanel({ found: true, entries: [], attempt: 1 });
assert.equal(root.querySelector("select"), null, "a control that filters nothing is worse than none");
assert.match(root.textContent, /Attempt 1/);
unmount();
});
// R9: the pane carries one live region announcing its STATE, never a line at a
// time. A per-line live region would read the whole log aloud on every load,
// and a pane that loads 500 entries would be unusable with a screen reader.
test("the pane announces its state once, not every log line", () => {
const { root, unmount } = renderPanel({
found: true,
attempt: 2,
entries: [
{ level: "info", msg: "one" },
{ level: "info", msg: "two" },
],
});
const live = root.querySelector("[aria-live]");
assert.ok(live, "the pane should carry a live region");
assert.equal(live.getAttribute("role"), "status");
assert.equal(live.getAttribute("aria-atomic"), "true");
assert.match(live.textContent, /2 log entries/);
assert.ok(live.className.includes("visually-hidden"), "the live text is for assistive technology only");
assert.equal(root.querySelector(".log-list").contains(live), false, "the live region is not the list itself");
unmount();
});
test("the live region says which of the log-unavailable cases applies", () => {
const disabled = renderPanel({ disabled: true, entries: [] });
assert.match(disabled.root.querySelector("[aria-live]").textContent, /cannot read task logs/);
disabled.unmount();
const absent = renderPanel({ found: false, entries: [], attempt: 0 });
assert.match(absent.root.querySelector("[aria-live]").textContent, /No log recorded for this attempt/);
assert.doesNotMatch(absent.root.querySelector("[aria-live]").textContent, /cannot read task logs/);
absent.unmount();
});
test.after(() => cleanup());
+115
View File
@@ -0,0 +1,115 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup, fireEvent } from "@testing-library/preact";
import { TabBar, panelId, tabId } from "../src/tasks/tab-bar.jsx";
const TABS = [
{ id: "stages", label: "Stages" },
{ id: "log", label: "Log" },
{ id: "changes", label: "Changed files" },
];
import { useState } from "preact/hooks";
function Harness({ initial = "stages", onSelect }) {
const [active, setActive] = useState(initial);
return (
<TabBar
tabs={TABS}
active={active}
onSelect={(id) => {
onSelect?.(id);
setActive(id);
}}
prefix="run"
/>
);
}
function mount(active = "stages", onSelect) {
const { container, unmount } = render(<Harness initial={active} onSelect={onSelect} />);
return { root: container, unmount };
}
test("the tab list is a tablist of tabs with the active one selected", () => {
const { root, unmount } = mount("log");
const list = root.querySelector('[role="tablist"]');
assert.ok(list, "a tablist should render");
const tabs = [...root.querySelectorAll('[role="tab"]')];
assert.equal(tabs.length, 3);
assert.equal(tabs[0].getAttribute("aria-selected"), "false");
assert.equal(tabs[1].getAttribute("aria-selected"), "true");
assert.equal(tabs[0].textContent, "Stages");
unmount();
});
// The panel is a separate element in the page, so the relationship has to be
// declared explicitly or assistive technology cannot connect them.
test("each tab points at the panel it controls", () => {
const { root, unmount } = mount("stages");
const tabs = [...root.querySelectorAll('[role="tab"]')];
const expected = ["stages", "log", "changes"].map((id) => panelId("run", id));
assert.deepEqual(tabs.map((tab) => tab.getAttribute("aria-controls")), expected);
assert.deepEqual(tabs.map((tab) => tab.id), ["stages", "log", "changes"].map((id) => tabId("run", id)));
unmount();
});
// Roving tabindex: the tab list is one stop in the page's tab order, not three.
test("only the active tab is in the page tab order", () => {
const { root, unmount } = mount("changes");
const tabs = [...root.querySelectorAll('[role="tab"]')];
assert.deepEqual(tabs.map((tab) => tab.getAttribute("tabindex")), ["-1", "-1", "0"]);
unmount();
});
test("clicking a tab selects it", () => {
const selected = [];
const { root, unmount } = mount("stages", (id) => selected.push(id));
fireEvent.click(root.querySelectorAll('[role="tab"]')[2]);
assert.deepEqual(selected, ["changes"]);
unmount();
});
test("arrow keys move between tabs, wrap around, and select as they go", () => {
const selected = [];
const { root, unmount } = mount("stages", (id) => selected.push(id));
const first = root.querySelectorAll('[role="tab"]')[0];
first.focus();
fireEvent.keyDown(first, { key: "ArrowRight" });
fireEvent.keyDown(root.querySelectorAll('[role="tab"]')[1], { key: "ArrowRight" });
fireEvent.keyDown(root.querySelectorAll('[role="tab"]')[2], { key: "ArrowRight" });
assert.deepEqual(selected, ["log", "changes", "stages"], "arrow-right wraps to the first tab");
unmount();
});
test("Home and End jump to the ends of the tab list", () => {
const selected = [];
const { root, unmount } = mount("log", (id) => selected.push(id));
const active = root.querySelectorAll('[role="tab"]')[1];
fireEvent.keyDown(active, { key: "End" });
fireEvent.keyDown(root.querySelectorAll('[role="tab"]')[2], { key: "Home" });
assert.deepEqual(selected, ["changes", "stages"]);
unmount();
});
// Keyboard focus must follow selection: a roving-tabindex widget that moves the
// selection but leaves focus behind loses the keyboard user.
test("an arrow key moves keyboard focus with the selection", () => {
const { root, unmount } = mount("stages");
const first = root.querySelectorAll('[role="tab"]')[0];
first.focus();
fireEvent.keyDown(first, { key: "ArrowRight" });
const tabs = [...root.querySelectorAll('[role="tab"]')];
assert.equal(document.activeElement, tabs[1]);
unmount();
});
test("an unrelated key does nothing", () => {
const selected = [];
const { root, unmount } = mount("stages", (id) => selected.push(id));
fireEvent.keyDown(root.querySelectorAll('[role="tab"]')[0], { key: "a" });
assert.deepEqual(selected, []);
unmount();
});
test.after(() => cleanup());
+105 -1
View File
@@ -1,7 +1,7 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { register } from "node:module";
import { render, waitFor } from "@testing-library/preact";
import { render, waitFor, fireEvent } from "@testing-library/preact";
const cssLoad = "data:text/javascript," + encodeURIComponent(`
export async function load(url, context, nextLoad) {
@@ -186,3 +186,107 @@ test("a link-kind action renders an anchor to the forge", async () => {
assert.equal(link.textContent, "Open PR");
assert.equal(link.getAttribute("href"), "https://forge.example.internal/sam/archie/pull/42");
});
// The stuck-pane case: an open log pane whose row is collapsed while the task
// is retried. If the pane only ever loaded from the click that opened it, the
// new attempt's pane would sit on "Loading…" with nothing fetching it.
test("a log pane left open across a retry loads the new attempt when the row is reopened", async () => {
const first = { id: 9, title: "Restart me", status: "parked", repo: "sam/archie", workflow: "tdd", attempt: 1, actions: ["retry"] };
const second = { ...first, attempt: 2, status: "running" };
const original = { tasks: api.tasks, task: api.task, taskAction: api.taskAction, taskLogs: api.taskLogs };
let listReads = 0;
const logReads = [];
api.tasks = async () => {
listReads += 1;
return [listReads === 1 ? first : second];
};
api.task = async () => [
{ kind: "stage_start", attempt: listReads, stage: listReads === 1 ? "prepare" : "bootstrap", at: "2026-09-18T07:00:00Z" },
];
api.taskLogs = async (id, params) => {
logReads.push(params);
return { found: true, attempt: params.attempt, disabled: false, entries: [{ level: "info", msg: "line" }] };
};
api.taskAction = async () => ({});
try {
const { container } = render(tasksPage(new URLSearchParams("task=9")));
await waitFor(() => assert.match(container.textContent, /Started stage: prepare/));
fireEvent.click(container.querySelector(".task-logs-section button"));
await waitFor(() => assert.equal(logReads.length, 1));
// Collapse the row, retry from the collapsed row, then reopen it.
fireEvent.click(container.querySelector(".task-expand"));
fireEvent.click(container.querySelector(".task-actions button"));
await waitFor(() => assert.equal(listReads, 2));
fireEvent.click(container.querySelector(".task-expand"));
await waitFor(() => assert.match(container.textContent, /Started stage: bootstrap/));
await waitFor(() => assert.equal(logReads.length, 2), { timeout: 2000 });
assert.deepEqual(logReads[1], { attempt: 2, limit: 500 });
assert.doesNotMatch(container.textContent, /Loading attempt log/);
} finally {
Object.assign(api, original);
}
});
// R8: the run detail page is a per-task route, and the list is how an operator
// reaches it. The existing #/tasks?task=N deep link is a different affordance
// and stays working (pinned in operator-controls.test.js).
test("a task row links to its run detail page", async () => {
const root = await renderTask({ id: 7, title: "Fix the flaky test", status: "parked", repo: "sam/archie", actions: [] });
const link = root.querySelector(".task-detail-link");
assert.ok(link, "the title should link to the run detail page");
assert.equal(link.getAttribute("href"), "#/tasks/7");
assert.equal(link.textContent, "Fix the flaky test");
});
// W8: the per-task caches used to be written and never invalidated, so a retry
// left the previous attempt's timeline (and, because the log cache was keyed by
// task, its log) on screen under the new run.
test("a retry drops the ended attempt's caches and reloads the new run", async () => {
const first = { id: 8, title: "Flaky", status: "parked", repo: "sam/archie", workflow: "tdd", attempt: 1, actions: ["retry"] };
const second = { ...first, attempt: 2, status: "running" };
const original = { tasks: api.tasks, task: api.task, taskAction: api.taskAction, taskLogs: api.taskLogs };
let listReads = 0;
const timelineReads = [];
const logReads = [];
api.tasks = async () => {
listReads += 1;
return [listReads === 1 ? first : second];
};
api.task = async () => {
timelineReads.push(timelineReads.length + 1);
const attempt = timelineReads.length;
return [
{
kind: "stage_start",
attempt,
stage: attempt === 1 ? "prepare" : "bootstrap",
at: "2026-09-18T07:00:00Z",
},
];
};
api.taskLogs = async (id, params) => {
logReads.push(params);
return { found: true, attempt: params.attempt, disabled: false, entries: [{ level: "info", msg: "line" }] };
};
api.taskAction = async () => ({});
try {
const { container } = render(tasksPage(new URLSearchParams("task=8")));
await waitFor(() => assert.match(container.textContent, /Started stage: prepare/));
fireEvent.click(container.querySelector(".task-logs-section button"));
await waitFor(() => assert.equal(logReads.length, 1));
assert.deepEqual(logReads[0], { attempt: 1, limit: 500 });
fireEvent.click(container.querySelector(".task-actions button"));
await waitFor(() => assert.match(container.textContent, /Started stage: bootstrap/));
assert.equal(timelineReads.length, 2, "the timeline is refetched, not kept from the ended attempt");
assert.doesNotMatch(container.textContent, /Started stage: prepare/);
await waitFor(() => assert.equal(logReads.length, 2), { timeout: 2000 });
assert.deepEqual(logReads[1], { attempt: 2, limit: 500 }, "the log pane follows the new attempt");
} finally {
Object.assign(api, original);
}
});
+73
View File
@@ -0,0 +1,73 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { register } from "node:module";
import { render, waitFor } from "@testing-library/preact";
// tasks.jsx imports its feature CSS, which node cannot load; the same inline
// loader the sibling tasks tests register lets the module be imported here.
const cssLoad = "data:text/javascript," + encodeURIComponent(`
export async function load(url, context, nextLoad) {
if (url.endsWith(".css")) {
return { format: "module", shortCircuit: true, source: "export default {};" };
}
return nextLoad(url, context);
}
`);
register(cssLoad, import.meta.url);
const { api } = await import("../src/base/api.jsx");
const { tasksPage } = await import("../src/tasks/tasks.jsx");
// jsdom implements neither matchMedia nor scrollIntoView, so both are provided
// here to observe the one decision under test: which scroll behaviour a
// deep-linked row is revealed with.
function stubMotion(reduced) {
window.matchMedia = (query) => ({
matches: Boolean(reduced) && String(query).includes("prefers-reduced-motion: reduce"),
media: String(query),
onchange: null,
addEventListener() {},
removeEventListener() {},
addListener() {},
removeListener() {},
dispatchEvent() {
return false;
},
});
}
async function revealWithMotion(reduced) {
const seen = [];
const originalScroll = Element.prototype.scrollIntoView;
const originalMatchMedia = window.matchMedia;
const originalTasks = api.tasks;
Element.prototype.scrollIntoView = (opts) => seen.push(opts);
stubMotion(reduced);
api.tasks = async () => [
{ id: 7, title: "Deep link", status: "running", repo: "o/r", workflow: "tdd", actions: [], attempt: 1 },
];
try {
const { unmount } = render(tasksPage(new URLSearchParams("task=7")));
await waitFor(() => assert.ok(seen.length, "the deep-linked row should be revealed"));
unmount();
return seen[0];
} finally {
Element.prototype.scrollIntoView = originalScroll;
window.matchMedia = originalMatchMedia;
api.tasks = originalTasks;
}
}
// The global reduced-motion rule switches CSS transitions, NOT JS smooth
// scrolling: a deep-linked row is revealed by scrollIntoView, so the behaviour
// has to be chosen in JS or a reduced-motion user still gets an animated scroll.
test("a revealed row scrolls smoothly only when motion is not reduced", async () => {
const opts = await revealWithMotion(false);
assert.equal(opts.behavior, "smooth");
assert.equal(opts.block, "center");
});
test("a revealed row scrolls instantly when motion is reduced", async () => {
const opts = await revealWithMotion(true);
assert.equal(opts.behavior, "auto");
});
+20
View File
@@ -102,6 +102,26 @@ test("cancelled stages are described as interrupted rather than failed", () => {
);
});
// Condition (d): the two provenance events render as human timeline lines and
// must never dump the captured payload inline -- the Configuration tab renders
// the document; the timeline only says that it was captured.
test("capture events describe themselves without dumping their payload", () => {
const config = describeTimelineEvent({
kind: "config_captured",
data: { schema: "archie/task-config@1", document: { BotUser: "archie" } },
});
assert.equal(config.title, "Configuration captured");
assert.doesNotMatch(config.detail, /BotUser/);
const changes = describeTimelineEvent({
kind: "changes_captured",
data: { captured_after: "commit", totals: { files: 3, additions: 40, deletions: 5 } },
});
assert.equal(changes.title, "Change capture recorded");
assert.match(changes.detail, /3 files changed/);
assert.match(changes.detail, /captured after commit/);
});
test("unknown event kinds become readable labels", () => {
assert.deepEqual(describeTimelineEvent({ kind: "human_approved", detail: "approved via dashboard" }), {
title: "Human Approved",