Files
plan2code/scripts/test-web-console-page-session.mjs
T

923 lines
55 KiB
JavaScript

// Page tests for how a session ends and comes back: the finished screen and
// its buttons, Stop and Stop with a handoff, and a page that loses its server
// and finds it again after a resume. Run with:
// node --test scripts/test-web-console-page-session.mjs
//
// Each test drives the real console in a real Chrome or Edge through
// scripts/page-test-helpers.mjs: one browser for the file, a fresh console
// session per test.
import test from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";
import { pageSuite, openSession, itemCard, drawn, textOf, tempProject } from "./page-test-helpers.mjs";
import { cli, until } from "./web-console-test-helpers.mjs";
import { STOP_HANDOFF_REPLY, HOME_REPLY } from "../src/web-console/public/answers.js";
// How long the page waits without contact before it calls itself offline:
// the page's own constant, so this file never drifts from it.
import { GONE_AFTER_MS } from "../src/web-console/public/screens/core.js";
const suite = pageSuite(test);
// The banner the page raises when it loses its server mid-session.
const LOST_CONTACT = /Lost contact with Plan2Code\. Nothing you have typed is lost\./;
// A plan session on the person's turn, the way an agent opens one: one text
// question and the agent listening.
const PLAN_QUESTION = {
items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name for the export." }],
agent: { status: "waiting" },
};
// The agent's side of `stop`, leaving the browser context open (s.stop()
// closes it, which would hide what the page does next).
async function stopServer(s) {
cli(["stop", "--session", s.sid], { cwd: s.project });
assert.ok(await until(async () => !(await s.answers()), 5000), "the server still answers after stop");
}
// The one send `wait` hands the agent; fails the test when nothing arrived.
function collect(s) {
const got = s.wait(10);
assert.equal(got.code, 0, `nothing was sent (wait exit ${got.code}): ${got.message || ""}`);
return got;
}
// Local helper: checks `fn` keeps returning true for `ms`. A sleep would
// prove nothing; this fails the moment the page shows what it must not.
async function holds(fn, ms) {
const end = Date.now() + ms;
while (Date.now() < end) {
if (!(await fn())) return false;
await new Promise((r) => setTimeout(r, 100));
}
return true;
}
test("the finished screen shows the next command with --web, copies it, turns Send off, and Back to the dashboard reaches the agent", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.context.grantPermissions(["clipboard-read", "clipboard-write"], { origin: new URL(s.url).origin });
s.post({
settle: true,
finish: {
headline: "The plan is written",
body: "Everything is under `specs/audit-export/`. Read `PLAN.md` first.",
command: "/plan2code-2-document",
dashboard: true,
},
});
const main = s.page.locator("#main");
await main.getByRole("heading", { name: "The plan is written" }).waitFor();
const shown = main.locator("code").filter({ hasText: /^\/plan2code-2-document --web$/ });
assert.equal(await shown.count(), 1, "the command is shown once, with --web appended");
// The Copy that belongs to this command: the innermost block holding both,
// whatever wraps them.
// (`has` is matched inside each candidate, so these start from the page.)
const code = s.page.locator("code").filter({ hasText: /^\/plan2code-2-document --web$/ });
const copy = s.page.getByRole("button", { name: "Copy", exact: true });
await main.locator("*", { has: code }).filter({ has: copy }).last().getByRole("button", { name: "Copy", exact: true }).click();
await s.page.waitForFunction(async () => (await navigator.clipboard.readText()) === "/plan2code-2-document --web");
assert.equal(await s.page.evaluate(() => navigator.clipboard.readText()), "/plan2code-2-document --web");
assert.equal(await s.page.locator("#btn-send").isDisabled(), true, "Send is still on after the finish");
await main.getByRole("button", { name: "Back to the dashboard" }).click();
const got = collect(s);
assert.equal(got.type, "submit");
assert.deepEqual(
got.actions.map(({ i, type }) => ({ i, type })),
[{ i: "__dashboard", type: "dashboard" }]
);
});
// What a person sees break: no Continue here on a finish that names a skill, one
// beside a git command or a pause, one at the red meter level, or a press that
// reaches the agent as anything but the dashboard's own launch.
test("Continue here shows beside a skill's next step while the meter is not red and sends a launch with the skill and spec", async (t) => {
const browser = await suite.browser();
const next = { headline: "The plan is documented", command: "/plan2code-3-implement specs/audit-export/overview.md", dashboard: true };
const s = await openSession(browser, { t, workflow: "document", payload: { agent: { status: "working", activity: "Writing" } } });
s.post({ finish: next });
const main = s.page.locator("#main");
const go = main.getByRole("button", { name: "Continue here" });
await go.waitFor();
assert.equal(await go.count(), 1);
await go.click();
const got = collect(s);
assert.deepEqual(got.actions, [
{ i: "__launch", type: "launch", skill: "plan2code-3-implement", workflow: "implement", spec: "specs/audit-export" },
]);
assert.equal(got.reply, "Start Implement (/plan2code-3-implement) for specs/audit-export, right here in this session.");
// The hop's resume is the dashboard's: the skill's workflow and the spec.
assert.match(got.resume, /--workflow implement --spec specs\/audit-export$/);
await main.getByRole("button", { name: "Starting the next step…" }).waitFor();
assert.equal(await main.getByRole("button", { name: "Back to the dashboard" }).isDisabled(), true, "one press locks the other buttons");
// No skill to continue into: a git command, or a pause.
const git = await openSession(browser, { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
git.post({ finish: { headline: "Quick task done", command: "git add -A && git commit -m x -m y", dashboard: true } });
await git.page.locator("#main").getByRole("heading", { name: "Quick task done" }).waitFor();
assert.equal(await git.page.getByRole("button", { name: "Continue here" }).count(), 0, "a git command is not a skill");
const paused = await openSession(browser, { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
paused.post({ finish: { headline: "Paused at Phase 2", command: "/plan2code-3-implement specs/audit-export/overview.md" } });
await paused.page.locator("#main").getByRole("heading", { name: "Paused at Phase 2" }).waitFor();
assert.equal(await paused.page.getByRole("button", { name: "Continue here" }).count(), 0, "a pause is not continued");
});
test("Update CHANGELOG first shows beside Commit it now only when the finish asks for it, and sends __changelog", async (t) => {
const browser = await suite.browser();
const base = { headline: "Quick task done", command: "git add -A && git commit -m x -m y", commit: true, dashboard: true };
const plain = await openSession(browser, { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
plain.post({ finish: base });
await plain.page.locator("#main").getByRole("button", { name: "Commit it now" }).waitFor();
assert.equal(await plain.page.getByRole("button", { name: "Update CHANGELOG first" }).count(), 0, "no flag, no button");
const s = await openSession(browser, { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
s.post({ finish: { ...base, changelog: true } });
const main = s.page.locator("#main");
const go = main.getByRole("button", { name: "Update CHANGELOG first" });
await go.waitFor();
assert.equal(await main.getByRole("button", { name: "Commit it now" }).count(), 1);
await go.click();
assert.deepEqual(collect(s).actions.map(({ i, type }) => ({ i, type })), [{ i: "__changelog", type: "changelog" }]);
await main.getByRole("button", { name: "Opening Changelog…" }).waitFor();
assert.equal(await main.getByRole("button", { name: "Commit it now" }).isDisabled(), true, "one press locks the other buttons");
});
test("Continue here is hidden once the session meter is red, and the command and fresh-session advice stay", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
// Ten points: a thirty-task phase scores ten, the red level.
s.post({ run: { event: "implement-phase", id: "phase-1", tasks: 30 } });
await s.page.locator("#meter-pill[data-level='red']").waitFor();
s.post({ finish: { headline: "Phase 1 is done", command: "/plan2code-3-implement specs/audit-export/overview.md", dashboard: true } });
const main = s.page.locator("#main");
await main.getByRole("heading", { name: "Phase 1 is done" }).waitFor();
assert.equal(await main.getByRole("button", { name: "Continue here" }).count(), 0, "Continue here at red");
assert.ok(await main.locator("code").filter({ hasText: /^\/plan2code-3-implement specs\/audit-export\/overview\.md --web$/ }).count(), "the command stays");
assert.equal(await closeGuide(s).count(), 1, "the fresh-session advice stays");
});
// Under the desktop app (PLAN2CODE_IN_APP=1) the fresh-session advice in the
// meter's popover and the dashboard's red banner must point at the app's own
// New Session, never a command to copy into a terminal that is not there:
// the popover's is a button filled with the user's highlight color.
test("under the app, the meter popover and the dashboard's red banner point at New Session, not a command", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
env: { PLAN2CODE_IN_APP: "1" },
});
s.post({ run: { event: "implement-phase", id: "phase-1", tasks: 30 } });
const pill = s.page.locator("#meter-pill[data-level='red']");
await pill.waitFor();
await pill.click();
const fresh = s.page.locator("#meter-fresh");
const press = fresh.getByRole("button", { name: "Start a New Session" });
await press.waitFor();
assert.equal(await fresh.locator(".meter-fresh-text").count(), 0, "the button is the whole note, no sentence around it");
// The page's highlight, resolved the same way the button's fill is.
const [fill, highlight] = await press.evaluate((n) => {
const probe = document.createElement("i");
probe.style.color = "var(--accent)";
n.append(probe);
const color = getComputedStyle(probe).color;
probe.remove();
return [getComputedStyle(n).backgroundColor, color];
});
assert.equal(fill, highlight, "filled with the user's highlight color");
assert.equal(await fresh.locator("code").count(), 0, "no command to copy under the app");
});
// The desktop app's frame, as the page sees it: a parent that keeps every
// message posted to it, for the test to read back.
const FAKE_APP_FRAME = () => {
window.__toApp = [];
Object.defineProperty(window, "parent", { configurable: true, get: () => ({ postMessage: (m) => window.__toApp.push(m) }) });
};
const toApp = (s, kind) => s.page.evaluate((k) => window.__toApp.filter((m) => m.plan2code === k), kind);
test("under the app, the meter popover's Start a New Session button asks the app for its New Session", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
env: { PLAN2CODE_IN_APP: "1" },
init: FAKE_APP_FRAME,
});
s.post({ run: { event: "implement-phase", id: "phase-1", tasks: 30 } });
const pill = s.page.locator("#meter-pill[data-level='red']");
await pill.waitFor();
await pill.click();
await s.page.locator("#meter-fresh").getByRole("button", { name: "Start a New Session" }).click();
await until(async () => (await toApp(s, "new-session")).length === 1, 5000);
assert.deepEqual(await toApp(s, "new-session"), [{ plan2code: "new-session" }], "a named request, nothing else in it");
});
test("under the app, the not running line's continue is a button that asks the app to type it, and the page hands the app its highlight", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
clock: true,
payload: { items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name." }], agent: { status: "waiting" } },
env: { PLAN2CODE_IN_APP: "1" },
init: FAKE_APP_FRAME,
});
const looks = await toApp(s, "looks");
assert.ok(looks.length >= 1, "the page told the app its highlight");
assert.deepEqual(looks.at(-1).accent, ["#619fe5", "#1a2533", "#0c1117", "#3d5978"], "the default highlight, in its dark shades");
await s.page.clock.fastForward(200_000);
await lineSays(s, /^Plan2Code is not running right now\./);
const press = s.page.locator("#agent-text .agent-key-btn");
assert.equal(await press.textContent(), "continue");
await press.click();
await until(async () => (await toApp(s, "agent-continue")).length === 1, 5000);
assert.ok(await press.isDisabled(), "held off, so a double press does not type it twice");
});
// The app's webview opens no new windows, so a link off the page asks the
// console to open it in the default browser instead, and says where to paste
// it when that fails.
const FEEDBACK_URL = "https://github.com/jparkerweb/plan2code/issues/new/choose";
test("under the app, a link off the page goes to the default browser through the console, not a new window", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION, env: { PLAN2CODE_IN_APP: "1" }, init: FAKE_APP_FRAME });
const asked = [];
await s.page.route("**/open-link", async (route) => {
asked.push(route.request().postDataJSON());
await route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify({ ok: true, url: FEEDBACK_URL }) });
});
let popups = 0;
s.page.context().on("page", () => popups++);
await s.page.locator("#btn-feedback").click();
await until(async () => asked.length === 1, 5000);
assert.deepEqual(asked, [{ url: FEEDBACK_URL }]);
await new Promise((r) => setTimeout(r, 300));
assert.equal(popups, 0, "no window opened inside the app");
});
test("under the app, a link the console cannot open is shown to paste into a browser", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION, env: { PLAN2CODE_IN_APP: "1" }, init: FAKE_APP_FRAME });
await s.page.route("**/open-link", (route) => route.fulfill({ status: 500, contentType: "application/json", body: "{}" }));
await s.page.locator("#btn-feedback").click();
await s.page.waitForFunction((u) => document.getElementById("banner").textContent.includes(u), FEEDBACK_URL, { timeout: 5000 });
assert.match(await s.page.locator("#banner").innerText(), /paste it into your browser/i);
});
test("outside the app, a link off the page opens as a plain link, with no detour through the console", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
let asked = 0;
await s.page.route("**/open-link", (route) => {
asked++;
return route.fulfill({ status: 200, contentType: "application/json", body: "{}" });
});
const popup = s.page.context().waitForEvent("page", { timeout: 5000 });
await s.page.locator("#btn-feedback").click();
await (await popup).close();
assert.equal(asked, 0);
});
test("outside the app, the not running line's continue stays a word to type", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
clock: true,
payload: { items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name." }], agent: { status: "waiting" } },
});
await s.page.clock.fastForward(200_000);
await lineSays(s, /^Plan2Code is not running right now\./);
assert.equal(await s.page.locator("#agent-text .agent-key-btn").count(), 0);
assert.equal(await s.page.locator("#agent-text strong.agent-key").textContent(), "continue");
});
test("Stop session, confirmed, sends __stop with no handoff", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.click("#btn-stop");
await s.page.locator("#stop-go").click();
const got = collect(s);
assert.equal(got.type, "submit");
const stop = got.actions.find((a) => a.i === "__stop");
assert.deepEqual(stop, { i: "__stop", type: "stop" });
});
test("Stop with a handoff sends __stop with handoff, and the paused finish and stop that follow end on the paused screen, not an error", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.click("#btn-stop");
const handoff = s.page.locator("#stop-handoff");
assert.equal(await handoff.isVisible(), true, "the handoff choice is offered off the dashboard");
await handoff.click();
const got = collect(s);
assert.equal(got.type, "submit");
const stop = got.actions.find((a) => a.i === "__stop");
assert.deepEqual(stop, { i: "__stop", type: "stop", handoff: true });
// What the agent does next (console-stop.md): a paused finish without
// --wait and no dashboard, then `stop`.
s.post({
settle: true,
finish: {
headline: "Paused at the naming question",
body: "Your place is saved, and a handoff is waiting on the dashboard. The naming question is still open.",
command: "/plan2code-1-plan",
},
});
const main = s.page.locator("#main");
await main.getByRole("heading", { name: "Paused at the naming question" }).waitFor();
await stopServer(s);
// The page needs GONE_AFTER_MS without contact before it would call the
// server lost. Through that window and past it, the paused screen stays.
const settled = async () =>
!LOST_CONTACT.test(await s.page.locator("#banner").innerText()) &&
!(await s.page.locator("#planny").getAttribute("class")).includes("is-gone");
assert.ok(await holds(settled, GONE_AFTER_MS + 3000), "the page raised a lost-contact state after a paused finish");
assert.match(await main.innerText(), /Session paused/i);
assert.match(await textOf(s.page.locator("#agent-text")), /^Paused\./);
assert.ok(await main.locator("code").filter({ hasText: /^\/plan2code-1-plan --web$/ }).count(), "the resume command is gone");
});
// Someone who presses Stop and steps away comes back to an answer: the
// wrapping-up dialog turns into Done once the stop lands and stays up until
// it is closed, rather than quietly going away.
test("the wrapping-up dialog says Done when the stop lands, and stays until closed", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.click("#btn-stop");
await s.page.locator("#stop-go").click();
const dlg = s.page.locator("#stopping-modal");
await dlg.waitFor();
assert.equal(await s.page.locator("#stopping-title").textContent(), "Wrapping up");
assert.doesNotMatch(await dlg.innerText(), /close the (window|tab)/i, "no advice to close the page mid-stop");
collect(s);
s.post({ settle: true, finish: { headline: "Paused at the naming question", body: "Your place is saved.", command: "/plan2code-1-plan" } });
await s.page.locator("#main").getByRole("heading", { name: "Paused at the naming question" }).waitFor();
await s.page.locator("#stopping-title").getByText("Done", { exact: true }).waitFor();
assert.equal(await s.page.locator("#stop-steps li.is-done").count(), 3, "every step ticked");
assert.ok(await holds(async () => dlg.isVisible(), 2000), "Done stays up on its own");
await s.page.locator("#stopping-hide").getByText("Close", { exact: true }).click();
await dlg.waitFor({ state: "hidden" });
});
test("a page that loses its server goes offline, and after a resume it shows the session again with the unsent answer still typed", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
const field = () => itemCard(s.page, "q1").locator("textarea, input[type=text]").first();
await field().fill("audit-export");
// Typed, not sent: the page mirrors it to the server's draft.json, which
// is what a page on a new port reads back (localStorage is per origin).
const draftFile = path.join(s.session, "draft.json");
assert.ok(
await until(() => fs.existsSync(draftFile) && fs.readFileSync(draftFile, "utf8").includes("audit-export"), 5000),
"the typed answer never reached the server's draft"
);
await stopServer(s);
await s.page.waitForFunction(() => document.getElementById("planny").classList.contains("is-gone"), null, {
timeout: GONE_AFTER_MS + 10000,
});
assert.match(await textOf(s.page.locator("#agent-text")), /^Not connected\. Your answers are saved\./);
assert.match(await s.page.locator("#banner").innerText(), LOST_CONTACT);
assert.equal(await s.page.locator("#btn-send").isDisabled(), true, "Send is on with no server");
const resumed = cli(["open", "--resume", s.sid, "--workflow", "plan", "--no-open"], { cwd: s.project }).json;
assert.ok(resumed && resumed.url, "the resume printed no url");
await s.page.goto(resumed.url, { waitUntil: "domcontentloaded" });
await drawn(s.page);
await itemCard(s.page, "q1").getByText("What to call it").first().waitFor();
assert.equal(await field().inputValue(), "audit-export", "the unsent answer was lost across the resume");
assert.equal(await s.page.locator("#planny").evaluate((n) => n.classList.contains("is-gone")), false);
});
// The status line beside Planny, and its "What to check" button when it has
// one. The button opens Help on the stuck tab.
const statusLine = (s) => s.page.locator("#agent-text");
const whatToCheck = (s) => statusLine(s).getByRole("button", { name: "What to check" });
async function lineSays(s, re) {
await s.page.waitForFunction((src) => new RegExp(src).test(document.getElementById("agent-text").textContent), re.source, { timeout: 10000 });
return textOf(statusLine(s));
}
test("the quiet, not running and not connected lines offer What to check, opening Help on the stuck tab, and the plain lines do not", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
clock: true,
payload: { headline: { stage: "Phase 1", cleared: 0, total: 3 }, agent: { status: "working", activity: "Task 1 of 3: the reader" } },
});
// Working, and heard from just now: the plain working line.
await lineSays(s, /Task 1 of 3: the reader/);
assert.equal(await whatToCheck(s).count(), 0, "the working line is plain");
// Quiet for 30 s: the approval hint, with the button.
await s.page.clock.fastForward(40_000);
await lineSays(s, /waiting on an approval in your terminal/);
assert.equal(await whatToCheck(s).count(), 1, "the approval hint carries What to check");
// Quiet for two minutes: still working, and the button stays.
await s.page.clock.fastForward(100_000);
await lineSays(s, /^Still working on it\./);
assert.equal(await whatToCheck(s).count(), 1, "the quiet working line carries What to check");
// Back to real time, and the agent asks something: the person's turn is plain.
await s.page.clock.setSystemTime(Date.now());
s.post({ items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name." }], agent: { status: "waiting" } });
await lineSays(s, /^Your turn: 1 question waiting\./);
assert.equal(await whatToCheck(s).count(), 0, "the your-turn line is plain");
// Nobody listening for three minutes: not running, with the button.
await s.page.clock.fastForward(200_000);
await lineSays(s, /^Plan2Code is not running right now\./);
assert.equal(await whatToCheck(s).count(), 1, "the not running line carries What to check");
await whatToCheck(s).click();
await s.page.locator("#help-modal[open]").waitFor();
assert.equal(await s.page.locator("#help-tab-stuck").getAttribute("aria-selected"), "true", "Help opened on the stuck tab");
await s.page.keyboard.press("Escape");
await s.page.locator("#help-modal[open]").waitFor({ state: "detached" });
// Answered and sent, never collected, and nobody listening: the saved line.
await s.page.clock.setSystemTime(Date.now());
s.post({ agent: { status: "waiting" } });
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-send");
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
assert.equal(await whatToCheck(s).count(), 0, "the sent line is plain");
await s.page.clock.fastForward(200_000);
await lineSays(s, /^Plan2Code is not running\. Your answers are saved and waiting for it\./);
assert.equal(await whatToCheck(s).count(), 1, "the saved-and-waiting line carries What to check");
// No server at all: not connected, with the button.
await stopServer(s);
for (let i = 0; i < 20 && !(await s.page.locator("#planny.is-gone").count()); i++) {
await s.page.clock.fastForward(GONE_AFTER_MS);
await new Promise((r) => setTimeout(r, 250));
}
await lineSays(s, /^Not connected\. Your answers are saved\./);
assert.equal(await whatToCheck(s).count(), 1, "the not connected line carries What to check");
});
// An agent sitting in `wait` pings every five seconds and collects a send at
// once, so answers still uncollected after a minute of its silence mean
// nothing is listening: the wake-up help shows then, not after three minutes.
test("answers a waiting agent never collects bring up the saved-and-waiting line after a minute of silence, not before", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", clock: true, payload: PLAN_QUESTION });
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-send");
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
await s.page.clock.fastForward(30_000);
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
await s.page.clock.fastForward(40_000);
await lineSays(s, /^Plan2Code is not running\. Your answers are saved and waiting for it\./);
assert.equal(await whatToCheck(s).count(), 1, "the line carries What to check");
});
// An agent that asked and carried on working collects at its next `wait`, so
// a minute is no proof against it; three minutes of silence is, whatever
// longer quiet allowance it gave itself before it went.
test("answers a working agent has not collected bring up the saved-and-waiting line after three minutes, not its long quiet allowance", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "implement", clock: true, payload: PLAN_QUESTION });
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-send");
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
// Its last word before it went quiet: working, with half an hour to spare.
s.post({ agent: { status: "working", activity: "Task 1 of 3: the reader", quietMinutes: 30 } });
await lineSays(s, /Task 1 of 3: the reader/);
await s.page.clock.fastForward(70_000);
await lineSays(s, /Task 1 of 3: the reader/);
await s.page.clock.fastForward(130_000);
await lineSays(s, /^Plan2Code is not running\. Your answers are saved and waiting for it\./);
assert.equal(await whatToCheck(s).count(), 1, "the line carries What to check");
});
// A failed Send says why at once, rather than one line for every cause and
// the real state only showing once the page's own timers catch up.
test("a Send that finds the server gone says so at once, with the reconnect help", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await stopServer(s);
await s.page.click("#btn-send");
await s.page.waitForFunction(() => document.getElementById("planny").classList.contains("is-gone"), null, { timeout: 3000 });
assert.match(await s.page.locator("#banner").innerText(), LOST_CONTACT);
assert.match(await textOf(statusLine(s)), /^Not connected\. Your answers are saved\./);
assert.equal(await whatToCheck(s).count(), 1, "the not connected line carries What to check");
});
test("a Send the server refuses shows the server's reason", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.route("**/submit", (route) =>
route.fulfill({ status: 500, contentType: "application/json", body: JSON.stringify({ error: "the disk is full" }) })
);
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-send");
await s.page.waitForFunction(() => /the disk is full/.test(document.getElementById("banner").textContent), null, { timeout: 3000 });
assert.match(await s.page.locator("#banner").innerText(), /Nothing was lost/);
});
test("a Send the server refuses as too large says to remove an attachment, not to try the same send again", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.route("**/submit", (route) =>
route.fulfill({ status: 413, contentType: "application/json", body: JSON.stringify({ error: "too large" }) })
);
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-send");
await s.page.waitForFunction(() => /remove an attachment/.test(document.getElementById("banner").textContent), null, { timeout: 3000 });
assert.doesNotMatch(await s.page.locator("#banner").innerText(), /try Send again/);
});
test("a Send lost on the way, with the server still up, says the console is there and to send again", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.route("**/submit", (route) => route.abort());
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-send");
await s.page.waitForFunction(() => /console is still up/.test(document.getElementById("banner").textContent), null, { timeout: 3000 });
assert.equal(await s.page.locator("#planny").evaluate((n) => n.classList.contains("is-gone")), false, "not called gone");
});
test("an answered finish offer comes back unanswered on a later finish, once the first finish has gone", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
const finishWith = (headline) => s.post({ finish: { headline, command: "/plan2code-3-implement specs/audit-export/overview.md", dashboard: true } });
const main = s.page.locator("#main");
finishWith("Phase 1 is done");
await main.getByRole("heading", { name: "Phase 1 is done" }).waitFor();
await main.getByRole("button", { name: "Back to the dashboard" }).click();
assert.deepEqual(collect(s).actions.map(({ i }) => i), ["__dashboard"]);
await lineSays(s, /^Opening the dashboard…/);
// The agent takes the press somewhere that clears the finish, and a later
// phase ends: that finish starts with its own offer unanswered.
s.post({ finish: null, agent: { status: "working", activity: "Task 1 of 1" } });
await lineSays(s, /Task 1 of 1/);
finishWith("Phase 2 is done");
await main.getByRole("heading", { name: "Phase 2 is done" }).waitFor();
await lineSays(s, /^Done\. Head back to the dashboard, or close this tab\./);
assert.equal(await main.getByRole("button", { name: "Back to the dashboard" }).count(), 1, "the later finish offers the way back again");
});
test("a finished session never puts a sent answer back on its form", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await itemCard(s.page, "q1").locator("textarea").fill("audit-export");
await s.page.click("#btn-send");
collect(s);
// Collected and left open, then the session ends: nothing more can be sent,
// so the answer stays sent rather than coming back to edit. It would show
// once the finish goes away (a review taken up), as an answer ready to send.
s.post({ finish: { headline: "The plan is written", command: "/plan2code-2-document" }, agent: { status: "waiting" } });
await s.page.locator("#main").getByRole("heading", { name: "The plan is written" }).waitFor();
s.post({ finish: null, agent: { status: "waiting" } });
await s.page.locator("#main").getByRole("heading", { name: "The plan is written" }).waitFor({ state: "detached" });
const q1 = s.page.locator("#sidebar").getByRole("button", { name: /What to call it/ });
await q1.click();
await itemCard(s.page, "q1").waitFor();
const mark = q1.locator(".rail-mark");
assert.notEqual(await mark.getAttribute("title"), "ready to send", "the sent answer came back on the form");
const box = itemCard(s.page, "q1").locator("textarea");
assert.notEqual((await box.count()) ? await box.inputValue() : "", "audit-export", "the sent answer is back in its box");
});
test("the footer keeps its workspace label on the dashboard, and the label opens the Workspace dialog", async (t) => {
const project = tempProject();
const name = path.basename(project);
const s = await openSession(await suite.browser(), { t, workflow: "dashboard", project });
// Past Planny's wake-up and, on this console home's first run, the Welcome.
await s.page.getByRole("button", { name: "Skip the intro" }).click();
await s.page.locator("#main").getByRole("heading", { name: "What are we doing today?" }).waitFor();
const welcomeDone = s.page.getByRole("button", { name: "Start building" });
if (await welcomeDone.isVisible()) await welcomeDone.click();
await welcomeDone.waitFor({ state: "hidden" });
const foot = s.page.locator("footer.footer");
const where = s.page.locator("#footer-where");
await where.waitFor();
// The dashboard drops the summary and Send, never the label.
assert.equal(await foot.evaluate((f) => f.classList.contains("is-dash")), true, "the dashboard's footer is marked is-dash");
assert.equal(await s.page.locator("#footer-summary").isVisible(), false, "the summary shows on the dashboard");
assert.equal(await s.page.locator("#btn-send").isVisible(), false, "Send shows on the dashboard");
assert.match(await textOf(where), new RegExp(`^${name}`), "the label names the project");
assert.equal(await where.getAttribute("title"), "Open workspace");
assert.match(await where.getAttribute("aria-label"), new RegExp(`^Open workspace: ${name}`));
// A click opens the Workspace dialog on the session's folders; leaving the
// label leaves it as it was (no copied state to undo).
await where.click();
await s.page.locator("#workspace-modal[open]").waitFor();
assert.match(await textOf(s.page.locator("#workspace-list")), new RegExp(name));
await s.page.keyboard.press("Escape");
await s.page.locator("#workspace-modal[open]").waitFor({ state: "detached" });
await s.page.locator("body").click({ position: { x: 5, y: 5 } });
assert.match(await textOf(where), new RegExp(`^${name}`), "the label changed after a click away");
});
test("a workflow page uses its modules: the full footer, the session meter, @ suggestions and the tab icon", async (t) => {
const project = tempProject();
const name = path.basename(project);
const s = await openSession(await suite.browser(), { t, workflow: "plan", project, payload: PLAN_QUESTION });
// Off the dashboard the footer is whole (workspace.js names the label).
assert.equal(await s.page.locator("footer.footer").evaluate((f) => f.classList.contains("is-dash")), false);
assert.equal(await s.page.locator("#btn-send").isVisible(), true);
// meter.js: the pill shows once a frame carries the meter.
await s.page.locator("#meter-pill").waitFor();
assert.ok((await textOf(s.page.locator("#meter-words"))).length, "the meter pill has no words");
// mentions.js: an @ in a text box offers the workspace's folders.
const box = itemCard(s.page, "q1").locator("textarea");
await box.click();
await box.pressSequentially("See @");
await s.page.locator("#mention-pop").waitFor();
assert.match(await textOf(s.page.locator("#mention-pop")), new RegExp(name));
// favicon.js: the person's move puts a bar on the tab icon.
await s.page.waitForFunction(() => document.querySelector('link[rel="icon"][type="image/svg+xml"]').href.startsWith("data:image/svg+xml"));
});
// The dashboard, past Planny's wake-up and the first-run Welcome.
async function pastTheIntro(s) {
const skip = s.page.getByRole("button", { name: "Skip the intro" });
await skip.click();
await s.page.locator("#main").getByRole("heading", { name: "What are we doing today?" }).waitFor();
const welcomeDone = s.page.getByRole("button", { name: "Start building" });
if (await welcomeDone.isVisible()) await welcomeDone.click();
await welcomeDone.waitFor({ state: "hidden" });
}
// What a person sees break: a handoff offered where there is nothing to hand off.
test("the stop dialog offers a handoff in a workflow and one plain Stop on the dashboard", async (t) => {
const plan = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "waiting" }, items: PLAN_QUESTION.items } });
await plan.page.click("#btn-stop");
const modal = plan.page.locator("#stop-modal");
await modal.waitFor();
assert.match(await textOf(modal), /Stop with a handoff/);
assert.match(await textOf(modal.locator("#stop-go")), /Just stop and save/);
const dash = await openSession(await suite.browser(), { t, workflow: "dashboard", payload: { agent: { status: "waiting" } } });
await pastTheIntro(dash);
await dash.page.click("#btn-stop");
await dash.page.locator("#stop-modal").waitFor();
assert.equal(await dash.page.locator("#stop-handoff").isVisible(), false, "the dashboard offers a handoff");
assert.match(await textOf(dash.page.locator("#stop-go")), /Stop\s+Ends the console session\./);
assert.doesNotMatch(await textOf(dash.page.locator("#stop-modal")), /Stop with a handoff/);
});
// What the agent would misread: a handoff stop that carries the plain stop's words.
test("Stop with a handoff sends its own reply line beside the stop, and a plain stop sends another", async (t) => {
const handoff = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "waiting" }, items: PLAN_QUESTION.items } });
await handoff.page.click("#btn-stop");
await handoff.page.locator("#stop-handoff").click();
const got = collect(handoff);
assert.deepEqual(got.actions.find((a) => a.i === "__stop"), { i: "__stop", type: "stop", handoff: true });
assert.ok(got.reply.includes(STOP_HANDOFF_REPLY), `the handoff stop's words: ${got.reply}`);
const plain = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "waiting" }, items: PLAN_QUESTION.items } });
await plain.page.click("#btn-stop");
await plain.page.locator("#stop-go").click();
const sent = collect(plain);
assert.equal(sent.actions.find((a) => a.i === "__stop").handoff, undefined);
assert.ok(!sent.reply.includes(STOP_HANDOFF_REPLY), "a plain stop asked for a handoff");
});
// A finish that offers a review, a commit and the dashboard, on a build.
const OFFERS = { headline: "Quick task done", command: "/plan2code-5-git", review: true, commit: true, dashboard: true };
const closeGuide = (s) => s.page.getByRole("region", { name: "Before you close this" });
// What a person sees break: "Safe to close" printed under "Review requested", or the review offer coming back after a reload.
test("Before you close this shows while a review is on offer, goes while it is asked, and the asked offer stays locked after a reload", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
s.post({ finish: OFFERS });
const main = s.page.locator("#main");
const reviewNow = main.getByRole("button", { name: "Review it now" });
await reviewNow.waitFor();
assert.equal(await closeGuide(s).count(), 1, "a review only on offer must not hide the guide");
assert.match(await textOf(main), /The review is optional\./);
await reviewNow.click();
const got = collect(s);
assert.deepEqual(got.actions.map(({ i, type }) => ({ i, type })), [{ i: "__review", type: "review" }]);
await main.getByRole("button", { name: "Review requested…" }).waitFor();
assert.equal(await closeGuide(s).count(), 0, "the guide shows while a review is starting");
assert.equal(await main.getByRole("button", { name: "No thanks, I am done" }).count(), 0);
// The press is remembered: the buttons do not come back on a reload.
await s.page.reload({ waitUntil: "domcontentloaded" });
await drawn(s.page);
await main.getByRole("button", { name: "Review requested…" }).waitFor();
assert.equal(await main.getByRole("button", { name: "Review it now" }).count(), 0);
assert.equal(await closeGuide(s).count(), 0, "the guide came back on a reload");
});
// What a person sees break: the guide missing while a commit or the dashboard
// is starting (it would say "start a new one" under "Opening Git"), or missing
// once they said they are done or the server is gone.
test("Before you close this goes while a commit or the dashboard is starting, and stays once they are done or the server is gone", async (t) => {
const browser = await suite.browser();
const finishPage = async (opts) => {
const s = await openSession(browser, { t, workflow: "quick-task", ...opts, payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
s.post({ finish: OFFERS });
await s.page.locator("#main").getByRole("heading", { name: "Quick task done" }).waitFor();
assert.equal(await closeGuide(s).count(), 1, "a plain finish shows the guide");
return s;
};
const cases = [
["Commit it now", "__commit", "Opening Git…", 0],
["Back to the dashboard", "__dashboard", "Opening the dashboard…", 0],
["No thanks, I am done", "__done", null, 1],
];
for (const [button, id, asked, guides] of cases) {
const s = await finishPage({});
await s.page.locator("#main").getByRole("button", { name: button }).click();
assert.deepEqual(collect(s).actions.map((a) => a.i), [id]);
if (asked) await s.page.locator("#main").getByRole("button", { name: asked }).waitFor();
assert.equal(await closeGuide(s).count(), guides, `the guide after ${button}`);
}
// A review asked, then the server gone: nothing is starting any more.
const gone = await finishPage({ clock: true });
await gone.page.locator("#main").getByRole("button", { name: "Review it now" }).click();
collect(gone);
assert.equal(await closeGuide(gone).count(), 0);
await stopServer(gone);
for (let i = 0; i < 20 && !(await gone.page.locator("#planny.is-gone").count()); i++) {
await gone.page.clock.fastForward(GONE_AFTER_MS);
await new Promise((r) => setTimeout(r, 250));
}
await closeGuide(gone).waitFor();
});
// What a person sees break: a finished screen with no Before you close this,
// a pause that promises the wrong thing, or the guide's own text going wrong.
test("every finished shape shows Before you close this with its three rows, and a pause names the resume command", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
const main = s.page.locator("#main");
const shapes = [
["A skill next", { command: "/plan2code-4-finalize" }, /A new session starts from clean context/, /Paste the command above in the new session, or start from the dashboard with \/plan2code\./],
["A terminal command next", { command: "git status" }, /A new session starts from clean context/, /Run the command above in your terminal, then start the next step/],
["Nothing left", {}, /A new session starts from clean context/, /In the new session, start from the dashboard with \/plan2code\./],
["Paused here", { command: "/plan2code-3-implement specs/x/overview.md" }, /Your saved place is picked up by the resume command above\./, /Paste the command above/],
];
for (const [headline, rest, fresh, carry] of shapes) {
s.post({ finish: { headline, ...rest } });
await main.getByRole("heading", { name: headline }).waitFor();
const guide = closeGuide(s);
assert.equal(await guide.count(), 1, `${headline}: one guide`);
assert.equal(await guide.locator("li").count(), 3, `${headline}: three rows`);
const text = await textOf(guide);
for (const label of ["Before you close this", "Safe to close", "Start fresh", "Carry on"]) assert.ok(text.includes(label), `${headline}: says "${label}"`);
assert.match(text, fresh, `${headline}: the Start fresh sentence`);
assert.match(text, carry, `${headline}: the Carry on sentence`);
assert.ok(!text.includes("—"), `${headline}: the guide carries an em dash`);
}
// With a stop warning up, a pause's command starts the work again.
s.post({ stopWarning: "Answers since the last save will not be kept." });
await closeGuide(s).getByText(/The command above starts it again\./).waitFor();
assert.equal(await s.page.locator("#btn-home").isVisible(), false, "a finished screen carries its own way back");
});
// Under the app the same three rows point at the app's own controls instead:
// New Session for "Start fresh", the top bar's dashboard button for "Carry
// on", and no stray command to copy into a shell that is not there.
test("under the app, Before you close this points at New Session, and never at a \"new conversation\" that does not exist there", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
env: { PLAN2CODE_IN_APP: "1" },
});
const main = s.page.locator("#main");
s.post({ finish: { headline: "A skill next", command: "/plan2code-4-finalize" } });
await main.getByRole("heading", { name: "A skill next" }).waitFor();
const guide = closeGuide(s);
const text = await textOf(guide);
assert.ok(text.includes("Press New Session at the top of the window to start the agent fresh."), "Start fresh points at New Session");
assert.ok(text.includes("Paste the command above into the terminal panel, or start from the dashboard with /plan2code."), "Carry on names the terminal panel");
assert.ok(!text.includes("new session") && !text.includes("new conversation"), "no classic-mode wording under the app");
// The extra "To start something else..." paragraph a classic finish also
// shows is left out here: the row above already says it once.
assert.equal(await main.getByText("To start something else, run").count(), 0, "no second mention of the same command");
// Nothing left to run: the all-done shape still offers the command (the
// app's terminal panel is a real terminal the agent runs in, so pasting it
// there works), worded for the one panel rather than a new conversation.
s.post({ finish: { headline: "AGENTS.md is updated" } });
await main.getByText(/paste .* into the terminal panel below/).waitFor();
assert.ok(await main.locator("code").filter({ hasText: /^\/plan2code --web$/ }).count(), "the command is still offered");
// The live dashboard button's own note, under it, also points at New
// Session instead of typing `/clear` by hand.
s.post({ finish: { headline: "A skill next, with a live dashboard offer", command: "/plan2code-4-finalize", dashboard: true } });
await main.getByRole("button", { name: "Back to the dashboard" }).waitFor();
assert.ok(await main.getByText("press New Session at the top of the window for a clean start instead").count(), "the dashboard note points at New Session");
assert.equal(await main.getByText("type `/clear`", { exact: false }).count(), 0, "no hand-typed /clear under the app");
});
// Once the console server itself is gone (not just finished), the review and
// dashboard offers' own "new conversation" fallback text must say the same:
// paste into the terminal panel, under the app, and never claim a command is
// needed to reconnect, since the app's own bar already does that on its own.
test("under the app, a gone session's review and dashboard fallbacks name the terminal panel, and reconnect needs no command", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "quick-task",
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
env: { PLAN2CODE_IN_APP: "1" },
clock: true,
});
s.post({ finish: OFFERS });
await s.page.locator("#main").getByRole("heading", { name: "Quick task done" }).waitFor();
await s.page.locator("#main").getByRole("button", { name: "Review it now" }).click();
collect(s);
await stopServer(s);
for (let i = 0; i < 20 && !(await s.page.locator("#planny.is-gone").count()); i++) {
await s.page.clock.fastForward(GONE_AFTER_MS);
await new Promise((r) => setTimeout(r, 250));
}
const main = s.page.locator("#main");
await main.getByText(/paste this into the terminal panel/i).first().waitFor();
assert.equal(await main.getByText(/new conversation/i).count(), 0, "no classic-mode wording under the app");
await main.getByText("Plan2Code will try to reconnect the console on its own; if it cannot, the app's bar offers Reconnect the console.").waitFor();
assert.equal(await main.getByText(/run this in a new conversation/i).count(), 0, "no stray reconnect command under the app");
});
// What a person sees break: the triangle leaving answers behind, or sending a
// finish-style stop instead of the way home.
test("the top bar's back triangle asks first, then sends __dashboard with the typed answers and the home reply", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
await s.page.click("#btn-home");
const modal = s.page.locator("#home-modal");
await modal.waitFor();
assert.match(await textOf(modal), /Leave this workflow\?/);
assert.match(await textOf(modal.locator("#home-blurb")), /The answer you have ready goes with it\./);
await modal.locator("#home-cancel").click();
await modal.waitFor({ state: "hidden" });
assert.equal(s.wait(1).code === 0, false, "Cancel sent something");
await s.page.click("#btn-home");
await modal.locator("#home-go").click();
const got = collect(s);
assert.deepEqual(got.actions.map(({ i, type }) => ({ i, type })), [{ i: "q1", type: "answer" }, { i: "__dashboard", type: "dashboard" }]);
assert.ok(got.reply.includes("audit-export") && got.reply.endsWith(HOME_REPLY), `the reply carries the answer, then the home line: ${got.reply}`);
await s.page.waitForFunction(() => document.getElementById("btn-home").disabled);
});
// What a person sees break: Commit it now, or Changelog's commit offer, hops
// into Git without the dashboard, and the board opens over the last skill's
// staged answer, its selected question and its open tab.
test("a hop into Git from another skill starts the page clean: nothing staged, nothing selected, the questions view", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "changelog",
payload: {
items: [{ id: "q1", kind: "choice", title: "Which version", body: "The next version number.",
options: [{ k: "A", text: "A patch release" }, { k: "B", text: "A minor release" }] }],
docs: [{ id: "notes", title: "Release notes", blocks: [{ id: "b1", md: "## Draft\n\nTwo fixes." }] }],
agent: { status: "waiting" },
},
});
// The page's own state, from the module app.js loaded (same URL, same instance).
const local = () =>
s.page.evaluate(async () => {
const { page } = await import("/state.js");
return { workflow: page.S.workflow, staged: page.local.staged, selected: page.selected, view: page.view };
});
await itemCard(s.page, "q1").getByText("A minor release").click();
await s.page.locator(".view-tab", { hasText: "Release notes" }).click();
const before = await local();
assert.deepEqual(Object.keys(before.staged), ["q1"], "the answer was never staged");
assert.equal(before.selected, "q1");
assert.notEqual(before.view, "questions", "the Release notes tab never opened");
const draftFile = path.join(s.session, "draft.json");
assert.ok(await until(() => fs.existsSync(draftFile) && fs.readFileSync(draftFile, "utf8").includes('"q1"'), 5000), "the staged answer never reached the draft");
// What Commit it now and Changelog's commit offer run.
cli(["open", "--resume", s.sid, "--no-open", "--workflow", "git"], { cwd: s.project });
await s.page.waitForFunction(async () => (await import("/state.js")).page.S.workflow === "git", null, { timeout: 10000 });
// Long enough for the page's draft push (600 ms after a save) to have run.
await new Promise((r) => setTimeout(r, 1500));
const after = await local();
assert.deepEqual(after.staged, {}, `the page kept the last skill's staged answer: ${JSON.stringify(after.staged)}`);
assert.equal(after.selected, null, `the page kept the last skill's selection: ${after.selected}`);
assert.equal(after.view, "questions", `the page kept the last skill's tab: ${after.view}`);
const stored = await s.page.evaluate((key) => JSON.parse(localStorage.getItem(key) || "{}").staged || {}, `p2c-console:${s.sid}`);
assert.deepEqual(stored, {}, "the browser's copy kept the staged answer");
const draft = fs.existsSync(draftFile) ? JSON.parse(fs.readFileSync(draftFile, "utf8")) : {};
assert.deepEqual(draft.staged || {}, {}, "the server's draft kept the staged answer");
});
// What a person sees break: Back to default in Preferences does nothing.
test("Back to default in Preferences returns the theme to follow the system and clears the chosen look", async (t) => {
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
await s.page.click("#btn-looks");
await s.page.locator('input[name="looks-theme"][value="dark"]').check();
await s.page.waitForFunction(() => document.documentElement.getAttribute("data-theme") === "dark");
await s.page.click("#looks-reset");
await s.page.waitForFunction(() => !document.documentElement.hasAttribute("data-theme"));
assert.equal(await s.page.locator('input[name="looks-theme"][value="system"]').isChecked(), true, "the system choice is ticked again");
});
// Planny's own spoken line said "close this tab": under the app there is no
// tab, only the one window.
test("under the app, Planny's finished line says to close the window, not the tab", async (t) => {
const s = await openSession(await suite.browser(), {
t,
workflow: "implement",
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
env: { PLAN2CODE_IN_APP: "1" },
});
s.post({ finish: { headline: "All done", dashboard: true } });
await s.page.locator("#main").getByRole("heading", { name: "All done" }).waitFor();
const line = await lineSays(s, /close this window/);
assert.doesNotMatch(line, /close this tab/, "no classic-mode wording under the app");
});