526c19fc21
- Persist chat stars in the operator-session registry (chat_star) so every browser/device shows the same Starred group; migrate old local stars once. - Add a compact pipeline graph shape to list responses and draw a lightweight list miniature; replace the cryptic id/version line with the stage count. - Surface OpenCode form questions as a chat card (chat_answer), replay a pending form to late subscribers, and notify for background questions. - Make the mobile dock's Search cell equal to every destination, keep the tab row visible with 100svh, and let Source use the full pane height. - Let a fresh sign-in auto-connect to its own origin; use a Lax session cookie with Expires so Remember me survives app/link launches. - Keep shipped starters and the skill agnostic: no repository paths, project areas or personal device commands; add Diagnose/Fix and Research starters. - Refresh the installed skill and document the new browser conventions.
307 lines
12 KiB
JavaScript
307 lines
12 KiB
JavaScript
// Pure unit tests for the attention / "Needs you" model (R15): qualification,
|
|
// identity, wording, ordering and tie-breaks, dismissal filtering, the
|
|
// Clear-all snapshot semantics and the localStorage encoding. No server, no DOM.
|
|
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import {
|
|
ATTENTION_STORAGE_KEY,
|
|
AttentionKind,
|
|
attentionBadgeLabel,
|
|
attentionDetail,
|
|
attentionDismiss,
|
|
attentionDismissAll,
|
|
attentionDismissalSnapshot,
|
|
attentionEntries,
|
|
startOfLocalDay,
|
|
attentionKey,
|
|
attentionKindOf,
|
|
attentionRowDescription,
|
|
decodeAttentionDismissals,
|
|
encodeAttentionDismissals,
|
|
} from "../src/attention.js";
|
|
|
|
/** A run summary with every field the attention model reads. */
|
|
function run(overrides = {}) {
|
|
return {
|
|
id: 1,
|
|
name: "Plan and land",
|
|
title: null,
|
|
status: "failed",
|
|
created_at: "2026-10-19T10:00:00Z",
|
|
finished_at: "2026-10-19T10:05:00Z",
|
|
diagnostic: "",
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Qualification
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test("only waiting and failed qualify; every other status never produces an entry", () => {
|
|
assert.equal(attentionKindOf("waiting"), AttentionKind.Decision);
|
|
assert.equal(attentionKindOf("failed"), AttentionKind.Failed);
|
|
for (const status of [
|
|
"queued",
|
|
"running",
|
|
"succeeded",
|
|
"canceled",
|
|
"cancelled",
|
|
"interrupted",
|
|
"active",
|
|
"blocked",
|
|
"skipped",
|
|
"unknown",
|
|
"",
|
|
" ",
|
|
null,
|
|
undefined,
|
|
"FAILED?",
|
|
]) {
|
|
assert.equal(attentionKindOf(status), null, `status ${JSON.stringify(status)} should not qualify`);
|
|
}
|
|
});
|
|
|
|
test("qualification trims and lowercases the server's own words", () => {
|
|
assert.equal(attentionKindOf(" Waiting "), AttentionKind.Decision);
|
|
assert.equal(attentionKindOf("Failed\n"), AttentionKind.Failed);
|
|
assert.equal(attentionKindOf("WAITING"), AttentionKind.Decision);
|
|
});
|
|
|
|
test("ranks are Decision 0 then Failed 1", () => {
|
|
assert.equal(AttentionKind.Decision.rank, 0);
|
|
assert.equal(AttentionKind.Failed.rank, 1);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Identity and wording
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test("identity is exactly {runId}:{kind}", () => {
|
|
assert.equal(attentionKey(440, AttentionKind.Failed), "440:Failed");
|
|
assert.equal(attentionKey(12, AttentionKind.Decision), "12:Decision");
|
|
});
|
|
|
|
test("detail is the fixed decision line and the trimmed diagnostic else Run failed", () => {
|
|
assert.equal(attentionDetail(AttentionKind.Decision, run()), "Waiting for your decision");
|
|
assert.equal(
|
|
attentionDetail(AttentionKind.Failed, run({ diagnostic: " boom " })),
|
|
"boom",
|
|
);
|
|
assert.equal(attentionDetail(AttentionKind.Failed, run({ diagnostic: " " })), "Run failed");
|
|
assert.equal(attentionDetail(AttentionKind.Failed, run({ diagnostic: "" })), "Run failed");
|
|
assert.equal(attentionDetail(AttentionKind.Failed, run({ diagnostic: null })), "Run failed");
|
|
});
|
|
|
|
test("label is the trimmed title else the pipeline name", () => {
|
|
const [titled] = attentionEntries([run({ title: " My run " })], new Set());
|
|
assert.equal(titled.label, "My run");
|
|
assert.equal(titled.pipeline, "Plan and land");
|
|
const [untitled] = attentionEntries([run({ title: " " })], new Set());
|
|
assert.equal(untitled.label, "Plan and land");
|
|
const [missing] = attentionEntries([run({ title: null })], new Set());
|
|
assert.equal(missing.label, "Plan and land");
|
|
});
|
|
|
|
test("row description is exactly {pipeline} · {detail}", () => {
|
|
const [entry] = attentionEntries([run({ title: "T", diagnostic: "failed hard" })], new Set());
|
|
assert.equal(attentionRowDescription(entry), "Plan and land · failed hard");
|
|
});
|
|
|
|
test("the surface is today's work: older failures are history", () => {
|
|
const entries = [
|
|
run({ id: 1, status: "failed", finished_at: "2026-10-19T21:33:27Z" }),
|
|
run({ id: 2, status: "failed", finished_at: "2026-10-20T10:00:00Z" }),
|
|
];
|
|
const since = Date.parse("2026-10-20T00:00:00Z");
|
|
assert.deepEqual(
|
|
attentionEntries(entries, new Set(), { since }).map((entry) => entry.runId),
|
|
[2],
|
|
);
|
|
assert.equal(attentionEntries(entries, new Set()).length, 2);
|
|
});
|
|
|
|
test("startOfLocalDay is local midnight", () => {
|
|
const now = new Date(2026, 9, 20, 15, 4, 5).getTime();
|
|
const start = startOfLocalDay(now);
|
|
assert.equal(new Date(start).getHours(), 0);
|
|
assert.equal(new Date(start).getMinutes(), 0);
|
|
assert.ok(start < now);
|
|
});
|
|
|
|
test("badge label is bare Notifications when empty, else the count", () => {
|
|
assert.equal(attentionBadgeLabel(0), "Notifications");
|
|
assert.equal(attentionBadgeLabel(-3), "Notifications");
|
|
assert.equal(attentionBadgeLabel(1), "Notifications, 1 needing attention");
|
|
assert.equal(attentionBadgeLabel(171), "Notifications, 171 needing attention");
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Ordering
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test("orders by kind rank, then recency descending, then run id descending", () => {
|
|
const runs = [
|
|
run({ id: 10, status: "failed", finished_at: "2026-10-19T10:00:00Z" }),
|
|
run({ id: 11, status: "waiting", finished_at: "2026-10-19T09:00:00Z" }),
|
|
run({ id: 12, status: "failed", finished_at: "2026-10-19T11:00:00Z" }),
|
|
run({ id: 13, status: "waiting", finished_at: "2026-10-19T08:00:00Z" }),
|
|
];
|
|
const entries = attentionEntries(runs, new Set());
|
|
assert.deepEqual(
|
|
entries.map((entry) => entry.runId),
|
|
[11, 13, 12, 10],
|
|
);
|
|
});
|
|
|
|
test("recency falls back to created_at when finished_at is blank", () => {
|
|
const runs = [
|
|
run({ id: 1, status: "failed", finished_at: "", created_at: "2026-10-19T12:00:00Z" }),
|
|
run({ id: 2, status: "failed", finished_at: "2026-10-19T11:00:00Z" }),
|
|
];
|
|
const entries = attentionEntries(runs, new Set());
|
|
assert.deepEqual(entries.map((entry) => entry.runId), [1, 2]);
|
|
});
|
|
|
|
test("equal kind and recency break ties by run id descending and stay stable", () => {
|
|
const runs = [
|
|
run({ id: 3, status: "failed", finished_at: "2026-10-19T10:00:00Z" }),
|
|
run({ id: 9, status: "failed", finished_at: "2026-10-19T10:00:00Z" }),
|
|
run({ id: 5, status: "failed", finished_at: "2026-10-19T10:00:00Z" }),
|
|
];
|
|
const first = attentionEntries(runs, new Set()).map((entry) => entry.runId);
|
|
const second = attentionEntries([...runs].reverse(), new Set()).map((entry) => entry.runId);
|
|
assert.deepEqual(first, [9, 5, 3]);
|
|
assert.deepEqual(second, [9, 5, 3]);
|
|
});
|
|
|
|
test("non-qualifying runs are dropped entirely", () => {
|
|
const runs = [
|
|
run({ id: 1, status: "succeeded" }),
|
|
run({ id: 2, status: "running" }),
|
|
run({ id: 3, status: "failed" }),
|
|
run({ id: 4, status: "queued" }),
|
|
];
|
|
assert.deepEqual(
|
|
attentionEntries(runs, new Set()).map((entry) => entry.runId),
|
|
[3],
|
|
);
|
|
assert.deepEqual(attentionEntries(null, new Set()), []);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Dismissal filtering
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test("a dismissed identity is filtered out; a still-waiting dismissed entry never returns", () => {
|
|
const runs = [run({ id: 7, status: "waiting", title: "Wait" })];
|
|
const dismissed = new Set(["7:Decision"]);
|
|
assert.deepEqual(attentionEntries(runs, dismissed), []);
|
|
// Re-deriving from the same live list stays empty.
|
|
assert.deepEqual(attentionEntries(runs, dismissed), []);
|
|
});
|
|
|
|
test("a different kind for the same run is a different identity and still appears", () => {
|
|
const waiting = run({ id: 7, status: "waiting" });
|
|
const dismissed = new Set(["7:Decision"]);
|
|
assert.deepEqual(attentionEntries([waiting], dismissed), []);
|
|
// The same run later fails: a new kind, a new identity, a new entry.
|
|
const failed = run({ id: 7, status: "failed", diagnostic: "later failure" });
|
|
const entries = attentionEntries([failed], dismissed);
|
|
assert.equal(entries.length, 1);
|
|
assert.equal(entries[0].key, "7:Failed");
|
|
assert.equal(entries[0].detail, "later failure");
|
|
});
|
|
|
|
test("dismissing one kind leaves the other kind of the same run", () => {
|
|
const runs = [
|
|
run({ id: 7, status: "waiting" }),
|
|
run({ id: 7, status: "failed" }),
|
|
];
|
|
// Two entries for one run id, one per kind.
|
|
const both = attentionEntries(runs, new Set());
|
|
assert.equal(both.length, 2);
|
|
const afterDismiss = attentionEntries(runs, new Set(["7:Failed"]));
|
|
assert.deepEqual(afterDismiss.map((entry) => entry.kind), [AttentionKind.Decision]);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Dismissal bookkeeping and the Clear-all snapshot
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test("attentionDismiss adds a key once and ignores a blank key", () => {
|
|
const one = attentionDismiss(new Set(), "1:Failed");
|
|
assert.deepEqual([...one], ["1:Failed"]);
|
|
const again = attentionDismiss(one, "1:Failed");
|
|
assert.deepEqual([...again], ["1:Failed"]);
|
|
const blank = attentionDismiss(one, "");
|
|
assert.deepEqual([...blank], ["1:Failed"]);
|
|
});
|
|
|
|
test("clear all applies only the identities in the open snapshot", () => {
|
|
const [a] = attentionEntries([run({ id: 1, status: "failed" })], new Set());
|
|
const snapshot = attentionDismissalSnapshot([a]);
|
|
// A later entry (arrived while the sheet was open) is not in the snapshot.
|
|
const [b] = attentionEntries([run({ id: 2, status: "failed" })], new Set());
|
|
const after = attentionDismissAll(new Set(), snapshot);
|
|
assert.deepEqual([...after].sort(), ["1:Failed"]);
|
|
assert.equal(after.has(b.key), false);
|
|
// And it does not retroactively appear from the live set either.
|
|
assert.deepEqual(
|
|
attentionEntries([run({ id: 1, status: "failed" }), run({ id: 2, status: "failed" })], after).map(
|
|
(entry) => entry.runId,
|
|
),
|
|
[2],
|
|
);
|
|
});
|
|
|
|
test("the dismissal snapshot is a defensive copy", () => {
|
|
const [a, b] = attentionEntries(
|
|
[run({ id: 1, status: "failed" }), run({ id: 2, status: "failed" })],
|
|
new Set(),
|
|
);
|
|
const live = [a, b];
|
|
const snapshot = attentionDismissalSnapshot(live);
|
|
live.push(run({ id: 3, status: "failed" }));
|
|
live.reverse();
|
|
assert.deepEqual(
|
|
snapshot.map((entry) => entry.runId),
|
|
[a.runId, b.runId],
|
|
);
|
|
assert.notEqual(snapshot, live);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Persistence
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test("the storage key is the one documented key", () => {
|
|
assert.equal(ATTENTION_STORAGE_KEY, "pipelines.web.attention.v1");
|
|
});
|
|
|
|
test("encoding is one sorted JSON array and round-trips", () => {
|
|
const encoded = encodeAttentionDismissals(new Set(["9:Failed", "1:Decision", "4:Failed"]));
|
|
assert.deepEqual(JSON.parse(encoded), ["1:Decision", "4:Failed", "9:Failed"]);
|
|
const decoded = decodeAttentionDismissals(encoded);
|
|
assert.deepEqual([...decoded].sort(), ["1:Decision", "4:Failed", "9:Failed"]);
|
|
assert.deepEqual(JSON.parse(encodeAttentionDismissals(new Set())), []);
|
|
});
|
|
|
|
test("blank or unreadable storage decodes to empty and never throws", () => {
|
|
for (const stored of ["", " ", null, undefined, "not json", "{", '"a string"', "{}", "42"]) {
|
|
assert.deepEqual([...decodeAttentionDismissals(stored)], []);
|
|
}
|
|
});
|
|
|
|
test("a JSON array with non-string members keeps only the strings", () => {
|
|
const decoded = decodeAttentionDismissals('["1:Failed", 2, null, {"a":1}, "3:Decision", ""]');
|
|
assert.deepEqual([...decoded].sort(), ["1:Failed", "3:Decision"]);
|
|
});
|
|
|
|
test("there is no expiry: a stored identity survives any timestamp", () => {
|
|
// The encoding is opaque to time; decoding never consults a clock or drops by age.
|
|
const stored = encodeAttentionDismissals(new Set(["7:Decision"]));
|
|
assert.deepEqual([...decodeAttentionDismissals(stored)], ["7:Decision"]);
|
|
});
|