@hanzlaa/rcode 3.6.16 → 4.0.0

package/rihal/workflows/quick.md

@@ -1,208 +0,0 @@
-<purpose>
-Execute small ad-hoc tasks with guarantees. Two real modes the workflow auto-detects:
-
-- **Trivial inline** — single ≤ 3-file change, finishes in 1-2 minutes, no planning needed.
-- **Bulk-task auto-route** — when the input contains many tasks (numbered list with 5+ items, or several distinct bugs/asks), automatically route to /rihal-add-phase with the task list pre-extracted, so the user doesn't have to copy-paste their list a second time.
-
-Closes the gap where /rihal-quick used to refuse + show a 4-option menu when given many tasks (forcing the user to re-enter the same list into another command).
-</purpose>
-
-<required_reading>
-@.rihal/references/verb-dictionary.md
-@.rihal/references/git-preflight.md
-</required_reading>
-
-<process>
-
-<step name="parse_task">
-Parse `$ARGUMENTS` for the task description. If empty, ask:
-
-```
-What's the quick fix? (one sentence — or paste a bug list and I'll auto-route)
-```
-
-Store as `$TASK`.
-</step>
-
-<step name="bulk_detection" priority="first-match">
-**Detect 'many tasks in one input'** — auto-route instead of refusing.
-
-Match if `$TASK` contains ANY of:
-
-- 5+ numbered list items (`/^\s*\d+\.\s/m` with ≥ 5 matches)
-- 5+ bullet items (`/^\s*[-*]\s/m` with ≥ 5 matches)
-- 3+ "Bug Report:" / "Issue:" / "Severity:" headers
-- 3+ separate "Status:" or "Priority:" lines
-- > 60 lines total
-- Contains the phrase "buht zada bugs" / "many bugs" / "list of bugs" / "bug list" / "saare bugs" / "all these bugs"
-
-If matched, **AUTO-ROUTE to `/rihal-add-phase`** without asking. Do not refuse, do not show a menu, do not ask the user to repaste.
-
-Procedure:
-
-1. Detect active milestone (per `do.md` state-aware logic):
-   ```bash
-   ACTIVE_MILESTONE=$(grep -m1 '^## Current Milestone' .planning/PROJECT.md 2>/dev/null | sed 's/^## Current Milestone[: ]*//' | xargs)
-   ```
-2. Generate a phase slug from the bulk content topic:
-   - If most items mention "bug" / "fix" / "broken" → `09-ui-bug-cleanup` (use next phase number)
-   - If most mention "feature" / "add" / "new" → `09-feature-batch`
-   - Otherwise → `09-task-batch`
-3. Print the auto-route banner:
-   ```
-   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    /rihal-quick — AUTO-ROUTING
-   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-   Detected: {N} tasks in input — too many for inline.
-   Active milestone: {ACTIVE_MILESTONE or "none"}
-   Routing to: /rihal-add-phase {phase-slug}
-   Reason: bulk-detection threshold ({matched signal}) — auto-route avoids
-           refusing and forcing you to re-paste the list.
-   ```
-4. Dispatch `/rihal-add-phase {phase-slug}` and pass `$TASK` verbatim. The add-phase workflow uses the pre-extracted task list as the phase task list — no user re-entry needed.
-5. STOP this workflow — add-phase takes over from here.
-
-If the bulk detection does NOT match, continue to scope_check.
-</step>
-
-<step name="scope_check">
-**Lightweight trivial-task gate** for the inline path. Reasonable scope for inline:
-- ≤ 3 file edits
-- ≤ 2 minutes of work
-- No new dependencies or architecture changes
-- No multi-file research needed
-
-If the task seems non-trivial but did NOT trigger bulk_detection above (e.g., a single complex task — not a list), redirect:
-
-```
-This is a single task but looks non-trivial. Recommended:
-  /rihal-add-phase — for multi-file refactor / new feature / structural change
-  /rihal-plan      — when scope is clear, jump straight to a SPRINT.md plan
-
-Or paste --force-inline at the end of your input to override and try inline anyway.
-```
-
-If `$TASK` contains `--force-inline`, skip this gate and continue.
-</step>
-
-<step name="execute_inline">
-Do the work directly:
-
-1. Read the relevant file(s)
-2. Make the change(s)
-3. Verify (run existing tests if applicable, or quick sanity check)
-
-**No SPRINT.md. No subagents. Just do it.**
-</step>
-
-<step name="blocker_handling">
-**When investigation reveals a blocker, do NOT present a multi-option menu.** Pick ONE response per the rules below.
-
-Common blocker types:
-- Need a screenshot / browser-rendered state to confirm
-- Need the dev server running
-- Need a decision the user hasn't given yet
-- Need access to an external system (production logs, Sentry, etc.)
-
-**Rules:**
-
-1. **If the original input was a LIST of tasks** (bulk_detection-eligible OR the user passed multiple tasks): silently SKIP the blocked task, log the blocker in the running tracker, and PIVOT to the next clearly-runnable task in the list. Do not stop. Do not ask. Do not present 5 options.
-
-   Example log line (appended to `.planning/BUG-TRACKER-YYYY-MM-DD.md` if it exists, or stdout otherwise):
-
-   ```
-   ⏸  #36 (Extraction wizard CSS) — skipped: needs runtime screenshot to confirm cascade-layer hypothesis. Will resume when dev server is available.
-   ```
-
-   Then continue with #19 / #17 / whichever is the next-most-runnable in the list. State the pivot in one line:
-
-   ```
-   ▶ Pivoting to next runnable: #19 (Breadcrumb UUID→name) — clear scope, no runtime needed.
-   ```
-
-2. **If the input was a SINGLE task and there's nothing to pivot to**: stop with ONE line stating the single specific blocker and how to unblock it. No menu. No options. The user pastes back the resolved info and re-runs.
-
-   ```
-   ⏸  Blocked on: a screenshot of the broken Extraction wizard. Paste the screenshot or run `pnpm dev` and share what you see — I'll resume from where I left off.
-   ```
-
-3. **If the user passed `--force-inline` AND the input was single-task AND blocked**: attempt the highest-confidence speculative fix, COMMIT it with a clear "speculative — needs runtime verification" prefix in the commit message, and proceed. The user explicitly chose this path.
-
-**Never present a 4+ option menu in blocker_handling.** Multi-option menus during execution are decision-fatigue. Pick one response, do it, move on.
-</step>
-
-<step name="next_task_loop">
-**If the original input was a list and there are remaining tasks after this one** (whether the current task succeeded, failed, or was skipped due to blocker), automatically continue to the next task without asking. State the pivot in one line and re-enter execute_inline.
-
-**Stop the loop only when:**
-- All tasks in the list are processed (done / skipped / blocked)
-- A task touches `> 5` files (escalate the rest of the list to /rihal-add-phase)
-- The user types stop / cancel / pause
-
-At the end of the loop, summarise:
-
-```
-✓ Loop complete: {N} done · {M} skipped · {K} blocked
-   Done:    {bullet list with commit hashes}
-   Skipped: {bullet list with reasons}
-   Blocked: {bullet list with what info is needed}
-
-Resume blocked tasks: {one-line guidance on what to provide and re-run}
-```
-</step>
-
-<step name="commit">
-Commit atomically with conventional commit format (`fix:`, `feat:`, `docs:`, `chore:`, `refactor:`):
-
-```bash
-git add -A
-git commit -m "{type}: {concise description of what changed}"
-```
-</step>
-
-<step name="log_to_state">
-Append the completed task to `.planning/STATE.md`. Create the section if it
-doesn't exist — projects initialized with `/rihal-new-project` use a STATE.md
-shape that has no "Quick Tasks Completed" table by default (#601). Without
-this fallback the entry was silently dropped on every fresh repo.
-
-```bash
-mkdir -p .planning
-if [ ! -f .planning/STATE.md ]; then
-  printf '# Project State\n\n## Quick Tasks Completed\n\n| Date | Type | Task | Status |\n|------|------|------|--------|\n' > .planning/STATE.md
-elif ! grep -q "Quick Tasks Completed" .planning/STATE.md 2>/dev/null; then
-  printf '\n## Quick Tasks Completed\n\n| Date | Type | Task | Status |\n|------|------|------|--------|\n' >> .planning/STATE.md
-fi
-echo "| $(date +%Y-%m-%d) | quick | $TASK | ✓ |" >> .planning/STATE.md
-```
-</step>
-
-<step name="done">
-Report completion:
-
-```
-✓ Done: {what was changed}
-   Commit: {short hash}
-   Files:  {list of changed files}
-```
-
-No next-step suggestions. No workflow routing. Just done.
-</step>
-
-</process>
-
-<guardrails>
-- NEVER spawn a Task/subagent — this runs inline (except via the add-phase auto-route, which is itself a workflow dispatch, not a Task spawn)
-- NEVER create SPRINT.md or SUMMARY.md files directly (add-phase will, when bulk-routed)
-- NEVER run research or plan-checking inline
-- If bulk_detection matches, auto-route silently — do not stop and ask
-- If a single non-bulk task exceeds 3 file edits and the user did NOT pass `--force-inline`, redirect to /rihal-add-phase or /rihal-plan
-</guardrails>
-
-<success_criteria>
-- [ ] Bulk inputs are auto-routed to /rihal-add-phase without forcing the user to re-paste
-- [ ] Trivial inputs are completed inline (single context, ≤3 files, conventional commit)
-- [ ] STATE.md updated if it exists
-- [ ] No self-referential redirects (the old quick.md redirected to /rihal-quick — that infinite loop is closed)
-</success_criteria>

package/rihal/workflows/remove-phase.md

@@ -1,160 +0,0 @@
-<purpose>
-Remove an unstarted future phase from the project roadmap, delete its directory, renumber all subsequent phases to maintain a clean linear sequence, and commit the change. The git commit serves as the historical record of removal.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
-<process>
-
-<step name="parse_arguments">
-Parse the command arguments:
-- Argument is the phase number to remove (integer or decimal)
-- Example: `/rihal-remove-phase 17` → phase = 17
-- Example: `/rihal-remove-phase 16.1` → phase = 16.1
-
-If no argument provided:
-
-```
-ERROR: Phase number required
-Usage: /rihal-remove-phase <phase-number>
-Example: /rihal-remove-phase 17
-```
-
-Exit.
-</step>
-
-<step name="init_context">
-Load phase operation context:
-
-```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${target}" 2>/dev/null)
-if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-```
-
-If `INIT` is empty or `INIT.ok` is false, print error and exit:
-```
-Error: rihal-tools init failed. Verify .rihal/ is installed and state.json is valid.
-```
-
-Extract: `phase_found`, `phase_dir`, `phase_number`, `commit_docs`, `roadmap_exists`.
-
-Also read STATE.md and ROADMAP.md content for parsing current position.
-</step>
-
-<step name="validate_future_phase">
-Verify the phase is a future phase (not started):
-
-1. Compare target phase to current phase from STATE.md
-2. Target must be > current phase number
-
-If target <= current phase:
-
-```
-ERROR: Cannot remove Phase {target}
-
-Only future phases can be removed:
-- Current phase: {current}
-- Phase {target} is current or completed
-
-To abandon current work, use /rihal-pause-work instead.
-```
-
-Exit.
-</step>
-
-<step name="confirm_removal">
-Present removal summary and confirm:
-
-```
-Removing Phase {target}: {Name}
-
-This will:
-- Delete: .planning/phases/{target}-{slug}/
-- Renumber all subsequent phases
-- Update: ROADMAP.md, STATE.md
-
-Proceed? (y/n)
-```
-
-Wait for confirmation.
-</step>
-
-<step name="execute_removal">
-**Delegate the entire removal operation to rihal-tools:**
-
-```bash
-RESULT=$(node ".rihal/bin/rihal-tools.cjs" phase remove "${target}")
-```
-
-If the phase has executed plans (SUMMARY.md files), rihal-tools will error. Use `--force` only if the user confirms:
-
-```bash
-RESULT=$(node ".rihal/bin/rihal-tools.cjs" phase remove "${target}" --force)
-```
-
-The CLI handles:
-- Deleting the phase directory
-- Renumbering all subsequent directories (in reverse order to avoid conflicts)
-- Renaming all files inside renumbered directories (SPRINT.md, SUMMARY.md, etc.)
-- Updating ROADMAP.md (removing section, renumbering all phase references, updating dependencies)
-- Updating STATE.md (decrementing phase count)
-
-Extract from result: `removed`, `directory_deleted`, `renamed_directories`, `renamed_files`, `roadmap_updated`, `state_updated`.
-</step>
-
-<step name="commit">
-Stage and commit the removal:
-
-```bash
-node ".rihal/bin/rihal-tools.cjs" commit "chore: remove phase {target} ({original-phase-name})" --files .planning/
-```
-
-The commit message preserves the historical record of what was removed.
-</step>
-
-<step name="completion">
-Present completion summary:
-
-```
-Phase {target} ({original-name}) removed.
-
-Changes:
-- Deleted: .planning/phases/{target}-{slug}/
-- Renumbered: {N} directories and {M} files
-- Updated: ROADMAP.md, STATE.md
-- Committed: chore: remove phase {target} ({original-name})
-
----
-
-## What's Next
-
-Would you like to:
-- `/rihal-progress` — see updated roadmap status
-- Continue with current phase
-- Review roadmap
-
----
-```
-</step>
-
-</process>
-
-<anti_patterns>
-
-- Don't remove completed phases (have SUMMARY.md files) without --force
-- Don't remove current or past phases
-- Don't manually renumber — use `rihal-tools phase remove` which handles all renumbering
-- Don't add "removed phase" notes to STATE.md — git commit is the record
-- Don't modify completed phase directories
-</anti_patterns>
-
-<success_criteria>
-Phase removal is complete when:
-
-- [ ] Target phase validated as future/unstarted
-- [ ] `rihal-tools phase remove` executed successfully
-- [ ] Changes committed with descriptive message
-- [ ] User informed of changes
-</success_criteria>

package/rihal/workflows/remove-workspace.md

@@ -1,164 +0,0 @@
-# Workflow: rihal-remove-workspace
-
-<purpose>
-Remove a workspace and clean up all its artifacts. This is destructive — deleted workspaces cannot be recovered unless `--archive` flag is used. Use when a parallel work stream is complete or abandoned.
-</purpose>
-
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or only `--help` or `-h`:
-
-```
-/rihal-remove-workspace <workspace-name> [--archive] [--force]
-```
-
-**Examples:**
-```
-/rihal-remove-workspace Bug Fix Sprint
-/rihal-remove-workspace Emergency --force
-/rihal-remove-workspace Old Work --archive
-```
-
-STOP — do not proceed.
-
-## Step 1 — Parse arguments
-
-Extract from `$ARGUMENTS`:
-- `$WORKSPACE_NAME` — the workspace to remove
-- `--archive` flag → copy to `.rihal/workspace-archive/` before deleting
-- `--force` flag → skip confirmation prompt
-
-If `$WORKSPACE_NAME` is empty, ask:
-
-```
-AskUserQuestion(
-  header: "Remove Workspace",
-  question: "Which workspace? (list: /rihal-list-workspaces)"
-)
-```
-
-## Step 2 — Locate workspace
-
-Read `.rihal/workspaces.csv` and find the row matching `$WORKSPACE_NAME`.
-
-Extract `$WORKSPACE_PATH` from the CSV row.
-
-If not found:
-
-```
-⚠ Workspace not found: {WORKSPACE_NAME}
-  List workspaces: /rihal-list-workspaces
-```
-
-STOP.
-
-Verify the directory exists:
-
-```bash
-if [[ ! -d "$WORKSPACE_PATH" ]]; then
-  echo "⚠ Workspace directory not found: $WORKSPACE_PATH"
-  exit 1
-fi
-```
-
-## Step 3 — Confirm deletion (unless --force)
-
-If NOT `--force` flag:
-
-```
-About to delete workspace: {WORKSPACE_NAME}
-  Location: {WORKSPACE_PATH}
-  
-This cannot be undone. Continue? (y/N)
-
-AskUserQuestion(
-  header: "Confirm Deletion",
-  question: "Delete {WORKSPACE_NAME}?"
-)
-```
-
-If user says no, STOP.
-
-## Step 4 — Archive workspace (if requested)
-
-If `--archive` flag:
-
-```bash
-ARCHIVE_BASE=".rihal/workspace-archive"
-mkdir -p "$ARCHIVE_BASE"
-ARCHIVE_PATH="$ARCHIVE_BASE/$(basename $WORKSPACE_PATH)-$(date +%s)"
-cp -r "$WORKSPACE_PATH" "$ARCHIVE_PATH"
-echo "✓ Workspace archived: $ARCHIVE_PATH"
-```
-
-## Step 5 — Delete workspace directory
-
-```bash
-PROJECT_ROOT="$(pwd)"
-REAL_WS="$(realpath "$WORKSPACE_PATH" 2>/dev/null || echo "")"
-if [[ -z "$REAL_WS" || "$REAL_WS" != "$PROJECT_ROOT"/* ]]; then
-  echo "⚠ SECURITY: workspace path '$WORKSPACE_PATH' escapes project root — aborting"
-  exit 1
-fi
-rm -rf "$WORKSPACE_PATH"
-```
-
-Verify deletion:
-
-```bash
-if [[ ! -d "$WORKSPACE_PATH" ]]; then
-  echo "✓ Workspace deleted"
-else
-  echo "⚠ Failed to delete workspace. Check permissions."
-  exit 1
-fi
-```
-
-## Step 6 — Update workspaces registry
-
-Remove the row from `.rihal/workspaces.csv`:
-
-```bash
-grep -v "^$WORKSPACE_NAME," ".rihal/workspaces.csv" > ".rihal/workspaces.csv.tmp"
-mv ".rihal/workspaces.csv.tmp" ".rihal/workspaces.csv"
-```
-
-## Step 7 — Report
-
-Print:
-
-```
-✓ Workspace removed: {WORKSPACE_NAME}
-  [Archive location: {ARCHIVE_PATH}] (if --archive)
-  
-Remaining workspaces: {count}
-List: /rihal-list-workspaces
-```
-
-## Success Criteria
-
-- Workspace directory deleted
-- Workspace removed from registry (workspaces.csv)
-- If --archive: backed up to archive location
-- User sees confirmation message
-
-## On Error
-
-If directory deletion fails:
-
-```
-⚠ Failed to delete workspace directory. Check:
-  - File permissions
-  - Open file handles
-  - Disk space
-  
-Path: {WORKSPACE_PATH}
-```
-
-If registry update fails:
-
-```
-⚠ Failed to update workspace registry. Manual cleanup:
-  rm -rf {WORKSPACE_PATH}
-  Edit: .rihal/workspaces.csv (remove the {WORKSPACE_NAME} line)
-```

package/rihal/workflows/replay.md

@@ -1,160 +0,0 @@
-# Workflow: rihal-replay
-
-<purpose>
-Re-run a past council session with the same question for a fresh panel round. Useful when:
-
-- The first council was inconclusive and you want a second pass
-- Facts or context have shifted and the original question deserves re-evaluation
-- You want to see how a different panel composition answers the same question
-
-This is NOT `--resume` (which asks a follow-up question with prior context). Replay re-asks the original question from a clean slate, then links the new artifact back to the original for comparison.
-</purpose>
-
-<output_format>
-Open with banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► REPLAY
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-End with a single-line redirect (per `command-redirect-format.md`) so the user copy-pastes the resulting `/rihal-council` invocation.
-</output_format>
-
-<required_reading>
-@.rihal/references/command-redirect-format.md
-@.rihal/references/output-format.md
-</required_reading>
-
-<process>
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains only `--help` / `-h`:
-
-```
-/rihal-replay <session-path-or-slug> [--agents a,b,c]
-
-  <session-path-or-slug>   Full path to .planning/council-sessions/council-YYYY-MM-DD-<slug>.md
-                           OR just the slug (e.g. "should-i-ship-v2") — the first matching
-                           file, newest-first, will be used.
-  --agents a,b,c           Override the panel for the replay (otherwise council auto-selects)
-```
-
-STOP — do not proceed.
-
-## Step 1 — Resolve the session file
-
-Parse `$ARGUMENTS` — first positional token is the session identifier, remaining tokens pass through.
-
-```bash
-SESSIONS_DIR=".planning/council-sessions"
-ARG="${1}"
-
-# Full path: use as-is
-if [ -f "$ARG" ]; then
-  SESSION_FILE="$ARG"
-# Slug: find newest matching file
-elif ls "${SESSIONS_DIR}" >/dev/null 2>&1; then
-  SESSION_FILE=$(ls -t "${SESSIONS_DIR}"/council-*"${ARG}"*.md 2>/dev/null | head -1)
-fi
-
-if [ -z "$SESSION_FILE" ] || [ ! -f "$SESSION_FILE" ]; then
-  echo "No session matched \"$ARG\". Available:"
-  ls -t "${SESSIONS_DIR}"/council-*.md 2>/dev/null | head -10
-  exit 0
-fi
-```
-
-If no sessions directory exists at all:
-
-```
-No council sessions on disk yet. Run /rihal-council "<question>" to create the first one.
-```
-
-STOP.
-
-## Step 2 — Extract the original question
-
-Read `SESSION_FILE` and pull the text block under the `## Question` heading (until the next `##` heading or EOF). Trim leading/trailing whitespace. Strip surrounding blank lines.
-
-```bash
-QUESTION=$(awk '/^## Question$/{flag=1;next} /^## /{flag=0} flag' "$SESSION_FILE" | sed '/./,$!d' | awk 'NF{found=1} found')
-```
-
-If the extracted question is empty:
-
-```
-Could not extract "## Question" heading from $SESSION_FILE. The artifact may be malformed. Open it and copy the question manually:
-
-/rihal-council <question>
-```
-
-STOP.
-
-Also capture the original slug for the replay annotation:
-
-```bash
-ORIGINAL_SLUG=$(basename "$SESSION_FILE" .md | sed 's/^council-[0-9-]*-//')
-ORIGINAL_DATE=$(basename "$SESSION_FILE" .md | grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}' | head -1)
-```
-
-## Step 3 — Show the replay preview
-
-Print a short summary so the user can confirm before the redirect:
-
-```
-Replaying session: {SESSION_FILE}
-Original date:    {ORIGINAL_DATE}
-Original slug:    {ORIGINAL_SLUG}
-
-Question to re-ask:
-  {QUESTION}
-```
-
-If `--agents` was passed, also print:
-```
-Panel override:   {agents_csv}
-```
-
-## Step 4 — Emit the redirect
-
-Per `command-redirect-format.md`, one line, copy-pastable:
-
-```
-Re-running the council with a fresh panel on the original question.
-
-Copy-paste this:
-
-/rihal-council {QUESTION}{agents_suffix}
-```
-
-Where `{agents_suffix}` is `  --agents=a,b,c` if `--agents` was passed, else empty.
-
-## Step 5 — Record the replay intent
-
-Append a lightweight replay record so history is traceable even before council runs:
-
-```bash
-node .rihal/bin/rihal-tools.cjs state add-decision \
-  "Replay of council session ${ORIGINAL_SLUG} (${ORIGINAL_DATE}) — re-asking: ${QUESTION:0:80}" \
-  2>/dev/null || true
-```
-
-The subsequent `/rihal-council` run will attach its own artifact; pairing the two by date + slug lets `/rihal-decisions` and state readers show the replay chain.
-</process>
-
-## Success Criteria
-
-- Slug argument resolves to the newest matching session file
-- Full path argument works as-is
-- `## Question` text is extracted verbatim, including any multi-line body
-- Malformed or empty question artifacts produce a clear error (not a crash)
-- Redirect is a single line, in the copy-paste format required by the command-redirect reference
-- `--agents` override passes through to the council invocation unchanged
-
-## On Error
-
-- Missing session directory → tell the user to run `/rihal-council` first
-- Slug ambiguity → list the top 10 newest matches so the user can paste a fuller path
-- Extraction returns empty → print the path and ask the user to copy the question manually