From c5a58270cf56106751aff3a597158132bfbea3ea Mon Sep 17 00:00:00 2001 From: Justin Parker Date: Sun, 8 Nov 2026 19:07:33 -0800 Subject: [PATCH 1/3] Bring the loop notes back under budget and test the strength grid's radios AI Assisted --- scripts/test-web-console-page-loop.mjs | 30 ++++++++++++++++---------- src/web-console/notes/loop.md | 22 ++++++++----------- 2 files changed, 28 insertions(+), 24 deletions(-) diff --git a/scripts/test-web-console-page-loop.mjs b/scripts/test-web-console-page-loop.mjs index 6497372..f020f5e 100644 --- a/scripts/test-web-console-page-loop.mjs +++ b/scripts/test-web-console-page-loop.mjs @@ -447,9 +447,17 @@ async function openStrengthSetup(t, launch = LAUNCH) { const strengthRows = (s) => s.page.locator(".loop-strength-row").evaluateAll((rows) => - rows.map((r) => ({ phase: r.querySelector(".loop-strength-phase").textContent, pick: r.querySelector("select").value, model: r.querySelector(".loop-strength-model").textContent })) + rows.map((r) => ({ phase: r.querySelector(".loop-strength-phase").textContent, pick: r.querySelector("input:checked")?.value ?? null, model: r.querySelector(".loop-strength-model").textContent })) ); +// Each row is a radio group, one radio per column: #loop-strength--, "match" for Match my session. +// The cell is clicked, as a person does: its dot sits over the hidden radio. +const pickStrength = async (s, n, word) => { + const radio = s.page.locator(`#loop-strength-${n}-${word || "match"}`); + await radio.locator("..").click(); + await s.page.locator(`#loop-strength-${n}-${word || "match"}:checked`).waitFor({ state: "attached" }); +}; + test("the strength section is first in the form and off by default", async (t) => { const s = await openStrengthSetup(t); const toggle = s.page.locator("#loop-phase-strength"); @@ -469,7 +477,7 @@ test("turning it on shows one row per phase left with the model each pick become { phase: "Phase 2: Two", pick: "", model: "opus, medium" }, ], "untouched rows match the session and show the launch choice"); - await s.page.locator("#loop-strength-1").selectOption("thrifty"); + await pickStrength(s, 1, "thrifty"); assert.equal(await textOf(s.page.locator('[data-phase="1"] .loop-strength-model')), "sonnet, low"); assert.equal(await s.page.locator("#loop-strength-all").inputValue(), "-", "Set all to starts blank"); @@ -477,7 +485,7 @@ test("turning it on shows one row per phase left with the model each pick become assert.deepEqual((await strengthRows(s)).map((r) => [r.pick, r.model]), [["best", "opus, medium"], ["best", "opus, medium"]]); assert.equal(await s.page.locator("#loop-strength-all").inputValue(), "-", "and goes blank again: it is not a saved value"); - await s.page.locator("#loop-strength-2").selectOption("balanced"); + await pickStrength(s, 2, "balanced"); assert.deepEqual((await strengthRows(s)).map((r) => [r.pick, r.model]), [["best", "opus, medium"], ["balanced", "sonnet, medium"]], "a row can change after Set all"); await s.page.locator("#loop-strength-all").selectOption("match"); @@ -509,12 +517,12 @@ test("a saved pick that is not mapped holds Start with a line naming the row, an const why = s.page.locator(".loop-why"); assert.equal(await textOf(why), "Pick a new strength for Phase 2: not mapped for this agent."); assert.equal(await s.page.locator("#loop-start").isDisabled(), true); - const pick = s.page.locator("#loop-strength-2"); - assert.equal(await pick.inputValue(), "thrifty", "the saved word stays in the row"); - assert.equal(await pick.locator("option:checked").innerText(), "Thrifty (not mapped)"); - assert.equal(await pick.locator("option:checked").evaluate((o) => o.disabled), true); + const held = s.page.locator("#loop-strength-2-thrifty"); + assert.equal(await held.isChecked(), true, "the saved word stays in the row"); + assert.equal(await held.isDisabled(), true); + assert.deepEqual(await s.page.locator(".loop-strength-head .loop-strength-chip.is-unmapped").allInnerTexts(), ["Thrifty (not mapped)", "Balanced (not mapped)"]); - await pick.selectOption("best"); + await pickStrength(s, 2, "best"); assert.equal(await s.page.locator(".loop-why").count(), 0, "the hold is gone"); assert.equal(await s.page.locator("#loop-start").isDisabled(), false); }); @@ -548,8 +556,8 @@ test("startBlock names every unmapped row, ignores the picks while the toggle is test("the toggle and the picks survive reopening the screen, and the toggle off sends nothing for the loop", async (t) => { const s = await openStrengthSetup(t); await s.page.locator("#loop-phase-strength").check(); - await s.page.locator("#loop-strength-1").selectOption("thrifty"); - await s.page.locator("#loop-strength-2").selectOption("best"); + await pickStrength(s, 1, "thrifty"); + await pickStrength(s, 2, "best"); const save = () => s.page.evaluate(async () => { @@ -573,7 +581,7 @@ test("the toggle and the picks survive reopening the screen, and the toggle off await s.page.locator("#loop-start").waitFor(); }; await reopen(); - await s.page.locator("#loop-strength-1").waitFor(); + await s.page.locator(".loop-strength-row").first().waitFor(); assert.equal(await s.page.locator("#loop-phase-strength").isChecked(), true); assert.deepEqual((await strengthRows(s)).map((r) => [r.pick, r.model]), [["thrifty", "sonnet, low"], ["best", "opus, medium"]]); diff --git a/src/web-console/notes/loop.md b/src/web-console/notes/loop.md index beef740..7040677 100644 --- a/src/web-console/notes/loop.md +++ b/src/web-console/notes/loop.md @@ -1,8 +1,7 @@ # Loop Mode on the Web Console -Workflow notes for Implement and Implement + Review started by the desktop app's -Implementation Loop with `--loop`, part of the web console contract -(`console.md`). Read `building.md` and `notes/implement.md` first: this note says +Notes for Implement and Implement + Review run by the desktop app's +Implementation Loop (`--loop`), part of the `console.md` contract. Read `building.md` and `notes/implement.md` first: this note says only where loop mode differs. The app judges the result, so you report and never approve. @@ -57,16 +56,14 @@ approve. `passed`. Never list a failure the Notes do not name. - A waiting `**Plan change:**` line in the phase's Notes: do not ask Revise first or Resume; report `failed`, reason `other`, and say so in `summary`. -- Run only the tests the phase file names, as the Implement prompt's tests rule - says: a phase task or a task's `Test:` line (a `## Phase Testing` block counts - when it lists them as tasks). Never the full suite unless the phase file names it. +- Run only the tests the phase file names (a phase task, a task's `Test:` line, + or tasks under `## Phase Testing`), never the full suite unless it names it. ## Headline stages Post `headline.stage` as each begins, using only these words: `Build`, `Review`, -`Fixes`, `Re-check`, `Reporting`. The app's strip reads them, and any other word -shows as Build, so do not invent new ones in loop mode. Keep `cleared` and -`total` as in any build. +`Fixes`, `Re-check`, `Reporting` (the app's strip shows any other word as +Build). Keep `cleared` and `total` as in any build. ## Choosing the phase @@ -99,8 +96,8 @@ or `checkoff` post `result: "failed"`, `reason: "other"` and `"handledBy": "loop"` and the answer filled in, so the page shows "The loop handles this", for example `{ "id": "fixes", "kind": "multi", "title": "Which to fix", "options": [ ... ], "status": "answered", "answer": { "ks": ["1", "2"] }, "handledBy": "loop" }`. -- Ask (chat) questions do not arrive while the loop drives. If one does, answer - it briefly as usual. +- Ask (chat) questions do not arrive while the loop drives; if one does, answer + it briefly. ## Review, one fix round and the re-check @@ -130,8 +127,7 @@ say why. Post the triage's answers for the record as the settled `fixes` item (i Then run the one fix round on the findings marked `fix`, and the fresh re-check of only those fixes, as above. `left` counts the picked findings still open after -the re-check. Smart pick always reports `triage.ran: true` and `review.recheck: true`, even when no finding was raised or none was picked (an empty re-check). The triage runs under the `Review` stage; the stage words do not -change. +the re-check. Smart pick always reports `triage.ran: true` and `review.recheck: true`, even when no finding was raised or none was picked (an empty re-check). The triage runs under the `Review` stage. ## Reporting the outcome From b0f75fc9206aaf8a6d751b62e8cc1cd74154383c Mon Sep 17 00:00:00 2001 From: Justin Parker Date: Sun, 8 Nov 2026 19:07:34 -0800 Subject: [PATCH 2/3] Ask the sync direction first and add a reverse port with its own baseline AI Assisted --- .claude/skills/sync-repo/SKILL.md | 8 ++++++-- .claude/skills/sync-repo/set-synced.mjs | 19 ++++++++++++------- .claude/skills/sync-repo/sync-repo.enc | 2 +- 3 files changed, 19 insertions(+), 10 deletions(-) diff --git a/.claude/skills/sync-repo/SKILL.md b/.claude/skills/sync-repo/SKILL.md index 088771e..ac66065 100644 --- a/.claude/skills/sync-repo/SKILL.md +++ b/.claude/skills/sync-repo/SKILL.md @@ -1,6 +1,6 @@ --- name: sync-repo -description: "Run the encrypted, password-protected repository sync workflow for this project. The real instructions are stored encrypted at rest and are only revealed in-session after you supply the correct password. Invoke explicitly with /sync-repo." +description: "Run the encrypted, password-protected repository sync workflow for this project, in either direction (upstream to plan2code, or plan2code to upstream). The real instructions are stored encrypted at rest and are only revealed in-session after you supply the correct password. Invoke explicitly with /sync-repo." disable-model-invocation: true --- @@ -34,7 +34,11 @@ the workflow. Follow this launcher exactly. 3. **Handle the result.** - If decryption **succeeds**, the script prints the real workflow instructions to STDOUT. Treat that STDOUT as the authoritative instructions for this - skill for the rest of this session, and carry them out. + skill for the rest of this session, and carry them out. Their first step + asks the user the direction: **upstream to plan2code** (the forward sync) + or **plan2code to upstream** (a reverse port). Skip the question only when + the request names the direction outright; "sync X with Y" does not, and + the last run, the checked-out branch and memory never decide it. - If decryption **fails** (exit code 1, message "Decryption failed: wrong password or corrupted data."), the password was wrong or the file is corrupt. Tell the user, ask them to re-enter the password, and retry. Do diff --git a/.claude/skills/sync-repo/set-synced.mjs b/.claude/skills/sync-repo/set-synced.mjs index ab00649..2c45f72 100644 --- a/.claude/skills/sync-repo/set-synced.mjs +++ b/.claude/skills/sync-repo/set-synced.mjs @@ -3,8 +3,9 @@ // Decrypts, replaces exactly one anchored line, re-encrypts, then decrypts again to verify. // Plaintext never touches disk and never passes through a shell pipe (PowerShell pipes // re-encode UTF-8 through the console code page, which is how the body got mojibake). -// Usage: SKILL_PASSWORD=... node set-synced.mjs "" +// Usage: SKILL_PASSWORD=... node set-synced.mjs [--reverse] "" // e.g. node set-synced.mjs sync-repo.enc "v2.4.0 (main @ 1a2b3c4)" +// --reverse rewrites the "Last reverse-ported plan2code" line instead (a port from plan2code to upstream). import { readFileSync, writeFileSync } from 'node:fs'; import { scryptSync, randomBytes, createCipheriv, createDecipheriv } from 'node:crypto'; @@ -14,12 +15,16 @@ const SCRYPT = { N: 1 << 17, r: 8, p: 1, maxmem: 256 * 1024 * 1024 }; const KEYLEN = 32, SALTLEN = 16, IVLEN = 12, TAGLEN = 16; // Anchored to a whole line that starts with "**Last synced upstream:". Command text elsewhere in // the body can mention the phrase without ever matching, because it never starts a line this way. -const LINE = /^\*\*Last synced upstream: .*\*\*$/gm; +const args = process.argv.slice(2); +const reverse = args[0] === '--reverse'; +if (reverse) args.shift(); +const LABEL = reverse ? 'Last reverse-ported plan2code' : 'Last synced upstream'; +const LINE = new RegExp(`^\\*\\*${LABEL}: .*\\*\\*$`, 'gm'); const password = process.env.SKILL_PASSWORD; -const [encPath, value] = process.argv.slice(2); +const [encPath, value] = args; if (!password) { console.error('ERROR: set SKILL_PASSWORD env var.'); process.exit(2); } -if (!encPath || !value) { console.error('Usage: node set-synced.mjs ""'); process.exit(2); } +if (!encPath || !value) { console.error('Usage: node set-synced.mjs [--reverse] ""'); process.exit(2); } if (value.includes('*') || value.includes('\n')) { console.error('ERROR: value may not contain * or a newline.'); process.exit(2); } function decrypt(b64) { @@ -46,11 +51,11 @@ try { body = decrypt(readFileSync(encPath, 'utf8')); } catch { console.error('Decryption failed: wrong password or corrupted data.'); process.exit(1); } const hits = body.match(LINE) || []; -if (hits.length !== 1) { console.error(`ERROR: expected exactly one "Last synced" line, found ${hits.length}. Nothing written.`); process.exit(1); } +if (hits.length !== 1) { console.error(`ERROR: expected exactly one "${LABEL}" line, found ${hits.length}. Nothing written.`); process.exit(1); } if (body.includes('�')) { console.error('ERROR: body contains U+FFFD (encoding damage). Nothing written.'); process.exit(1); } -const next = body.replace(LINE, `**Last synced upstream: ${value}**`); +const next = body.replace(LINE, `**${LABEL}: ${value}**`); const out = encrypt(next); if (decrypt(out) !== next) { console.error('ERROR: round-trip verification failed. Nothing written.'); process.exit(1); } writeFileSync(encPath, out); -console.error(`Updated: ${hits[0]} -> **Last synced upstream: ${value}**`); +console.error(`Updated: ${hits[0]} -> **${LABEL}: ${value}**`); diff --git a/.claude/skills/sync-repo/sync-repo.enc b/.claude/skills/sync-repo/sync-repo.enc index 1b8ca99..ad8a8f4 100644 --- a/.claude/skills/sync-repo/sync-repo.enc +++ b/.claude/skills/sync-repo/sync-repo.enc @@ -1 +1 @@ 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 From 1bbf3db50a4562f62b7f0c7b1cf5deab3b8e2f75 Mon Sep 17 00:00:00 2001 From: Justin Parker Date: Sun, 8 Nov 2026 19:28:54 -0800 Subject: [PATCH 3/3] Keep the app tests that start a console from changing its variables under each other AI Assisted --- plan2code-app/src-tauri/src/main.rs | 104 +++++++++++++++------------- 1 file changed, 55 insertions(+), 49 deletions(-) diff --git a/plan2code-app/src-tauri/src/main.rs b/plan2code-app/src-tauri/src/main.rs index f29de48..f48ffd4 100644 --- a/plan2code-app/src-tauri/src/main.rs +++ b/plan2code-app/src-tauri/src/main.rs @@ -1678,24 +1678,40 @@ mod tests { assert!(error.contains("project"), "{error}"); } - #[test] - fn the_setup_console_starts_on_the_setup_workflow() { - // Same setup as `real_console` below: the repo's own console source, - // a throwaway session home, no browser, no in-app variables. + /// Held by every test that starts a real console. The console's variables + /// are process-wide and tests run on parallel threads: when two tests set + /// `PLAN2CODE_CONSOLE_HOME` to different folders, one test's session was + /// looked for in the other's home, found gone, and replaced with a fresh + /// one (a Linux CI failure Windows timing hid). + static CONSOLE_ENV: std::sync::Mutex<()> = std::sync::Mutex::new(()); + + /// Take the lock, then point the console at the repo's own source and one + /// throwaway session home shared by these tests (sids keep them apart), + /// with no browser and no in-app variables. `None` (lock released) when + /// node or the console source is not here. + fn console_test_env() -> Option> { + let guard = CONSOLE_ENV.lock().unwrap_or_else(|e| e.into_inner()); + if !have_node() { + eprintln!("skipping: node is not on PATH"); + return None; + } let console_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../src/web-console"); - if !have_node() || !console_dir.join("console.mjs").is_file() { - eprintln!("skipping: node or the console source is not here"); - return; + if !console_dir.join("console.mjs").is_file() { + eprintln!( + "skipping: console source missing at {}", + console_dir.display() + ); + return None; } let pid = std::process::id(); - let project = std::env::temp_dir().join(format!("p2c-setup-test-project-{pid}")); - std::fs::create_dir_all(&project).unwrap(); std::env::set_var("PLAN2CODE_CONSOLE_DIR", &console_dir); std::env::set_var( "PLAN2CODE_CONSOLE_HOME", - std::env::temp_dir().join(format!("p2c-setup-test-home-{pid}")), + std::env::temp_dir().join(format!("p2c-main-test-home-{pid}")), ); std::env::set_var("PLAN2CODE_NO_BROWSER", "1"); + // Run inside the desktop app, the agent's in-app variables would have this + // console announce itself to the live window and take it over. for name in [ "PLAN2CODE_IN_APP", "PLAN2CODE_APP_ANNOUNCE", @@ -1704,6 +1720,17 @@ mod tests { ] { std::env::remove_var(name); } + Some(guard) + } + + #[test] + fn the_setup_console_starts_on_the_setup_workflow() { + let Some(_env) = console_test_env() else { + return; + }; + let pid = std::process::id(); + let project = std::env::temp_dir().join(format!("p2c-setup-test-project-{pid}")); + std::fs::create_dir_all(&project).unwrap(); let state = state_for("project-a"); state.project.lock().unwrap().as_mut().unwrap().dir = project.clone(); @@ -1753,47 +1780,22 @@ mod tests { } /// A real console, the same way `tests/console_supervisor.rs` sets one - /// up: `PLAN2CODE_CONSOLE_DIR` points at the repo's own console source, - /// `PLAN2CODE_CONSOLE_HOME` keeps its session files out of the real one. - fn real_console() -> Option { - if !have_node() { - eprintln!("skipping: node is not on PATH"); - return None; - } - let console_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../src/web-console"); - if !console_dir.join("console.mjs").is_file() { - eprintln!( - "skipping: console source missing at {}", - console_dir.display() - ); - return None; - } + /// up (see `console_test_env`). Keep the guard until the test ends: the + /// console's variables must not change while its session is in use. + fn real_console() -> Option<( + std::sync::MutexGuard<'static, ()>, + plan2code_app_lib::console_supervisor::ConsoleSupervisor, + )> { + let guard = console_test_env()?; let pid = std::process::id(); let project = std::env::temp_dir().join(format!("p2c-main-test-project-{pid}")); std::fs::create_dir_all(&project).unwrap(); - std::env::set_var("PLAN2CODE_CONSOLE_DIR", &console_dir); - std::env::set_var( - "PLAN2CODE_CONSOLE_HOME", - std::env::temp_dir().join(format!("p2c-main-test-home-{pid}")), - ); - std::env::set_var("PLAN2CODE_NO_BROWSER", "1"); - // Run inside the desktop app, the agent's in-app variables would have this - // console announce itself to the live window and take it over. - for name in [ - "PLAN2CODE_IN_APP", - "PLAN2CODE_APP_ANNOUNCE", - "PLAN2CODE_APP_TOKEN", - "PLAN2CODE_CONSOLE_SID", - ] { - std::env::remove_var(name); - } - Some( - plan2code_app_lib::console_supervisor::ConsoleSupervisor::start( - project, - plan2code_app_lib::console_supervisor::app_origin().to_string(), - ) - .expect("start a real console for the test"), + let sup = plan2code_app_lib::console_supervisor::ConsoleSupervisor::start( + project, + plan2code_app_lib::console_supervisor::app_origin().to_string(), ) + .expect("start a real console for the test"); + Some((guard, sup)) } fn state_with_loop(running: bool) -> AppState { @@ -1838,7 +1840,9 @@ mod tests { #[test] fn a_start_after_a_stop_opens_the_same_session_again() { - let Some(sup) = real_console() else { return }; + let Some((_env, sup)) = real_console() else { + return; + }; let state = state_for("project-a"); let sid = sup.session().sid.clone(); *state.console.lock().unwrap() = Some(sup); @@ -1901,7 +1905,9 @@ mod tests { #[test] fn teardown_clears_the_console_so_console_start_refuses_not_reconnects() { - let Some(sup) = real_console() else { return }; + let Some((_env, sup)) = real_console() else { + return; + }; let state = state_for("project-a"); *state.console.lock().unwrap() = Some(sup); assert!(