feat(cli): init prompts to mine, mine handles Ctrl-C gracefully (#1181, #1182)

[igorls]

Summary

UX polish for the init -> mine user journey, addressing two linked issues that touch the same flow.

#1181: init -> mine prompt with scope estimate

After entity confirmation, room detection, and the gitignore guard, mempalace init now shows a one-line scope estimate computed from its existing corpus walk and prompts the user:

~423 files (~12 MB) would be mined into this palace.
Mine this directory now? [Y/n]

The estimate fires BEFORE the prompt -- on a real corpus mine takes minutes-to-tens-of-minutes, so hitting Enter on a default-Y prompt with no size cue would be a footgun. Empty answer / y / yes runs mine() in-process; n exits with the exact mempalace mine <dir> resume hint. Errors from the in-process mine surface via sys.exit(1) instead of being swallowed.

Flag design (revised after review). --yes is unchanged from before this PR -- still scoped to entity auto-accept, still prompts for the mine step. A new --auto-mine flag is what skips the mine prompt. This avoids silently changing behaviour for scripted callers running mempalace init --yes <dir> today.

invocation	entities	mine
mempalace init <dir>	prompt	prompt
mempalace init --yes <dir>	auto-accept	prompt (unchanged from today)
mempalace init --auto-mine <dir>	prompt	auto-mine
mempalace init --yes --auto-mine <dir>	auto-accept	auto-mine (fully non-interactive)

The scope estimate uses a single corpus walk: scan_project's output is passed into mine() via a new optional files= kwarg, so we never walk the tree twice.

#1182: graceful Ctrl-C in mine

Wrapped the main file-processing loop in try / except KeyboardInterrupt. On interrupt, prints a clean summary block (files_processed: N/M, drawers_filed: K, last_file: ...) plus the resume hint, then exits with code 130 (standard SIGINT). Already-filed drawers are upserted idempotently via deterministic IDs, so re-running picks up where it left off without duplicates. A second Ctrl-C during the summary print propagates to the default handler -- we don't try to handle everything.

PID-file cleanup in finally

The hooks-side mine PID lock at ~/.mempalace/hook_state/mine.pid (from #1023) is now actively removed by the mine subprocess on every exit path (clean exit, error, interrupt) -- but only when the file's recorded PID matches os.getpid(), so unrelated mines from other sessions are never disturbed. Stale entries previously relied on _pid_alive() returning False; this makes the cleanup observable and avoids edge cases with PID reuse on short-lived test runs.

Why one PR

Both changes target the same init -> mine -> Ctrl-C user journey. The init prompt path calls mine() directly, so the new try/except in mine() is what makes the in-process auto-mine safe to interrupt without leaving the init parent in a weird state. Reviewing them together keeps the story coherent.

Tests

All new paths covered:

• tests/test_cli.py::test_maybe_run_mine_prompt_accepted_runs_mine -- empty answer triggers mine().
• tests/test_cli.py::test_maybe_run_mine_prompt_yes_accepted_runs_mine -- Y answer triggers mine().
• tests/test_cli.py::test_maybe_run_mine_prompt_declined_prints_hint -- n answer skips and prints mempalace mine <dir> hint.
• tests/test_cli.py::test_maybe_run_mine_yes_alone_still_prompts -- regression guard: --yes does NOT auto-mine.
• tests/test_cli.py::test_maybe_run_mine_auto_mine_skips_prompt -- --auto-mine runs mine without calling input().
• tests/test_cli.py::test_maybe_run_mine_yes_and_auto_mine_fully_noninteractive -- both flags together: never call input(), always mine.
• tests/test_cli.py::test_maybe_run_mine_eof_on_stdin_treated_as_decline -- piped/non-interactive stdin doesn't crash.
• tests/test_cli.py::test_maybe_run_mine_failure_surfaces_via_exit -- mine errors exit non-zero with an error line on stderr.
• tests/test_cli.py::test_maybe_run_mine_estimate_appears_before_prompt -- file-count + size line renders before the prompt fires.
• tests/test_miner.py::test_mine_keyboard_interrupt_prints_summary_and_exits_130 -- KeyboardInterrupt mid-loop -> SystemExit(130) + summary printed.
• tests/test_miner.py::test_mine_cleans_up_pid_file_on_interrupt -- our PID entry removed on interrupt.
• tests/test_miner.py::test_mine_cleans_up_pid_file_on_clean_exit -- our PID entry removed on clean exit.
• tests/test_miner.py::test_mine_does_not_remove_other_processes_pid_file -- foreign PID entries left untouched.

Full suite: 1247 passed locally. Ruff check + format check both clean against the CI-pinned ruff>=0.4.0,<0.5.

Test plan

• Run mempalace init <dir> interactively, accept the prompt -> mine runs, drawers land.
• Run mempalace init --yes <dir> -> entities auto-accepted, mine prompt STILL fires (unchanged from today).
• Run mempalace init --auto-mine <dir> -> entity prompt fires, mine prompt skipped.
• Run mempalace init --yes --auto-mine <dir> -> fully non-interactive, both auto.
• Run mempalace init <dir> interactively, answer n -> exits with the resume hint, no mine.
• Run mempalace mine <large-dir>, hit Ctrl-C mid-loop -> clean summary, exit code 130, no traceback.
• Re-run mempalace mine <same-dir> -> resumes, no duplicate drawers.
• Inspect ~/.mempalace/hook_state/mine.pid before/after a mine run -> cleared after exit.

Closes #1181, #1182.

[Copilot]

Pull request overview

Improves the init → mine CLI flow by prompting to start mining immediately after initialization and by making mempalace mine handle Ctrl‑C with a clean summary + proper exit code, while also ensuring the hooks PID lock file is cleaned up on all exit paths.

Changes:

• Add _maybe_run_mine_after_init() to optionally run mine() in-process after cmd_init, with --yes skipping the prompt.
• Catch KeyboardInterrupt inside miner.mine() to print an interrupt summary and exit with code 130, plus always run PID-file cleanup in finally.
• Add unit tests covering the new prompt behavior, Ctrl‑C summary behavior, and PID-file cleanup semantics; document changes in the changelog.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
mempalace/cli.py	Adds post-init “mine now?” prompt + --yes auto-mine helper.
mempalace/miner.py	Adds Ctrl‑C summary/exit(130) handling and PID-file cleanup in finally.
tests/test_cli.py	Adds tests for the init→mine prompt helper, including --yes, decline, EOF, and failure cases.
tests/test_miner.py	Adds tests for Ctrl‑C summary/exit code and PID-file cleanup behavior.
CHANGELOG.md	Documents the new init prompt and graceful Ctrl‑C behavior.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[bensig]

Reviewed locally on `feat/init-mine-ux`. Approve, no asks. Tight scope, well-tested, backward-compat preserved by deliberate design.

Full pytest: 1247 passed in 48s — +13 from v3.3.3 baseline, mapping to the new test_cli/test_miner cases this PR adds.

Strengths

• Backward-compat flag matrix is the right call. `--yes` stays scoped to entity auto-accept; the new `--auto-mine` flag is the mine-skip toggle. Anyone running `mempalace init --yes ` in a script today gets exactly the same behaviour after this lands. The matrix in the PR body is explicit, and the inline comment in `cmd_init` ("`--yes` is SCOPED to entity auto-accept and does NOT imply mining") makes the design defendable in code review six months from now.
• Single corpus walk. `scan_project`'s output feeds both the user-visible scope estimate AND `mine()` via the new `files=` kwarg. No double-walk. The `mine()` signature change preserves backward-compat (`files=None` falls through to the existing `scan_project` call).
• Footgun mitigation is honest. Scope estimate prints BEFORE the prompt and the comment explicitly names the failure mode ("hitting Enter on a default-Y prompt with no size cue"). `<1 MB` floor on `_format_size_mb` so small projects never see a misleading `0 MB`.
• `EOFError` handling for piped stdin — non-interactive callers get "decline" instead of a `raise EOFError`. Won't block scripts that pipe `init` from somewhere.
• Errors surfaced, not swallowed. Mine failure → `sys.exit(1)` so downstream scripts see the non-zero status.

Ctrl-C handling

This is exactly the right level of mature:

• `try/except KeyboardInterrupt` around the file loop with an inner `try` capturing `last_file` for the summary.
• Outer `except` prints the clean `files_processed: N/M` / `drawers_filed: K` / `last_file: …` block.
• `sys.exit(130)` for standard SIGINT semantics — shells and CI runners read this correctly as user-interrupted.
• `finally` still runs (PID cleanup happens), and the comment explicitly calls out that a second Ctrl-C during the summary print propagates to the default handler. Knowing what you're not trying to catch is half the discipline.
• Resume guidance points at the idempotent re-mine path with deterministic IDs — already-filed drawers upsert to the same row, no duplicates. Honest description of why partial progress is safe to leave in place.

PID-file cleanup

`_cleanup_mine_pid_file` is its own function with a long docstring explaining the cross-session reasoning. The "only remove if the file claims our own PID" check is the part that prevents the bug where a separate concurrent mine gets its lock file yanked. Defensive in exactly the right way.

Minor observations (not blockers)

1. `last_file` is updated inside both the inner exception handler and the post-`process_file` line — slightly redundant, but the comment explains why. Cleaner alternative would be to set `last_file` before `process_file()` so the variable always reflects "the file we attempted last", but the current pattern works.
2. `_format_size_mb` and `_maybe_run_mine_after_init` extracted for unit-testability — exactly the right move and a contrast with the (still-good) PR #1185 where I had to ask for tests. Nothing to do here.

---

Ship it. Same review-quality bar as #1179.