main
111
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
bb056c511d |
fix(core): a venv made with --symlinks is its own environment
Its python.exe links to the Python it was made from, and env_hash followed the link, so the venv's pins, snapshots and cached graph, report and audit were filed under its base. Nothing showed it while no screen could list the two apart; Add interpreter now can. A venv's own interpreter, recognised by its pyvenv.cfg, is resolved only up to its folder. No other path's identity changes, and a linked venv's earlier pins and snapshots stay with the base they were filed under. Checked against a real --symlinks venv: `env use` stores the venv with its own prefix, and the venv and its base keep two identities. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
2539950cd5 |
fix: what an independent review of 1.6.0 found
A venv made with --symlinks is run and stored as itself, not as the base Python its python.exe links to: validate_interpreter returned the canonical path, so `--env .venv update --all --yes` would have changed the system Python. Canonicalizing now only decides where a link leads and whether it is PipDock's own; a link to another program is refused, and a Microsoft Store alias (os error 1920) is judged by its own path. The GUI merges and removes an added row by its path rather than by envHash, which follows links: a re-add replaces a broken row, removal sticks for an entry whose file is gone (a share), and neither runs during a scan. Added entries are validated again on every listing in both heads (envs::probe_listed), and the CLI checks its stored default when it uses it. `env remove` makes a typed path absolute first. SECURITY section 2 and env_probe's doc claimed an enforcement point over IPC; they now say what is checked, and backlog X36-b records the rest. notify.yml reports a Triage failure on a pull request. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
c9128e479e |
feat(ui): Add interpreter… and Remove from list on Environments
The header and the empty state offer Add interpreter…, which asks for a python.exe and selects what it added; an added row, broken or not, offers Remove from list. Busy is aria-disabled with a click guard, an add and a scan refuse to overlap, the result is said in a status region mounted before its words, and focus goes to the heading when the row holding it leaves. Ctrl+K has the add too. PD-ENV-001's copy now covers a file PipDock will not run, in both catalogues. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
ccae96dbeb |
chore: move to poli0981org — self-contained CI, Qodana, an npm licence gate, this week's dependencies (#119)
The repository now lives in the poli0981org organization, and this makes it at home there. - main was red since 2026-11-18: RUSTSEC-2026-0543 (chrono), in Cargo.lock only through serde_with's weak features and compiled into nothing; ignored with its reason and exit condition. - Supersedes #113–#118 (Rust 1.100.0, rusqlite 0.42.0, Tauri 2.12.6, code-health pins, actions, npm) plus jsdom 31.0.1; minimatch 11 closes GHSA-g3hv-75wg-m249. rfd 0.18 (#112) is held again until tauri-plugin-dialog moves. - Dependabot's tauri groups never worked (it picks the most specific group); exclude-patterns on the catch-alls fix it. - CI is self-contained: no workflow calls poli0981/.github; every action is pinned by commit; notify.yml vendors the Discord notifier. - npm licences: scripts/check-licenses.mjs, deny.toml's allowlist for the npm half. Required, with cargo deny and tauri lockstep — eight required checks. - Qodana in two parts (Rust, TS/JS), full scans, a triaged Rust baseline, fail on anything new. The Rust container needed its toolchain and CARGO_HOME pointed somewhere writable before it analysed anything. - SonarQube Cloud analyses into poli0981org_pipdock; every npm ci runs with --ignore-scripts (S6505). - Every repository URL points at the organization. README's attestation command for 1.4.0/1.5.0 had stopped working; it now says --owner poli0981 --signer-repo poli0981/pipdock. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
90fdfb3a2a |
test(a11y): hold the click guards that replaced disabled
A `disabled` button cannot be clicked; an `aria-disabled` one can. So every button that became aria-disabled while busy depends on a guard in its handler, and a guard that is missing starts a second scan, run or audit over the first. SonarQube's gate saw those branches uncovered (78.7% on new code). busy.test.tsx drives each one both ways: Use and Rescan, Code Health's Run, Security's Run audit, the plan panel's Stop, and the two requirements buttons, where the second press must not open a second picker. It also holds the other half of the rule: a control with nothing to act on is still `disabled`. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
7ee00893a7 |
fix(a11y): four defects from an independent review of the diff
- Visually-hidden text is position: absolute, and with no positioned ancestor it is laid out against the viewport, outside every scroller above it. A pin chip's hidden sentence did that on Pins: a long list made the whole window scroll and took the header with it. Every parent of hidden text is relative. - A run that failed before producing a summary rendered no <h1>, so the focus rule had nothing to land on. The branch has a heading. - The console drawer stays open across runs, so the next run mounts it with no opener to return focus to. It falls back to the Console button. - Under forced-colors the selection outline followed the focus ring at equal specificity and replaced it on a focused current tab. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
5aa4da87f4 |
fix(a11y): five defects found by driving the installed build
Every one of these was in code whose tests were green. They were found by installing the bundle, opening WebView2's debugging port, and pressing real keys while reading document.activeElement and the accessibility tree. - The high-contrast border on destructive buttons had never been drawn. The rule sat in @layer base; every button carries Tailwind's border utility, a later layer wins whatever the selectors say, and border: 2px lost to border-width: 1px. It is outside every layer, and a double border, because 2px beside 1px is not a difference anyone sees. - Accepting the legal gate left focus on nothing: the gate is rendered instead of the shell, so the screen was replaced with the tab unchanged. - A button that disabled itself when pressed dropped focus to <body>, because a browser takes focus from a control that becomes disabled and jsdom does not. Use, Rescan, Run, Run audit, Add, Download the index, Stop and the two requirements buttons are aria-disabled while busy and ignore a second press. - A dialog's name read "Remove packages : certifi": a browser puts a space before visually-hidden text. The second half of the name is an aria-label. - The Updates tab's name read "Updates(5)". Zoom hotkeys were tried and are not in this commit: at 200% in the default window the package-name column collapsed to zero width. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
4732f05197 |
docs: sync the specs with the accessibility pass
UI-SPEC §7 no longer describes a forced-colors list that is "not complete": the mark is data-destructive. §8 gains the five rules the pass left behind — focus on every screen replacement, names that contain the visible text, composite widgets as one tab stop, chip meanings as text, status regions that exist before their first message. TESTING says which of the three new tests holds what, and that none of them knows what a screen reader says; the manual charter gains a ten-minute accessibility pass. CLI-SPEC writes down that the CLI has no colour and nothing that animates, which was true of the code and stated nowhere. RELEASE-CI: the conversation-resolution rule the protection table never listed, the labels box that had been true for weeks, and .nvmrc, which still said 24 a month after every workflow moved to 26. README links the new files and gains Accessibility and Contributing sections. AI-DISCLOSURE and About name the model that produced 1.5.0. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
d016b80014 |
fix(a11y): name dialogs by their heading, and four smaller things
A PdDialog's name was an aria-label holding what it was about, so a screen reader announced "numpy, dialog" and then "Cancel": the question being asked was on screen and never spoken. It is named by its visible heading, followed by what it is about, and described by its body. The legal gate replaces the whole shell, declares itself modal, and had no focus inside it. Its heading takes focus on arrival, as a screen's does. A package row's focus ring was drawn 2px outside a row that is absolutely positioned in a scroller and stacked against its neighbours, so three sides of it were clipped or painted over. It sits inside the row, in every mode rather than only in forced-colors. The dock bay's remove button was a bare glyph about 8px wide. It is 24px each way. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
885bca416c |
feat(about): the accessibility statement and where to report a barrier
Someone who cannot use part of the app is the person least able to go looking for a repository file about it. About gains an Accessibility section: a button that opens ACCESSIBILITY.md, and accessibility@poli0981.dev beside the two addresses already there, copyable the same way. No capability is widened: https://github.com/* was already in scope. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
a5fc204de8 |
fix(a11y): mark destructive controls by attribute for high contrast (U45)
Forced-colors drops every tint, so a danger-treated primary is drawn exactly like the Cancel beside it. The stylesheet gave five data-action values a border and had missed Remove, Allow, Clear, the Force-latest confirm and a forced plan's Confirm for as long as the list existed. The mark is one attribute, data-destructive, and destructive.test.ts reads the source to hold both halves: every button drawn in the danger colour carries it, and the stylesheet draws it. The active sidebar tab carries aria-current="page" and the outline rule matched 'true', so high contrast drew it like every other tab. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
f1bab20306 |
fix(a11y): say what Search is doing, and expose the tab shortcuts
Search told a screen reader nothing between a keystroke and its answer: the index loading, a search running, how many results came back and "nothing matches" were plain spans or not text at all. One status region carries them, mounted from the first render so there is an earlier state for a message to differ from. The result whose details are showing was a background colour; it carries aria-current. The sidebar's ^1..^9 hints were aria-hidden and at half opacity: about 2.6:1, and the shortcut existed nowhere else. They are drawn in a token, and each tab carries aria-keyshortcuts. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
6b70580b91 |
fix(a11y): finish the tab, radio group and listbox patterns (U47, U48)
Health's tabs were three buttons with role="tab": three tab stops, no arrow keys, no panel. They are one stop with Left/Right/Home/End, tied to a tabpanel. Their accessible name was an aria-label reading "Dependencies, 3 findings" over a tab that says "deptry 3", which fails WCAG 2.5.3; the name is the visible text now, followed by what the tab is about. A conflict's three choices were role="radio" with none of a radio group's keyboard. They are one stop, and the arrows move between them. The arrows move focus and choose nothing: checking what focus lands on would open Force latest's destructive confirm from an arrow key. The palette's highlight is an aria-activedescendant, not focus, so nothing scrolled the list and the selection left the visible window. It is scrolled into view. The vulture whitelist link was told from the sentence around it by a colour 1.4:1 away and underlined only on hover. It is underlined at rest. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
567b0ae8fa |
fix(a11y): move focus when the screen is replaced, not only when the tab changes
The shell moved focus to the new screen's heading on a tab change and on nothing else. Four things replace what <main> shows without changing the tab: the plan panel and each of its phases, the dependency view, and an opened environment. Each unmounts the control that was just pressed, so focus fell to <body>, the next Tab started from the top of the window, and a screen reader said nothing about a screen that had entirely changed. A second effect covers them, and only acts when focus was actually lost: a run advancing from resolving to preview must not pull a keyboard user off Back. The console drawer had the same hole. Escape closed it and dropped focus; it goes back to whatever opened the drawer. Its close button was named "Cancel", beside a Stop that cancels the run, and is "Close console". Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
9754b95e66 |
test(a11y): run axe-core over every screen, and fix the grid it failed
No accessibility tooling stood behind any of this: roles were asserted one at a time, wherever a test happened to reach for getByRole. axe-core now runs over every screen inside the shell and over the components with structure of their own. It is called directly: eslint-plugin-jsx-a11y peers ESLint 9 at most and this repository is on 10, and the matcher packages are wrappers pinned to a runner's major. color-contrast stays off under jsdom and stays tokens.test.ts's job. Its first run failed on the package grid, which is fixed here: - the row checkbox was a direct child of role="row"; it is in a gridcell - the header had five column headers over six cells; the checkbox and action columns are named, visually hidden - the grid says rows are multi-selectable, which aria-selected needs And one axe cannot see: a pin chip's meaning lived in a title attribute on a span that cannot take focus. It is text now, visually hidden. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
2f6ad04967 |
fix: the 16 Rust findings and the coverage gap from the first CI analysis of main (#91)
The first CI analysis of main failed its gate: 16 Rust bugs and new-code coverage 78.3 % against 80 %, over all of 1.4.0 (sending a version did not move the previous-version baseline). - rust:S6677 x3: a failure's message is logged as `error`, not as a second `message` field (CLI, update flow, app startup); golden.rs reads the CLI's log to hold it, and failed first. - rust:S7493 x13: std::fs inside async fns goes through tokio::fs (tools venv sync, deptry's report, export/requirements/report commands). - Tests for 1.4.0 code nothing drove: rollback end to end, forcing a latest this Python cannot run, PEP 691 parsing (L55), user_file_error (U25), a plan verified in another environment, PyPiReleases' cache, and the plan/env stores' success and late-error paths. InstallSet::only had no caller and is removed. - ROADMAP, TESTING and CLAUDE.md record what the analysis found. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
42f227c1aa |
fix: what installing the build found, and what the doc pass turned up
The release build was installed and driven before tagging. Two defects showed up that no suite could see: - Every dialog opened in the window's top-left corner. Tailwind's preflight sets `margin: 0` on everything, which removes the `margin: auto` a modal <dialog> is centred by; PdDialog (and so the uninstall guard, since it was written) and the Ctrl+K palette were both affected. `m-auto` / `mx-auto`, measured in the dev server: (0,0) before, centred after. - On a profile that had never downloaded the index, Search said "preparing the package index" for ever and never offered the download. Moving the load into the background let a failed load restart on the next search, which reset the slot to Warming before the failure could be read, and the screen asked again every 150 ms. A failed load now stays failed until a refresh; a test in state.rs failed first against the old rule. From the documentation pass, each checked against the code: - The GUI's snapshot diff used the plain diff while the CLI's and the rollback used the engine-aware one, so the two heads disagreed about pip and setuptools across engines (G5). - `--json`'s help still promised NDJSON; `--yes`, `--quiet`, `--verbose`, `--log-file`, the install spec and `engine` described behaviour they did not have. Corrected, and the 32 help goldens re-blessed for exactly those lines. `pipdock engine` now marks the configured engine, as its help always said; `health --fix` printed a dirty-tree warning to stdout before its JSON; the text preview now lists withdrawn releases, as the GUI's does. - Copy that promised what the code does not do: a pinned package "can still be updated on its own" (an Exclude pin filters a named package too), a held pin left only "out of bulk updates", and an empty Environments screen pointing at a Browse… button that does not exist. - Stale comments in exec, the pip and uv parsers, index refresh, health, the pin screen, the status line, the settings store and i18n.ts (whose missing-key warning never fires). The ExecutionSummary.cancelled description is part of the public schema, so that golden and the TypeScript bindings move with it. - Metadata lookups reuse the shared HTTP client (M37 had been half done); insta was a dev dependency of core that nothing in core used; the integration workflow's checkouts no longer persist credentials; the capability file cites SECURITY §4, where the rule lives. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
12bf723daa |
ci: failures reach someone, audits run on what is merged, releases are attested
- notify-ci-failure.yml lists its workflows by name. `workflows: ['*']` is not a wildcard to workflow_run: it matched nothing, so `main` was red from 2026-09-23 with no one told. - cargo audit runs a prebuilt cargo-audit (taiki-e/install-action, pinned by commit) with `--deny warnings`, replacing rustsec/audit-check@v2 - Node 20, a check-run write token, and on a pull request a failure only for "critical", which is how September's advisories passed every PR. .cargo/audit.toml's contract (a new informational advisory fails CI) is now what runs. - security-scan.yml: both audits daily against `main`, so an advisory against something already merged is reported the day it is published, not at the next PR. - cargo deny (licences, sources, bans) with deny.toml: the licence allowlist makes "every bundled licence is GPL-3.0-compatible" a test. The workspace declares `publish = false`, which it never had - and without which cargo-deny judged the app crates as published ones. - CodeQL analyses rust and actions as well as javascript-typescript. The comment saying CodeQL had no Rust support stopped being true in 2025. - ci-node.yml: Pages and id-token write move from the workflow to the one job that needs them (Sonar S8233); the audit installs with --ignore-scripts (S6505); a new `tauri lockstep` job fails when a Tauri crate and its npm package drift apart on Cargo.lock and package-lock.json. - release.yml: build (read-only token, no persisted credentials) and publish (attest + draft) are separate jobs; the tag must match all five version fields; SHA256SUMS.txt is LF, which `sha256sum -c` elsewhere needs; actions/attest-build-provenance attests the .exe and .msi; softprops/action-gh-release is pinned by commit; `workflow_dispatch` with `dry_run` builds any ref without attesting or drafting. - ci-integration.yml also runs for the CLI, exec, audit, release metadata, errors, store, index, Cargo.lock and rust-toolchain.toml - every one of which its end-to-end steps run through. - dependabot.yml: cooldowns, a group per ecosystem for Tauri packages and for actions and pip, TypeScript held below 6.1 (typescript-eslint's peer range), and the rust-toolchain ecosystem. A multi-ecosystem group would put both Tauri halves in one PR, but what it does to dependencies outside its patterns is undocumented; the lockstep job covers the gap instead. - Sonar: NOSONAR with reasons on the dev scripts' argv and PATH lookups; bundle-cli.mjs no longer claims to run from beforeBuildCommand. The dev CSP moves out of index.html into a Vite plugin that reads devCsp from tauri.conf.json, so a release build carries one policy, the strict one (S7039); checked in the dev server, where React Refresh's preamble still runs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
7c6a506652 |
chore: remove what nothing uses, and finish what was half-wired
Dead code, each checked for callers first: - graph::ReverseDeps::leaves (only its own test called it), health::run::sink_for (no caller, and a doc describing something else), SnapshotProof::id and is_waived (no caller). - Two whitespace collapsers become one, errors::catalog::collapse_whitespace; the classifier's normalize is that plus lowercase. Three hand-folded SHA-256 hex digests become model::sha256_hex (build.rs keeps its own: a build script cannot use the crate it builds). - Six copies of asPdError become one, beside isPdError in ipc/errors.ts. - Thirteen strings no screen renders, from both catalogs (status.resolving/executing/ready, actions.confirm/browse/retry/openLogs, env.requiresPython/unusable, packages.updateSelectedSoon, health.notInstalled, settings.localeSystem/saved). - fixtures.rs is compiled only for tests and for xtask (feature `fixtures`), not into release. Half-wired, finished rather than deleted: engine_info had a typed wrapper and no caller, while ARCHITECTURE §7 promised a version beside each engine radio. Settings now shows it for the selected environment, and says "not found" for an engine that is not installed. Docs that described another project: core's "Phase 0" status, model.rs's specta, pip.rs's "lands in M1", snapshot.rs's "execute takes a Snapshot" (it takes a SnapshotProof), declared_source's doc stranded on validate_project, the pin validators' "character-class check" (they share pep440::is_version now), three health wrappers in ipc/index.ts each under another's doc, and three %LOCALAPPDATA% paths missing the data\ folder. Repo: production builds carry no source maps - Tauri embeds dist/ in the executable, so `sourcemap: true` shipped 2 MB of them to every user (X51). .gitignore covers insta's pending snapshots and a downloaded SHA256SUMS.txt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
4da4c0f3ec |
fix(ui): the shell - window, grants, CSP, language, keys, table, contrast
The window (U21). It may now be maximized and snapped; the 1600x1100 cap is gone, and the content column stops at max-w-content (87.5rem) instead, centred in what is left. The window is created hidden and src-tauri/src/window.rs fits it to the monitor's work area before showing it: 1180x760 is taller than the work area of a 1920x1080 panel at 150% and of a 1366x768 laptop, so the status line and the plan panel's Confirm opened under the taskbar. Never below 900x560; pinned to the corner rather than centred off-screen when even that does not fit. UI-SPEC §5 says so. The webview's grants (U1, U32). core:default granted some sixty core commands nothing called and not core:window:allow-close, so Decline on the legal gate did nothing in the installed app while its component test - which mocks close() - passed. default.json now holds exactly the five the frontend calls, and a test in lib.rs pins the union of every capability file, plus the opener's four hosts. CSP (U56): object-src, base-uri and form-action 'none'. A release build's style-src drops 'unsafe-inline' - React sets styles through CSSOM, which CSP does not govern. index.html keeps it for `npm run dev`, where Vite injects <style> elements; both policies are enforced, so the stricter decides. To be confirmed on the installed build. Language (U3): the choice is stored and applied at start. save() sent locale: null every time, so choosing Vietnamese lasted until the window closed. Settings now load before the legal gate, so the gate is in the chosen language too, and <html lang> follows the UI. Keys: a screen's data-autofocus wins over the heading (U12) - Search's field lost focus to the shell's effect, which runs after its children's - and `/` works from Search itself. Ctrl+1..9 by e.code (U49): on AZERTY Ctrl+3 reports `"`. A release build swallows F5, Ctrl+R, Ctrl+P, Ctrl+F, F3 and Alt+arrows (U20), which reloaded, printed and found in a single-page app. Also: Security scrolls (U2); the legal gate shows a consent that cannot be recorded (U29); Report bug asks for the link again with the environment, so the issue carries the Python and engine versions, at one subprocess per click rather than per row (U31); the package table's header and rows share one set of widths and one gutter, and narrow tables drop Size so names stay visible at 900px (U22, U23); the grid is focusable (Sonar S6852); --color-danger is #F26A63 and danger badges use a 15% tint, with tokens.test.ts now compositing every badge tint over every surface (U46 - 3.92:1 before); test seeds typecheck instead of `as never`, the IPC mock uses the real isPdError and has the audit cache entry (U10). U14 and U26 were already fixed by earlier commits in this release. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
8e4b87e4ab |
feat(ui): the PEP 668 override asks first and is shown; the preview says what the report says
SECURITY §3 asks for two things the override never had: a confirmation before it turns on, and a persistent chip on every mutating screen while it applies. Turning it on now opens PdDialog with Cancel focused; turning it off saves at once. PdOverrideChip shows on Installed/Updates, Search's dock bay, the plan panel and an environment's detail - only where the override applies: the setting is on and the environment carries the EXTERNALLY-MANAGED marker. A venv never does, and a chip there would claim the flag is being sent. The preview renders the three fields ResolutionReport gained in this release, which nothing showed: - forced: "Will break (n)" in danger, each dependent named with the constraint the forced version violates; the Confirm button carries the count and the danger treatment (DISCLAIMER §2). - incompatible: left out for Requires-Python, with the range against this interpreter (invariant 10). A plan whose only content is one is no longer "nothing to change". - yanked: PD-PKG-003 as a warning row beside the change it belongs to. The summary says when the post-run check could not run (CheckReport.error) instead of showing nothing, which read as a pass (M30). The same defect survived on the empty-plan path of plan::execute, which kept its own unwrap_or(ok: true); it now goes through post_check like every other path, with a test that failed first. Also: settings load at app start once the documents are accepted, so the status line's engine and the chip are right before anyone opens Settings (U13); the plan panel names the interpreter it changes (part of U15); pins.suggestIntro no longer claims a pinned package can still be updated one at a time - an Exclude pin filters a named package too (DATA-FLOW §9.5). flow_step_forced.json is computed by derive_forced and release::mismatch over the scenario rows rather than written, for the reason fixtures.rs gives for its other computed fixtures. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
73e65303ca |
fix(ui): an answer for what the user has left is dropped
Every store awaited a command and then wrote what came back, without asking whether the question was still the one being asked. A slow answer for the environment the user had just left landed on the one they switched to: - the package list and the outdated badges (U5), pin suggestions (U43) and the snapshot timeline check the environment after each await; - a pin write re-joins the rows from the store as it is after the write, not as it was before two awaits (U6); - two clicks down the timeline show the second entry's diff whichever answers first (U42); - the dependency view loads the environment switched to while the previous one was loading, rather than bailing on "already loading" and showing nothing (U34). The plan store counts generations. Leaving a plan the backend is still working on - Back during a resolve or a guard, or out of a parked preview - now stops it there with plan_cancel, and its late answer no longer re-opens the panel the user closed (U9). A failed decision round keeps the preview (U24, the UI half). The progress subscription stays open 50 ms past the command's reply, which arrives separately from its last events and in no promised order. The uninstall guard's probe has its own phase, so the table is not swapped for the plan panel for half a second and its scroll position kept (U14). - Back from a preview is not a finished run: the selection is kept and nothing is refetched (U11). - Search asks again while the index warms instead of waiting for another keystroke (U7); the backend now always answers the first search at once. - Install from the dock bay keeps the queue until the resolve answers (U30). ui/src/stores/races.test.ts holds a command open, moves on, then lets it answer: six of its seven tests fail on the previous stores. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
77ca18cc33 |
feat(app): the GUI logs, says when it cannot start, and shows where the log is
- The GUI writes data\logs\pipdock.<date>.log through the same core::logging the CLI uses, with
the panic hook installed, so a crash leaves a record where it used to leave nothing.
- A data folder that cannot be opened is said in a dialog before any window exists (U18). The
store was opened inside Tauri's setup hook, whose failure is a panic in the event loop: a
release build has no console, so the user double-clicked and nothing happened. It now opens
before Tauri starts, and the failure shows the code, the message and the log path through
rfd - already in the tree via tauri-plugin-dialog, so Cargo.lock gains one dependency edge and
no crate. It is the one place GUI copy is written in Rust (both languages at once), because no
webview exists yet to load a catalog.
- logs_tail returns LogTail { dir, lines } - a new schema, so schema-LogTail is blessed and
schema-unknown-type lists one more type. NOT_YET is down to one entry, env_add_manual.
- Settings gains a Logs row: the folder, as a path, and "Copy recent log", which re-reads the tail
at the moment of copying so the clipboard holds the run that just went wrong. The clipboard
permission "Copy full log" already had is enough; no capability changes. en + vi copy.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
||
|
|
d2993bbd7d |
feat(wire)!: the preview carries what it was missing, and stops carrying the engine's output
A contract change, deliberately in one commit; four schema goldens re-blessed for it (`ResolutionReport`, `FlowStep`, `CheckReport`, `ExecutionSummary`). **`ResolutionReport.raw` leaves the wire.** It was pip's whole `--report` document — every package's README — cloned into each `FlowStep`, serialized over IPC on every round and printed by `--json` (33 KB for two packages, megabytes for "update all"). Nothing in the UI ever read it. It stays in Rust (`#[serde(skip)]`) for the log, and for pip it now holds stderr — pip's warnings — rather than the report the parser already consumed. **New fields, all omitted when empty, so existing JSON reads the same:** - `incompatible: [PythonMismatch]` — pins whose `Requires-Python` excludes this environment (PD-PKG-001), as structured data: the preview shows the required range against the environment's version, which a sentence assembled in Rust could not let it do (invariant 4). Filled by a later commit. - `forced: [HeldBack]` — what "Force latest" will break. Filled by a later commit. - `yanked: [YankWarning]` — **both adapters parsed yank warnings and then dropped them** (`.map(|p| p.report)`), so PD-PKG-003's preview warning has never been shown. `ParsedPlan::into_report` keeps them. **`CheckReport.error`.** A post-execution check that could not run was reported as `ok: true` — "verified" exactly when nothing was, for instance when the run had broken pip itself. It is now `ok: false` with the reason's code; the rows still carry the per-package truth. `CheckReport` therefore embeds `Code`, which makes it the sixth schema that does. **`NothingReason::Cancelled`**, for a resolve the user stopped (wired in a later commit); the CLI maps it to exit 130. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
6559ebcc84 |
feat(model): PEP 440 at the boundary where text becomes argv
SECURITY §2 has always said names *and versions* are validated before argv. Names were; versions were plain strings, so a dock-bay entry of `2.0 ; python_version<'0'` reached argv as one token pip read as a requirement whose marker is false — a silent no-op install — and requirements import failed outright on any range, because `build_request` split on `==` alone (`django>=5.0,<6` became a "package name"; `pkg===1.0` became version `=1.0`). New `pep440` module, the one place that says what a version and a specifier set may look like: a hand-written reader of `packaging`'s `VERSION_PATTERN` (epochs, every pre/post/dev spelling, local labels — nothing legitimate is refused), a specifier-set grammar (`===`, `.*` prefixes, whitespace only between an operator and its version), and `is_argv_safe` for installed versions that are not PEP 440, which the guard set now restates with `===` (packaging dropped `LegacyVersion`, so `==` would be refused). Wired in at every way text arrives: - `Spec::parse` for CLI/GUI install specs and imported requirements; `Spec` and `PinnedSpec` now deserialize through the same checks, closing the IPC door the way `PkgName` already did. - The guard set skips an installed version that could be read as more than one token. - uv's `+ pkg==0.1.0 (from file:///…)` keeps only the version (it reached argv whole). - pip report changes and freeze lines with such versions are dropped / unrestorable. - `pins::validated_hold` and `health::validated_version` were the same charset check twice; both use `pep440::is_version` now, which also rejects `1.0--break-system-packages`, a string whose every character is in a version's alphabet. `version_req` is normalized to an operator form (`==0.28.1`), which `plan_argv_specs` already rendered identically. The one golden that moved is `schema-PlanRequest`, for its doc text. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
2b4681954b |
feat(errors): PD-ENG-004 for an engine watchdog; WinError rules match exactly
**PD-ENG-004 `EngTimedOut`.** Every engine command shares one watchdog, and when it fired the run reported PD-INT-001 — "PipDock hit an internal error" — for an sdist build that was simply still compiling, and in the batch phase that error aborted the whole run with no summary and no per-package retry. A timeout is a fact about the engine, not a PipDock bug, so it gets its own code. Raised by PipDock, never classified from stderr, so it joins the `internally_raised` table of the corpus gate. The exec layer starts producing it in the next commit. The nine places: the catalog variant (`as_str`, `area`, `ALL`), both count tests (34 → 35), the corpus gate, both `errors.json` catalogues, `codes.json` and `generated.ts` (regenerated, not edited), the ERROR-CATALOG row (31 → 32 rows), and the five schema goldens that embed `Code` — `Code`, `StepResult`, `ExecutionSummary`, `HealthReport`, `AuditReport` — each re-blessed for exactly one new `const`, which is the contract change this is. **WinError needles include the closing bracket.** Python prints `[WinError N]`, and the bare "winerror 5" also matched 50, 53 and 59: `[WinError 53] The network path was not found` came out as PD-PRM-001, "use a venv". `[WinError 53]` and `[WinError 10013]` (a firewall refusing the socket, raised *as* a PermissionError) now classify as network failures, ahead of the permission rules that would otherwise take them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
91a846c0fd |
build(deps): every dependency to its latest release
Supersedes Dependabot #75, #76 and #77, which could not merge while `main`'s audits were red. Rust (floors raised to what is locked, so the manifests say what is built): - tauri 2.11.5 → 2.12.4 and tauri-build 2.7.3, with the plugins dialog 2.8.3, opener 2.7.2, clipboard-manager 2.5.0 and single-instance 2.5.4 — in lockstep with `@tauri-apps/*` 2.12, which Tauri's own version check requires. - **rusqlite 0.37 → 0.40.2** (libsqlite3-sys 0.38.2, SQLite 3.53.2). ARCHITECTURE §10 held it because libsqlite3-sys used the then-unstable `cfg_select!`; that is stable since 1.95 and the toolchain is now 1.99.1. Nothing here used `u64`/`usize` `ToSql` (disabled by default since 0.38) or `prepare_cached` (optional since 0.38), and 0.40.1 fixes a SAVEPOINT-name injection. - reqwest 0.13.5, tokio 1.53.3, tokio-util 0.7.20, jiff 0.2.38, clap 4.6.7, schemars 1.2.3, sha2 0.11.1, thiserror 2.0.21, serde_json 1.0.154, async-trait 0.1.92, insta 1.49.0, and 211 transitive updates (h2 0.4.20 among them). npm: React 19.3.1, Vite 8.3.4, @vitejs/plugin-react 6.1.2, **Vitest 5.0.5** (all 18 `vi.mock` calls were already top-level), ESLint 10.12.0, typescript-eslint 8.71.2, jsdom 30.1.3, @tanstack/react-virtual 3.14.21, i18next 26.4.7, react-i18next 17.0.19, @types/* current. **TypeScript stays 6.0.3**: typescript-eslint 8.71.2 still peers `>=4.8.4 <6.1.0`. Code Health pin: ruff 0.16.3 → 0.17.1. Verified by running it, not by reading its changelog: `health/sample/capture.py` reproduces all four committed `ruff/*.json` byte for byte, and exit codes 0/1/2 still mean clean/findings/error. Two things the upgrade surfaced in the frontend, both real: - virtual-core 3.19 measures the scroll element with `clientWidth`/`clientHeight` (it used `getBoundingClientRect()`), and that first reading replaces `initialRect`. jsdom reports 0, so 13 table tests and 5 App-level ones went back to rendering an empty grid; the setup now stubs the two properties beside the `offset*` ones. - jsdom 30.1 implements "a closed `<dialog>`'s contents cannot take focus", which is the spec. React applies `autoFocus` by calling `focus()` during commit — *before* PdDialog's effect calls `showModal()` — and never writes the `autofocus` attribute, so neither path focused Cancel. It worked in WebView2 only because Cancel is the first focusable element. PdDialog and the palette now focus explicitly after `showModal()`, and return focus to whatever opened them on close (it fell to `<body>` before). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
8609518a37 |
test(ui): drive the shell against a logging bridge
The jsdom form of the recipe that has found more real defects here than any suite: render the app, log every command that crosses, read back what actually happened. Stage 2 found every screen fetching twice this way and Stage 4 found a plan resolving into a screen that does not render it — both faults *between* components, which is the one place a component suite cannot look. It proves the premise the slice is built on where it can actually be observed: `deps_graph` crosses **once** when the view opens and **zero** times on a re-centre. It also covers the seam nothing else did — the row's new button through the table, the screen, the store and out to the bridge — and pins the three row actions with none of them a tab stop. Writing it found the trap the browser recipe already records, in its jsdom form. `App` calls `checkConsent()` on mount and `useLegalStore.check` **fails closed**, so setting `accepted: true` in the store is undone a tick later by the real command rejecting and the legal gate replaces the entire shell. The store reached `phase: 'ready'` with the graph in hand and every assertion was reading a licence agreement. Both halves have to be stubbed; the comment says so. The browser pane could not reach localhost in this session, so this stands in for the live drive rather than replacing it — the Rust side of a command and the real window still want a human. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
6ef677bc01 |
feat(ui): the dependency view, drawn at the one depth that survives the data
A mode of the package screen, not a tenth tab. `PdEnvironments` switches
to `PdEnvDetail` on `openFor`; this switches on `focus`, for UI-SPEC §4's
reason: `Ctrl+1..9` is positional over `NAV_KEYS`, appending is free and
inserting is not, and a Dependencies tab would have to sit beside
Installed to read as related. `NAV_KEYS` is already nine, so a tenth
entry would have no digit at all.
Three columns at depth 1, and depth is navigated by re-centring rather
than drawn. That is a measurement, not a preference: on the 352-package
fixture a depth-1 neighbourhood is a median of 7 nodes, and depth 2 is a
median of 172 and exceeds 60 for 212 of 352 packages. No layout
algorithm makes 172 nodes legible, so the eleventh runtime dependency, a
THIRD-PARTY-NOTICES edit that re-shows the legal gate, and a CSP
argument all buy a picture nobody can use. Transitive reach is two
numbers instead, and paths are not offered at all — `setuptools` has
more than 2000 distinct paths to a root in that environment.
**UI-SPEC §4 said the third row action folds all three into a `⋮` menu.
It does not.** A menu spends one click opening and one choosing, so
uninstall becomes four clicks where §5's table records three,
hand-counted. Four is under the ceiling of 5, which is exactly why the
budget alone would have let it through. A third inline button costs
nothing: the row is the only tab stop, so the controls are a roving
sequence and a third is one more arrow step, not 200 more stops.
Nothing is carried by colour. `styles.css` rebinds every `--color-*` to
a system keyword in forced-colors, so every edge states its specifier as
text and the columns are told apart by heading and position.
`deps_graph.json` is computed by `fixtures::deps_graph`, never written —
`numpy_blockers`' lesson. It turned out to carry two dependents with two
different specifiers *and* two packages with unsatisfied requirements,
which is more than a hand-written one would have thought to include.
Two defects the tests found by being run against mutations rather than
by being written: a column helper keyed on copy silently matched nothing
once the heading pluralised ("2 packages require this", not "requires"),
and a name-only comparison of the dependents column passed a mutation
that dropped the version and the specifier from every row.
The invalidation is the one this slice was warned about: `freshGraph`
keys on `envHash`, which a mutation does not change, so `App.tsx` resets
the slice in `onFinished`. Health and Security guard and never reset
because nothing they read is altered by an install. Edges are exactly
what an install alters.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
c58fcac523 |
feat: deps_graph, and the shape it deliberately is not
`pin_suggestions`' shape, not `audit_run`'s. No `Sessions` slot, no progress channel, no cancellation: those exist because an audit is 18-68 seconds, and a probe is 605 ms. Borrowing them here would be a constant carrying its original units — the mistake `AUDIT_TIMEOUT` already records. One call per environment rather than one per package, which is the whole reason the value is shaped this way. The view re-centres on a click; a `deps_for(pkg)` command would read more naturally and pay a probe for every click to answer a question the previous probe already held the data for. No store read, so there is no guard to drop — `pkg_list` is the same and for the same reason. All five sites: the command, the handler list, `COMMANDS`, the wrapper with `DepsGraph` added to the `import type` list (`export type *` does not bring it into scope for a wrapper's own signature), the `test/ipc.ts` mock, and ARCHITECTURE §7 — with its trailing pipe, which the test added two commits ago now checks. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
4ddec61ebb |
feat(wire): DepsGraph is a schema type
Registered in `schema_for!` and `SCHEMA_TYPES`, and in `golden.rs`'s own copy of that list — the deliberate second list, which `schema_lists_exactly_the_documented_types` holds in step by reading the real one back out of the binary. Only the root type, as the comment beside `HealthReport` says: the generator hoists every `$defs` entry, so `DepEdge` and `DepsNode` arrive as their own TS declarations without being listed, and listing them would emit each twice. `golden__schema-unknown-type.snap` churns because the error message enumerates every known type, which is a real behaviour change rather than noise. 67 snapshots. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
99a25f3fa4 |
build(deps): ruff 0.16.3, zustand 5.0.15, typescript-eslint 8.67.0
Landed here rather than by merging #48 and #49, for two reasons that are the same reason: both branches were cut before Slice 0 and P1-1, so each was ~3,400 lines behind `main` and both touched `package.json`, which the 1.2.0 bump had since moved. A green check on a stale base is the thing that broke `main` twice already. **The ruff bump does not stand alone**, which is the P4 defect in full: `health/mod.rs` asserts the rendered requirements body against a literal carrying `ruff==0.16.2`, and `fixtures.rs` hardcodes the same string into `HealthReport.toolVersions`. Bumping the ledger alone turns both red. Ledger, test literal and fixture move together, with `ui/src/test/fixtures/health_*.json` regenerated. rusqlite 0.40 (#50) is closed rather than deferred: ARCHITECTURE §10 holds it at 0.37 because `libsqlite3-sys` 0.38.1's build script needs the unstable `cfg_select!`, and `rust-toolchain.toml` still pins 1.94.1. That is a compile failure, not a preference. 386 Rust tests, 204 UI tests, fmt/clippy/typecheck/lint clean, `npm audit` finds nothing. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
62c359c75b |
feat: the audit venv is a cache target, and a report can be saved
Two gaps the Security tab left, both of the same kind — a thing that exists on disk or on screen that the rest of the app did not know about. **The cache manager under-reported by a whole venv.** P1-1 put pip-audit in `data\audit\`, and `cache::usage` knew only about `data\tools\`, so "clear the cache" would have left one venv behind while reporting it gone. `Target::Audit` is a separate variant rather than part of `Tools` for the same reason the venvs are separate: two directories are two rows. Fixing that turned up a second, worse one. `total_bytes` summed three entries and the new field made four, so the total silently under-reported while **every existing test passed** — the size on screen would have been wrong with nothing to say so. `every_entry_reaches_the_total` now asserts on distinct powers of two, so a missing term shows up as its own bit rather than as a number that merely looks plausible. `PdCacheUsage`'s `entryOf` also became a lookup, because its ternary chain ended in a hand-maintained negation that would have reported the tools venv's size on the audit row. **And an audit could not be saved**, where Code Health writes Markdown and JSON beside a chosen path. `audit_save_report` is `health_save_report`'s shape exactly, including both of its reasons: Rust does the writing because `dialog:allow-save` asks for a path and grants no `fs` permission, and the report comes from the frontend because what the user asked to save is what is on their screen. `audit::markdown` lives in core so a future `--format md` reuses it rather than growing a second renderer, and it states the source at the top — an advisory database records what has been *reported*, which is what a reader needs to judge an absence of findings. Still owner-verifiable only: the save dialog itself, which needs the real Tauri runtime rather than the stubbed bridge. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
cbb6b17da4 |
feat(ui): the Security screen, and the sentence it told while running
`PdSecurity` owns the run, the errors and the progress; `PdAuditReport` owns the list.
Same division as `PdHealth`/`PdHealthReport`, and it is what lets the list be tested
against a fixture with no store at all. Routing the screen is one line: the nav slot,
`Ctrl+7` and both locale labels have existed since M2, so `PdSidebar`'s `NOT_YET` is
empty for the first time and `PdPalette`'s comment about a placeholder is no longer
true.
**The fixture is computed, not written** — `fixtures::audit_report` runs the real
`audit::parse` over a real pip-audit capture. Slice 0 is the reason, and the risk was
concrete rather than theoretical: dedup and the fixable-first order are exactly what
these tests read, and both live in Rust. A two-package capture, because one cannot show
grouping — sixteen rows collapsing to thirteen advisories, five of them against pip
itself, which is `Engine::freeze` passing `--all` and a fact the screen does not hide.
**One defect, found by clicking Run against a deliberately slow bridge.** Mid-run the
body read *"No audit has run for this environment"* — while an audit was running. The
report is cleared before the command, so `shown` is null during a run, and the un-run
empty state was rendered on that basis. It is P4's *no issues found before anything had
run*, inverted: a true-looking sentence derived from a state the screen had not loaded.
The body now says nothing while a run is in flight, because the live region, the
disabled Run and the Cancel beside it already say what is happening. `PdSecurity.test.tsx`
is new and asserts the absence; mutation-checked by restoring the old branch.
Verified in the browser against a stubbed bridge, per the recipe that found Stage 2's
double fetch: `audit_run` crosses **once**, all three `plugin:event|listen` calls precede
it (so a cold bootstrap is not emitted into nothing), both package groups render, Cancel
really reaches `audit_cancel`, and stale advisories clear before a second run rather
than sitting under a new timestamp.
`useSecurityStore` keys on `envHash` alone — health's `{envHash, folder}` pair exists
because Code Health has a project folder and an audit has none. `cancel` deliberately
sets no phase: a cancelled run still returns a report carrying `cancelled: true`, and
resolving the phase here would race that and throw away the partial answer.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
2c6670a336 |
feat: audit_run, audit_cancel and pipdock audit
The Security tab's core reaches both heads. `AuditReport` joins `SCHEMA_TYPES`, which is the six-place change the P1-A record describes — including `golden.rs`'s own copy of the list, a new `golden__schema-AuditReport.snap`, and the expected churn in `golden__schema-unknown-type.snap`, whose error message enumerates every known type. `audit_run` takes the freeze itself, through the configured engine, because that choice changes what is audited: pip is invoked with `--all` and includes pip and setuptools, uv has no such flag. The real run makes that concrete — auditing the SP-4 environment reports **five advisories in pip 25.0.1** alongside urllib3's eight, which a uv-engine audit of the same environment would not see. The store guard is read and dropped before any subprocess. `AppState.audit` is `Sessions<()>`: nothing is parked, because an audit hands its report straight back with no second call consuming it the way `health_fix` consumes a `HealthSession`. What the slot is for is the **token**, which lives beside it so `audit_cancel` can reach a run the slot no longer owns. Its own slot rather than health's, for the reason health's is not `sessions` — an audit touches no environment, so refusing it while Code Health runs would be a lock with no invariant behind it. `pipdock audit` exits **1 on findings**, as `health` does: an advisory is a result, not a failure, and a script wants to branch on it. A tool problem outranks the findings, so a report that is empty because pip-audit never ran cannot exit 0 and read as "nothing wrong here". **Run rather than asserted.** Cold, against `spikes/out/target-env` with an isolated `LOCALAPPDATA`: the audit venv bootstrapped, wrote its manifest, and reported 13 advisories across 2 packages; `--json` emitted **one** camelCase document with `toolVersion` read back out of that manifest, and exit was 1. The second run did no bootstrap at all, which is `needs_sync` returning `Fresh` for `AUDIT_TOOLS` — the half of the venv split that only a warm second run can show. Two hand-maintained lists were a row short and are not now: ARCHITECTURE §7, which the new drift test demanded before it would pass, and `golden.rs`'s per-command help list, which nothing polices — so `help-audit.snap` exists rather than the subcommand's help going unpinned. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
adaa363f7c |
fix(ui): the held-back row named the dependent twice
The preview rendered `scipy requires scipy 1.11.4 requires numpy <1.28.0,>=1.21.6`.
`graph::blockers_for` assembled a whole English sentence into `Blocker.constraint`
while also setting `by`, and `PdConflictRow` passed both to `plan.blocker`, whose
template is `{{by}} requires {{constraint}}`. It has shipped in every release that
had a preview.
The sentence lived in Rust because the CLI prints that field alone, so the CLI was
the one head it looked right in — hard invariant 4 the wrong way round. `Blocker`
now carries `by`, `version` and a bare requirement: the shape its own doc has
described since M1 (`"requests<2.31"`) and the shape `graph::BrokenDependent` has
always used. Each head writes its own sentence — `run.rs` gains `blocker_line`,
mirroring the guard composition a few hundred lines below it, and the GUI
interpolates the same three fields `PdUninstallDialog` already does.
Why the suites were green. `PdPreviewDiff.test.tsx` *did* assert this sentence, and
asserted the correct one, because the fixture's blockers were hand-written to the
documented shape while core had drifted away from it. `fixtures.rs`'s own module doc
says hand-writing that JSON "would defeat the guarantee", and `guard_report()` is
computed for exactly that reason; the plan fixture's blockers were the one exception.
They are computed now, from the same rows — which is also why there are two: `pandas
2.1.4` and `scipy 1.11.4` both exclude 2.5.1, and only one was ever written down. The
force-latest confirm consequently names both and exercises the plural branch of
`forceWarning`, which nothing did before.
`PdConflictRow` gets its first test. Checked against the bug rather than trusted
green: restoring the sentence in core and regenerating the fixture fails it on the
doubled text, and removing it passes again.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
ef9f4f5016 |
feat(ui): the Ctrl+K command palette — P1-D
UI-SPEC §1 called this a signature move and PRD P1-5 has listed it since the start.
Frontend only: every action already exists as a store action, so no IPC command, no
Rust, no capability change.
`Ctrl+K` collided with nothing and was a **silent no-op** — `App.tsx` parses `e.key`
as a number, so `'k'` became NaN and `NAV_KEYS[NaN]` was undefined. The branch sits
*after* the guard-and-panel bail, which makes both refusals structural rather than
remembered: the palette cannot open while a plan owns the content area, while the
guard dialog is up, or behind the legal gate including About's review mode. A palette
that could navigate during an execution is the defect S3 shipped, through a different
door. Verified in the browser: behind a re-opened gate, Ctrl+K and Ctrl+3 both do
nothing, and the palette works again once it closes.
**Its own matcher, twenty lines, not `index_search`.** That command searches 864,000
PyPI package names over IPC — the wrong corpus and the wrong cost for nineteen
actions. What is taken from `index/mod.rs` is the ranking philosophy SP-3 paid for:
tiered, not score-ordered, because a raw fuzzy score rewards density and puts
`requests-ntlm` above `requests`.
**A ranking flaw the tests caught.** Matching one flat `"${group} ${label}"` string
ranked *Download the index* — group "Search", so a prefix match — above the Search
tab itself, whose label matched only as a subsequence of `go to search`. Someone
typing a screen's name wants the screen. Primary and secondary text now score
separately, with a gap wider than any tier, so every label match beats every group
match. Confirmed in the running app.
Not built on `PdDialog` — it hardcodes a heading and a Cancel-first row for
destructive confirms, the opposite of a filter list — but its `showModal()` pattern
is lifted whole, including the `if (!el.open)` guard that exists for StrictMode. It
*does* dismiss on backdrop click, which `PdDialog` argues against and is right to for
a confirm; nothing here is destructive on its own.
A listbox with `aria-activedescendant` rather than tab stops, so the input keeps
focus while the arrows move the selection — which is what lets someone keep typing to
narrow. `aria-selected` is also what survives Windows high-contrast mode, where the
tint is erased and `styles.css` outlines the selected row instead.
20 tests across the matcher and the palette.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
0b02bbde1e |
feat: the cache manager — P1-C
**The scope needed correcting before anything was built: there are no log files.** `LOG_RETENTION_DAYS` has never had a reader, the only log is the in-memory ring buffer behind *Report bug*, and `logs_tail` is still owed. So this covers three artefacts, not the four the roadmap listed — a "logs — 0 B" row would be inventing a thing that does not exist. **`index.db` is not a target, and the screen says why.** It holds the package index *and* the settings *and* the pin list *and* the legal-consent record in one SQLite file, so a "clear the cache" that removed it would take a user's pins — the same class of surprise the privacy policy had to be corrected for. Its size is still reported: a disk report that omitted the largest thing on disk would be answering a different question. **This is the first delete-a-tree in production code**, so the safety design is the feature rather than the UI: - **Nothing is removed by path.** Callers name a `Target` enum; `cache::path_of` is the only thing that turns one into a location, and it is private. There is no function here that accepts a path to delete. - **The resolved path is checked to be inside the data root**, canonicalized on both sides. A prefix test on unresolved paths is a string comparison wearing a `Path` — on Windows it passes `data\..\..\Users` and fails a legitimate path that arrived through a junction or a short name. - **Symlinks contribute zero and are not walked.** `fs::metadata` follows them and would report the target's size; worse, a recursive walk that follows one can leave the data root entirely, which is the single thing this module exists to prevent. Pinned by a test that builds a real link out of the root. `PD-PRM-002` rather than a generic failure when the files are held open: a tools venv whose Python is still running is the ordinary way to hit this on Windows, and it is something the user can act on. Clearing goes through `PdDialog` — Cancel first and focused, per UI-SPEC §7 — and the confirm says exactly what is lost: snapshots take the *record*, not the environment. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
3d636a4793 |
feat: requirements export and import — P1-B
**Export needed no formatter.** A `pip freeze` document *is* a requirements file, and `Engine::freeze` already produces it for snapshots — so `env_export` is that string and a path, and there is one idea of what a written-down environment looks like rather than two. A constraints file is the same body under a different name. Import is the half with work in it, and the work is parsing. `snapshot::parse_freeze` was deliberately not reused: its narrowness is what makes it the exact complement of `unrestorable_lines`, an invariant the rollback preview depends on, so widening it to read a hand-written file would break the thing it exists for. `crates/pipdock-core/src/requirements.rs` handles ranges, extras, markers, hashes, continuations and comments, and **reports by line** what it will not use: `-r`/`-c` includes name files PipDock has not read, `-e` and URLs install from outside the index, `--index-url` changes how everything installs. Reported rather than skipped, because a silently shorter install list is the failure DATA-FLOW §9 exists to prevent — the preview would be honest about itself and wrong about the user's file. **A real defect found while writing the tests.** `graph::Requirement::parse` splits the name at the first space, so `this is not a requirement` parses happily as name `this` with constraint `is not a requirement` — which would have rendered as a spec containing spaces and gone straight into argv. That is correct for its own job: `Requires-Dist` metadata never looks like prose. A file a person typed can. So the constraint is shape-checked here, the same obligation SECURITY §2 puts on every other user-supplied version, and the check is deliberately a shape test rather than a PEP 440 parse — rejecting a legitimate specifier would make a package uninstallable, which is the worse failure. Eight specifier shapes are pinned by a test. Reading and writing both happen in Rust: `capabilities/default.json` grants only `dialog:allow-open` and `dialog:allow-save`, so the webview can ask for a path and do nothing with it. `pickOpenFile` joins the two existing pickers; the permission already covered it. The UI sits on the environment detail screen beside snapshots — both are the environment as a document — and **import does not install.** It hands the specs to the ordinary flow, which previews, snapshots and confirms. Arriving from a file earns no exemption. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
929cff898a |
fix(ui): cap the suggestion list, because a real environment offers 94
Running it against `C:\Python314` — 352 packages, the scale fixture — the default threshold of 5 qualifies **94 packages**. The ranking is right (setuptools at 150 dependents, then zope at 93, zope-interface at 86; it is a Plone environment and those really are its workhorses) but a "Worth pinning" section with 94 rows is not a suggestion, it is a second package list. No unit test could have said this. The fixtures have six packages because that is what proves the threshold logic; the usability of the result at scale is a property of real dependency graphs. **Raising the default would have been the wrong fix.** A deep tree is exactly where a bulk update is most dangerous, so it is exactly where the feature has to work. The screen shows the top 8 and says how many more qualify — `RUFF_ROWS_SHOWN`'s pattern, including its rule that the count comes from the **full** list so a capped view never misreports a total. `pins::suggest` is unchanged and still returns everything at or above the threshold, which is what keeps it composable. Measured in --release while there: probe **605 ms**, graph build plus the entire suggest pass **1 ms**. The plan's worry about `dependent_count` being O(n·m) over 350 packages was unfounded — the subprocess dominates completely, and there is no case for a batched counts method. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
ce833c3475 |
feat(ui): the suggestion section on Pins, and the threshold that governs it
UI-SPEC §4's `(P1) auto-suggest section: "urllib3 — 12 packages depend on it. Pin?"`,
built where the spec put it. Above the pin list, because it is a prompt to act and
the list below is a record of having acted; absent entirely when there is nothing to
suggest, because an empty "Worth pinning" heading is a question nobody asked.
**Its own fetch key, not `loadedFor`.** `useEnvPackages` covers two calls with one
flag, and folding a probe-costing third into it would tie its staleness to theirs.
`suggestionsFor` is the `snapshotsFor` pattern, including the *synchronous*
`loading` check before any await — without it StrictMode's second effect run reaches
the key check before the first has answered, which is Stage 2's double fetch, except
each call here costs a `probe.py` run. Verified against the bridge log: **one call**
per visit.
**Silent on failure, deliberately.** There is no `suggestionsError`. This screen's
job is listing pins and it does that either way, so an error row about an advisory
would be the loudest thing on it.
Accepting writes the count as the pin's reason — PRD P1-2 says "suggest pin with
reason", and the field below is editable so it is a starting point rather than the
last word. It goes through `writePin` like every other pin write, then drops the
entry locally rather than re-probing to learn what cannot have changed.
**The first `type="number"` in the codebase**, so it sets the rule: reject at the
boundary, never store junk. `<input type="number">` reports `''` for anything it
cannot parse, and coercing that writes 0 — which is a meaningful setting ("off") the
user did not ask for. Driven in the browser: `abc`, `-1` and `9999` each write
nothing; `3` writes once.
Copy on this screen avoids the substring "hold" — `PdPins.test.tsx` asserts
`queryByText(/hold/i)` is absent to prove no Hold pin can be created, and "threshold"
matches it. That is why the field is worded "Suggest pinning at" and lives on
Settings.
Eight tests. One of them found a real property while being written: the fixture row
had no `env`, so `pin_suggestions` was never called — which is correct behaviour for
a row whose probe failed, and now has a case of its own.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
446d84a3b8 |
feat(bridge): pin_suggestions
Takes the whole `PyEnv`, not an `env_hash`. There is no resolver from one to the other and there cannot be: `envs::env_hash` is a one-way SHA-256 of the canonicalized interpreter path. Every command that probes takes a `PyEnv` for this reason; the hash is derived inside, the same thing `flow::UpdateFlow::start` does. Store read, guard dropped, *then* probe — `pkg_outdated`'s rule. Both the pin list and the threshold come out of one locked block. Holding it across the await compiles, passes every test, and freezes `settings_get` and the pin commands for the length of the probe. One probe per call, which is why UI-SPEC §4 puts this on the Pins screen rather than a sidebar badge: only someone who opened the tab pays it. The alternative — asking the frontend for the `Dist` list it already holds — would send several hundred packages' worth of `requires_dist` back across the bridge to save a subprocess. **The drift tests found a fourth registration site the plan had missed.** `crates/pipdock-cli/tests/golden.rs` keeps its own copy of `SCHEMA_TYPES`, and `schema_lists_exactly_the_documented_types` reads the real list back out of the binary to compare — so the local copy cannot silently fall behind. It failed exactly as designed. Six places, not five: core's `schema_for!`, core's `SCHEMA_TYPES`, the test's copy, `generate_handler!`, `COMMANDS`, and the typed wrapper. Two goldens, both read before blessing: `golden__schema-PinSuggestion.snap` is new, and `golden__schema-unknown-type.snap` gains one word because its error message enumerates every known type. That is a real behaviour change — the CLI serves one more schema — which is the only condition under which that file may be re-blessed. 61 snapshots now. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
ba6f19722e |
docs: an AI disclosure, and a CLI guide written by running the CLI
**AI disclosure.** PipDock was written with substantial help from Claude Opus 5 (Anthropic, via Claude Code), and the fact was only visible as a commit trailer. `docs/AI-DISCLOSURE.md` is the full statement — model, vendor, period, what it wrote (source, tests, debugging, the VI catalogue), what review actually meant, what was not delegated, and how to verify any of it from `git log`. 172 commits, 163 with the trailer. It also says the thing worth saying: a green suite was never sufficient. Thirty-four defects reached or nearly reached `main` and not one was caught by the suite that was green at the time. Three surfaces, because three different people look in three different places: the README for someone browsing the repo, `docs/` for someone reading the code, and the **About tab** for someone who installed the app and will never open GitHub. The last one needed keys in both catalogues. **`docs/CLI-GUIDE.md`.** CLI-SPEC is the contract; this is what you type. Written against `pipdock 1.0.0` by running every command rather than by reading the spec — which is how the exit codes in it were confirmed (`PD-ENV-001` really is 3, `schema` on an unknown type really is 1) rather than copied. That also turned up a defect: `self report-bug` printed **fourteen stray spaces** in the middle of a sentence, because a multi-line string literal keeps its source indentation. Nobody had read the output. Also: `About.png` -> `about.png` so the seven screenshots share one convention, and the About shot joins the README. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
57c365e36a |
feat(ui): About — what PipDock is, and a way back to the documents you accepted
UI-SPEC §4 has specified *Legal & About* since the spec was written, as a section inside Settings, and four milestones shipped without it. That is what folding a read-only surface into a screen of controls does. It is now the ninth tab. **The ninth tab cost nothing.** `App.tsx` reads `NAV_KEYS[key - 1]`, so appending `about` made it Ctrl+9 without moving one existing binding. UI-SPEC's warning was about *inserting* — which is still true, and is still why Snapshots is a mode of Environments: it would have to sit beside Environments to read as related. The comments in four files said "a ninth entry would renumber Ctrl+1..8"; they now say what the rule actually is. Contents: what PipDock does and what it does not collect; version and the legal-docs hash from `app_info` — a command that has existed since M1 with no consumer, so the version on screen cannot drift from CARGO_PKG_VERSION; the SPDX identifier `GPL-3.0-only` rather than the looser "GPL-3.0" elsewhere; a control that puts the gate back; and contact. **Addresses are copied, not opened.** `mailto:` would widen the opener capability by a whole URL scheme, and the scope's real job is bounding the two call sites that pass data — one of which hands over a URL that came out of ruff's JSON. Clipboard-write is already granted, works with no mail client, and the address has to be on screen anyway. Only `https://poli0981.dev/*` was added, for the links page. They are also TS constants rather than catalog entries: an address is data (I18N §2), and a catalog is a thing a translator is invited to change. **`review` is a flag of its own, not `accepted = false`.** Re-using the latter was one line and would have made a review indistinguishable from a revocation — offering Accept, and a Decline that closes the application, to someone who wanted to re-read their privacy policy. The gate takes a presentational prop instead; first-run rendering is untouched and `PdLegalGate.test.tsx` (its first test, ever) pins that. Two things found by running rather than by the suite: - `app_info` fired **twice** per mount under `npm run dev`. StrictMode's doubling is dev-only, but it drew attention to the real one: `key={nav}` remounts `<main>`, so every visit to About was a fresh call for a value baked in at compile time. Now cached per process in `useAppInfo`. Verified against the bridge log: one call. - The whole seam — About, re-open, Ctrl+3 refused behind the modal, Close, back on About — with zero IPC calls, confirming consent is never touched. VI catalog complete and checked in the running app; the parity gate gets the rest. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
10691a117a |
fix(ui): a shortcut that fires behind a modal, and three neighbours
Four defects found while reading App.tsx for the About tab. None was reported; all four are the kind that look like nothing until they don't. **Ctrl+N never refused while a plan owned the screen.** `App.tsx` returned early on `guardOpen` only, and `PANEL_PHASES` excludes `guard` on purpose — the two sets are disjoint, so guarding on one guarded neither. The sidebar was disabled and the panel kept rendering, so nothing looked wrong until the plan finished and dropped the user on a tab they never chose. UI-SPEC §8 has asserted the opposite since S3. **Ctrl+N also fired behind the legal gate.** The keydown effect is registered above the `accepted === false` early return, so the listener was live while the modal was up. Harmless today because nothing renders underneath; not harmless once About can put the gate back on screen. **Four call sites opened URLs with `void openUrl(...)`.** `opener:allow-open-url` is scoped, so a URL outside the allowlist rejects — and a discarded rejection means nothing opens and nothing says so. SECURITY §4 names that silence as the reason the allowlist is documented in prose; this is the same fact from the UI side. `PdLegalGate` handled it by hand. The rule is now `useOpenExternal`, and the sharp case is `PdHealthReport`'s rule link: `finding.url` comes out of ruff's own JSON and is the only URL in the app derived from a third-party tool's output — precisely what `https://docs.astral.sh/*` exists to bound. Its `?? ''` was papering over a narrowing TypeScript loses inside a closure, and handed the opener an empty string. **`reportBugUrl` was mocked with the wrong shape.** It resolved a bare string where the wrapper returns `BugReportLink { url, log }`, so any test clicking *Copy full log* asserted against `writeText(undefined)` and agreed with itself. A mock of the wrong shape is worse than none: it makes the seam it covers look tested. `REPO` moves to `components/legal.ts` with the five-document list, ahead of About needing both. 15 files, 145 tests still green. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
3eeda059c8 |
fix(ui): a hand-written fixture that npm test accepted and tsc did not
CI's Node job failed on the test I had just added: `TS2322` on an `ExecutionOutcome` literal that was missing `appVersion` and carried three fields `SnapshotMeta` does not have. Vitest does not typecheck, so `npm test` passed — and I ran the suite and the linter after adding the file but **not `npm run typecheck`**, which is the one gate that could see it. Now taken from `snapshot_list.json`, which is the pattern the rest of the suite already uses and the reason it exists: a fixture serialized from the real Rust type cannot drift from it, and a literal typed by hand can be wrong in three ways at once. Also records the Phase 4 state for whoever picks this up: what the pipeline can now do, and the six things still open — a genuinely clean machine, SmartScreen, the rest of the manual charter, the icon, the version and RC tag, and README screenshots. CLAUDE.md gains the two rules this stretch established: building and installing are their own test tier, and the seam between a tested component and its untested parent is where bugs live. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
2abfef6a7c |
fix(ui): one window, one way back, and a sidebar that stops mid-plan
Four things from the first real click-through of the installed build. **Two "Back to packages" buttons after a successful run.** `PdSummarySheet` renders `plan.done` from its `onDone`, and the panel rendered a second one beneath it. The panel's is now shown only when there is no sheet — a run that failed before producing an `ExecutionSummary` has an error row and nothing else, and without a button that phase is a dead end. Worth naming *why* no test caught it: `PdSummarySheet` has its own tests and `PdPlanPanel` had none, so the two had never been rendered together. `PdPlanPanel.test.tsx` now does exactly that, and it was checked against the bug — reverting just the panel change makes it fail with "expected 2 to have length 1". Adding it exposed a second gap: `ipcMock` had no `reportBugUrl`, which `PdErrorRow` asks for on mount, so any screen containing an error was untestable. **No single instance.** Five launches gave five windows — which is five `AppState`s over one machine: five `Sessions` slots, each certain it owned the mutation in flight, and five `PD-RES-003` guards that cannot see each other. `tauri-plugin-single-instance` is registered **first**, before any plugin that could take a lock, and the handler unminimizes before focusing: focusing a minimized window leaves it minimized, and the user's second launch appears to do nothing. Added without the `deep-link` feature `cargo add` selects by default — PipDock registers no deep links, and it pulls three crates into the audit surface for nothing. **The sidebar is disabled while a plan owns the content area.** Navigating away left the plan parked in Rust with nothing on screen driving it, and the next Update answered `PD-RES-003` about a plan the user could no longer see. `App.tsx` already refuses `Ctrl+1..8` while the guard dialog is open; this is that rule applied to the panel and to the mouse. **The window is bounded and cannot be maximized.** `maxWidth`/`maxHeight` at 1600×1100 with `maximizable: false` and `fullscreen: false`. The layout is a fixed sidebar plus one scrolling column; stretched across a 4K panel it is a column of text with a metre of empty surface. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
73a67a6243 |
feat(ui): reach the row's actions with a keyboard, and stop saying things twice
UI-SPEC §8's remaining keyboard work, and it turned out to be hiding a WCAG 2.1.1 failure.
**Pin and uninstall were unreachable without a mouse.** Every control in a package row is
`tabIndex={-1}` so that 200 rows do not become 600 tab stops — a sound trade for the
checkbox, whose job `Space` already does from the row. Applied to the two action buttons it
removed the actions entirely: the row was the only tab stop, and from it there was nowhere
further to go. Found by tabbing to a row in the running app and pressing every key that
should have done something.
The ARIA grid pattern's answer is a roving tabindex, so that is what this is: `ArrowRight`
and `ArrowLeft` walk the row's controls, `Escape` comes back out to the row, and no tab stops
are added. Verified in the browser — the focus walk is checkbox → *Pin this package* →
*Remove this package* → row.
**`Enter` is the row's primary action, and it is pin rather than uninstall.** A row has one
reversible annotation and one irreversible removal; a destructive operation one keypress away
from a focused row is not a primary action, it is an accident waiting. `Space` still toggles
selection independently — checked, because a new binding on the same element is exactly how
an old one stops working.
Note what the audit actually found: `Enter` already worked everywhere else in the app,
because every other primary action is a real `<button>` and buttons handle it natively. The
gap was one element that only looks like a control.
**Two live regions folded, and the pair that mattered was not the pair the ROADMAP counted.**
`PdEnvDetail` had two on one screen; they are now one, which is safe because a diff cannot be
loading before a snapshot has been selected from the list. And `PdConsoleDrawer` announced
the same `done/total` as the panel that opens it, so a reader heard every step twice — the
drawer's is gone, because the screen owns the announcement and the drawer may be closed while
a run is going. Ten regions down to eight, with the two genuine conflicts removed rather than
the count merely reduced.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
3e72ecf7c4 |
feat(ui): Fix N safely fixable issues, and a confirm that says what it cannot undo
**One dialog with two states, not two dialogs.** Two confirms would break the click budget, and the second is the one nobody reads. `PdDialog` renders Cancel first and focuses it, so Enter without Tab cancels — UI-SPEC §7's rule for a destructive confirm, inherited rather than re-implemented. `button[data-action='fix']` joins the forced-colors list in `styles.css`, because high contrast drops every tint and a destructive primary that looks like Cancel is worse than no colour at all. The unconditional line is *PipDock cannot undo this; only your own version control can* — true whether or not there is a repository. The **danger** block is reserved for a tree that really has uncommitted work, so a folder outside version control is not nagged about. That is the same reasoning `fix::dirty` documents for answering `None` rather than warning. `health_dirty` is a command of its own rather than a field on the report, because the answer expires: the user can commit, or start editing, between the run and the button. It is asked when the dialog opens, and `health_fix` asks **again** before writing — this answer decides what to render, that one decides what to allow. Every count comes off the report. The button names `fixable`, the dialog names `fixableFiles`, and neither is derived from the badges rendered beside them — the button, the CLI prompt and the server's own check all have to name one number, which is what `recount` exists for. `fix` is in `NO_HEALTH`, so a second Run closes an open confirm. The server replaces its parked report on a new run, and a dialog left open would let the user confirm a count that no longer exists on either side. On success the tab drops to `remaining` with **no second Run**, which is why the server re-parks its session rather than releasing it. On failure the dialog closes and the report stays: nothing was written, so it is still true, and every failure here is one the user has to act on elsewhere — commit, clear a read-only flag, or re-run. Six store tests, including the two that would pass silently: that `acknowledgedDirty` is true only when the tree really is dirty, and that a failed dirty check opens the confirm anyway rather than blocking the fix for a reason nobody can act on. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
d5f02c73d2 |
feat(app): health_fix, and the last NOT_YET row Phase 3 owed
`NOT_YET` is down to two, both M3-general. Code Health is feature-complete. The command takes **no project, no environment, no file list and no findings**. All of it comes from the parked `HealthSession`, which is the point: what is fixed must be what was reported on — the same reasoning that makes `plan_execute` take nothing. `files` crosses as an assertion the server checks against its own copy, so a frontend cannot widen the blast radius past what its own dialog named. Three gates, in the order that matters, all before the first byte: 1. `files` against the parked report — a mismatch is `PD-INT-001`, because only a frontend out of date with its own store can produce it. 2. A **read-only re-read** of the project. Minutes pass between confirming and clicking, and a source tree is not PipDock's to assume is still; a change in either count is `PD-RES-002`, which is DATA-FLOW §9.3's staleness rule applied to the one thing no snapshot describes. It has to be a separate invocation because `--fix` writes as it goes. 3. `git status` asked **again**. The dialog's answer decided what to render; this one decides what to allow. `ruff_argv` is extracted so the re-check and the run cannot drift — a re-check excluding different files would compare two different questions and refuse a fix the user was correctly shown. And a note where the next person will read it: if `RunOptions` ever reaches the wire, this must re-check with the *session's* options rather than the defaults. The session is re-parked either way, carrying the post-fix ruff state on success. The screen drops its tab count to `remaining` without a second Run, so the server has to hold the same thing the user is now looking at — otherwise the next fix is checked against a report nobody can see. `claim_one` rather than `claim`, so finding nothing leaves the slot idle instead of wedging every later command with `PD-RES-003` for a session that does not exist. `FixReport` is the one type on the wire; `FixConsent` never crosses. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |