111 Commits
Author SHA1 Message Date
poli0981andClaude Opus 5.5 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>
2026-11-21 23:22:12 +07:00
poli0981andClaude Opus 5.5 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>
2026-11-21 23:22:12 +07:00
poli0981andClaude Opus 5.5 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>
2026-11-21 23:22:12 +07:00
poli0981andClaude Opus 5.5 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>
2026-11-21 21:50:41 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Fable 5.2 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>
2026-11-10 20:01:03 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-25 07:21:45 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5.5 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>
2026-10-17 00:55:27 +07:00
poli0981andClaude Opus 5 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>
2026-08-21 08:35:15 +07:00
poli0981andClaude Opus 5 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>
2026-08-21 08:35:15 +07:00
poli0981andClaude Opus 5 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>
2026-08-21 08:35:15 +07:00
poli0981andClaude Opus 5 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>
2026-08-21 08:35:15 +07:00
poli0981andClaude Opus 5 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>
2026-08-18 12:07:57 +07:00
poli0981andClaude Opus 5 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>
2026-08-18 10:55:11 +07:00
poli0981andClaude Opus 5 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>
2026-08-18 10:55:11 +07:00
poli0981andClaude Opus 5 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>
2026-08-18 10:55:11 +07:00
poli0981andClaude Opus 5 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>
2026-08-18 09:05:59 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 21:16:52 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 21:16:52 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 21:16:52 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 20:19:28 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 20:19:28 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 20:19:28 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 19:03:58 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 17:32:20 +07:00
poli0981andClaude Opus 5 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>
2026-08-14 17:32:20 +07:00
poli0981andClaude Opus 5 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>
2026-08-13 22:08:38 +07:00
poli0981andClaude Opus 5 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>
2026-08-13 22:08:38 +07:00
poli0981andClaude Opus 5 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>
2026-08-13 19:48:48 +07:00
poli0981andClaude Opus 5 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>
2026-08-13 19:30:12 +07:00
poli0981andClaude Opus 5 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>
2026-08-13 19:30:12 +07:00