@c4a/context-cli 0.6.1 → 0.6.2

package/plugins/claude/skills/skill-source-scope/references/capture-source.md

@@ -1,201 +0,0 @@
----
-name: capture-source
-description: >
-  Capture local Markdown or Lark/Feishu document sources through registered
-  Context sources and declared capture phases. Use the local `context` CLI for
-  workspace writes.
-tools:
-  - Bash
----
-
-# Capture
-
-Current capture discipline for document sources. The executable path is source
-registration plus the declared capture phase flow:
-
-- local Markdown/MDX file source: `context source add file [YYYYMMDD] --module <module> --local <path>`
-  followed by `context run capture:file:YYYYMMDD/<module> --format json`;
-- Lark/Feishu source: `context source add lark [YYYYMMDD] --module <module> ...`
-  followed by `context run capture:lark:YYYYMMDD/<module> --format json`;
-- refresh: rerun the same declared capture phase after status or the user asks
-  for recapture.
-
-Use only commands surfaced by the current status output or capture phase.
-For a user-confirmed multi-document batch, `context status --format json`
-returns every uncaptured module in `routing.command_plan`. Run the complete
-list in order; a successful module is omitted from the next status result.
-When the user explicitly asks to capture, ingest, fetch, read, or include exact
-file/Lark paths or URLs, that request is the read permission for those sources;
-do not repeat the question after registration. A mere mention, possible-source
-discussion, or register-only request is not permission, and an explicit refusal
-always wins.
-Register several file/Lark/repo sources with `context source add batch [date]
---input <yaml|json|->`; do not launch multiple `source add` processes in
-parallel. Repo batch items require `module`; file/Lark items may omit it and use
-the module returned by the CLI. A write-lock error means another Context mutation is active: wait for
-it to finish and retry rather than editing registry files.
-
----
-
-## Workflow
-
-Capture is entirely CLI-driven — your role is to register the right source,
-declare the matching capture phase, run the current `context run capture:*`
-command, and relay its output. Never hand-write captured source snapshots: the
-CLI owns normalisation (NFC, BOM strip, line endings) and the `content_hash`
-contract, so any manual edit breaks idempotency.
-
-### Code capture diagnostics
-
-Do not run hand-written dependency preflight commands before code extraction or
-document capture. The CLI owns configured runner/plugin resolution and returns
-structured `agent_hints[]` when a runner or remote-document helper is missing or
-misconfigured.
-
-If code extraction capture fails with install or runner hints, surface the CLI's `agent_hints[]` command exactly as printed. Ask the user once whether to run that command on their behalf when it touches shared state. If approved, run the exact command from `agent_hints[0].command`, then retry the same capture command. If declined, leave the command visible so the user can run it manually. Do not inline extraction packages, do not hand-write code snapshots, and do not continue with partial capture.
-
-Invocation note: document capture and code extraction do not run through `npx`.
-Use the installed `context` CLI and the declared phase command returned by
-`context status` or the phase view. When external helpers are missing, surface
-the CLI's structured install hints instead of substituting your own package
-manager or version.
-
-### Route by source boundary
-
-Before choosing a local Markdown capture route, honor the surrounding task context. Driver documents such as run instructions, handbooks, READMEs, plans, feedback issues, corpus/index/manifests, and batch lists are not Context sources unless the user explicitly asks to ingest them. Capture only ingest targets that are already explicit in the user request; if they are missing, ask one clarification instead of capturing the driver document.
-
-- One or more local `.md` / `.mdx` files or a local documentation folder to ingest →
-  register one file source with the user-confirmed boundary:
-  `context source add file [YYYYMMDD] --module <module> --local <file-or-folder>`.
-  The CLI returns the `YYYYMMDD/module` identity to use in project phases. More
-  than one file module may share the date. For an explicit
-  batch inside a broader folder, preserve the user's include list on source
-  registration. Default file capture handles `.md`. If the CLI reports
-  document-site files such as `.mdx`, `_meta.json`, sidebars, or docs config,
-  stop and confirm whether the selected boundary is a documentation site before
-  changing capture configuration. For MDX documentation sites that use
-  `_meta.json`, declare `mdxJsonDocs()` on `captureFile` in `src/index.ts`;
-  keep `_meta.json` only when it is route metadata for the selected document
-  folder. The CLI captures it as metadata and generates
-  `__context_route_metadata.md` as mechanical route evidence; it also extracts
-  static MDX component props/children into `__context_mdx_component_text.md`
-  when components carry user-facing text. Declare
-  `captureFile({ source: source("<date>", "<module>", { type: "file" }), processor: mdxJsonDocs() })`, then
-  run `context run capture:file:<date>/<module> --format json`. If the selected MDX page
-  is empty or only mounts runtime-rendered content, tell the user that capture
-  found a document-site shell and ask for the rendered-site or data-source
-  boundary instead of inventing body text.
-- A Lark/Feishu URL, doc token, or wiki token → register one Lark source:
-  `context source add lark [YYYYMMDD] --module <module> --url <url>` or the
-  matching token flag. Register every requested document under the same date;
-  do not ask for `YYYYMMDD-2`. Declare
-  `captureLark({ source: source("<date>", "<module>", { type: "lark" }) })`,
-  then run `context run capture:lark:<date>/<module> --format json`.
-- Mixed local document and Lark document batches are separate sources unless
-  the current CLI explicitly offers a combined source contract. Do not write an
-  Agent-side URL/file loop.
-- Refresh or recapture request for an already registered file/Lark source →
-  rerun the same declared capture phase. The CLI appends a new snapshot only
-  when content changes and never overwrites prior snapshots.
-- Code package extraction is not document capture. Route code source selection
-  through `skill-source-scope` extraction preview and the declared extract
-  phase. Do not invent a document capture path for code.
-- Conversation notes, decisions, and revision intents are not document capture
-  sources in the current workflow unless the CLI status or project-specific
-  phase exposes an explicit note source contract. If absent, record the user
-  guidance in the conversation and use it as pre-align hints, not as a snapshot
-  write.
-
-Do not discover files with `find` / `ls` when the user already supplied paths.
-If the include set is large, summarize it and ask for confirmation before
-registration; do not read file bodies before capture permission is clear.
-
-### Output Handling
-
-Report the CLI output verbatim. If the CLI reports `N sources changed`, suggest the right next step:
-
-- Run `context status --format json` and use its `state`, `routing`, and
-  `command_plan`; if status returns `needs-capture-phase`, first perform the
-  exact `routing.configuration` edit and rerun status.
-- While status remains `needs-capture`, execute every returned capture command
-  for the already confirmed batch before asking another naming, collection, or
-  read-permission question.
-- If status reports `captured-ready-to-investigate`, suggest the returned
-  `context run align:<type>:<source>:<collection> --view read-plan --format json`
-  command and hand off to `skill-prose-align`.
-- If status reports `needs-structure` or `structure-ready`, follow the returned
-  align/compile command instead of naming a generic slash command.
-- If status reports `compile-ready-for-review`, route to the review gate.
-- If the source was code-only and status reports pending code projection,
-  follow the CLI-owned extract/compile route returned by status.
-
-Never suggest prose compile or hand-built document knowledge for a code-only
-source. Code sources become active knowledge only through the declared
-extraction/review route returned by `context status`.
-
-If capture is rejected because another phase or write gate is active, do not
-discard it automatically. Explain the active state from `context status`, follow
-that phase when it is the intended task, and ask the user before discarding
-in-progress work when a current project command exists. If the user expected a
-different repository/workspace, change to the confirmed workspace root before
-retrying capture.
-
-## Final Report
-
-Report in the user's conversation language. Translate section headings into the user's language instead of copying the English labels below verbatim. Optimize for human readability: use document titles instead of source ids, package names instead of internal source id strings, and human-readable kind labels ("local markdown", "Feishu doc", "code package") instead of internal tokens. Do not surface content hashes, snapshot digests, internal payload identifiers, or absolute file paths.
-
-Stable structure:
-
-1. Completion headline. Single line with the action verb plus core counts: how
-   many sources were captured this round, broken down by `new` / `updated` /
-   `unchanged`. Capture data from the current `context run capture:* --format
-   json` result summary, or per-source statuses when no aggregate is returned.
-2. Per-source list grouped by status. Show each captured source under one of three groups (`new` / `updated` / `unchanged`); within each group list the document title (`source.title`), kind label, and a short delta indicator for updated sources (for example added/removed line counts when the CLI returns them; otherwise "content changed"). Cache-hit code packages belong in `unchanged`. Omit groups that are empty.
-3. Pending phase signals. When `context status --format json` reports follow-up
-   work tied to this capture (sources pending align, sources pending compile,
-   refreshed sources pending recompile, code sources pending projection),
-   summarize each as a single line naming the work and which sources are
-   affected. Omit the section entirely when there is no pending follow-up.
-4. Next step. Single command suggestion driven by status: the returned
-   `context run align:<type>:<source>:<collection> ...` command when structure work is
-   pending, the returned `context run compile:<type>:<source>:<collection> ...`
-   command when prose compile work is pending, or the CLI-owned code projection
-   command when code projection is pending. If nothing is pending, say so
-   explicitly.
-
-Do not include raw CLI diagnostics, agent_hints content, schema names, or phase
-payload identifiers in the report. Those belong in earlier troubleshooting
-output, not in the completion summary.
-
-## Reference
-
-### Missing Dependency Recovery
-
-If the CLI returns `agent_hints[]` for a missing code runner or plugin package, stop and surface the hint. Ask the user once for permission to run `agent_hints[0].command` (the CLI has already picked the correct package manager — `npm install -g` or `bun install -g` — based on how `context` itself was installed). If approved, run that exact command via `Bash` and then retry the same capture; if declined, leave the command visible for manual install. Never substitute a different package manager or version.
-
-If the CLI prints a missing-dependency error like `lark-cli not installed`, walk the user through installation:
-
-1. Ask once up-front whether to proceed with install. If no → stop and tell the user to install manually from the tool's official README, then re-run.
-2. `WebFetch` the tool's official README (for `lark-cli` that's `https://github.com/larksuite/cli/blob/main/README.md#quick-start-ai-agent`).
-3. For each command the README prescribes for the user's platform, show the command then call `Bash`. The host's per-tool permission prompt is the user's confirmation surface; don't add extra y/n questions between commands.
-4. Stop on any failure; surface stderr verbatim.
-5. After success, tell the user to rerun the current Context command that
-   failed.
-
-### Language Policy
-
-Your prose to the user follows the user's conversation language. CLI commands, flag names, URLs, env-var names, binary names, source-ids stay English.
-
-### Invariants
-
-- Captured source snapshots are immutable post-write — the CLI only ever appends new snapshots.
-- The source registry is authoritative; derived index files are not Agent phase
-  inputs.
-- Local `.md` / `.mdx` source identity follows the captured file's stable origin path, not its H1/title. If the user edits the title but captures the same path again, the CLI appends a new snapshot to the same `local:*` source.
-- In `--format json`, code capture runner cache state is authoritative in `result.runner.cacheMode`: `prepared` means a workspace runner was prepared, `cached` means workspace cache hit, and `bypass` means `--no-runner-cache` used a temporary runner directory instead of the workspace runner cache.
-- Code extraction runner evidence is derived by the CLI from emitted source files. Do not ask users to configure `evidence.mode`; rerun capture after fixing the runner emit output.
-- Code extraction snapshots ship with `evidence.mode: none`; symbols/files/edges are indexed inside the code bucket. Do not ask users to inspect or repair a code `.evidence` manifest.
-- Code extraction/projection is separate from document capture. Materialize code
-  knowledge through the declared extract/code projection flow before prose align
-  attaches documentation to code Nodes.
-- On duplicate capture of the same URL: identical `content_hash` → CLI skips with `unchanged`; different hash → CLI appends a new snapshot.

package/plugins/codex/skills/continue/references/internal-procedures/skill-continue-workflow.md

@@ -1,235 +0,0 @@
----
-name: skill-continue-workflow
-description: >
-  Internal procedure invoked by the public Context continuation entry; not a user slash command.
-  Runs the status-driven Context process, executes safe mechanical next steps,
-  and delegates human gates to source, review, and package procedures.
-tools:
-  - Bash
----
-
-# skill-continue-workflow
-
-Continue an existing Context workspace from its current state.
-
-## TL;DR
-
-- Use this only inside an initialized Context workspace. If the user is starting
-  a new knowledge workspace or a new batch from a raw project/repo root, do not
-  run `context status` first; use the init workflow and complete setup before
-  returning here.
-- If `context status` reports `workspace-not-found` with a configured
-  `context.workspaceDir`, stop. If the directory exists, enter it and rerun
-  status. If it does not exist, ask whether to initialize it through the init
-  workflow; do not treat the host repository root as the workspace.
-- There is no `context continue` CLI command. Start with `context status`.
-- `context status` and CLI diagnostics are the source of truth.
-- If the user explicitly authorizes fully managed operation in the current
-  conversation, start and continue that loop with `context status --managed
-  --format json`, then execute its managed `command_plan`. This authority is
-  conversation-only: do not write it into `defineProject`, project files, or
-  reuse it in a later conversation.
-- Inspect `declarationGraph` and `configurationGaps`. Before structure
-  confirmation they are configuration warnings; after confirmation, a missing
-  compile route is a hard gate. Never substitute a compile phase from another
-  collection.
-- Treat `unclassifiedDocumentTargets`, `pendingStructureTargets`, and nonterminal
-  `structureBatch.slots` as unfinished workspace work even when the
-  current approved package is ready. A build closes only the active snapshots;
-  it does not prevent a later captured source from entering its own structure
-  round.
-- Confirm structure per canonical source + collection slot, but batch Review
-  across the declared round. When candidates exist and
-  `pendingStructureTargets` is non-empty, follow the pending align route before
-  opening Review; deterministic close later merges every active slot.
-- Execute safe mechanical `next:` steps; stop at semantic choices and human
-  gates.
-- Delegate source/scope decisions to
-  `skill-source-scope.md`.
-- Delegate review to `skill-review-gate.md`.
-- Delegate package output choices to
-  `skill-package-output.md`.
-- Delegate document investigation and structure confirmation to
-  `skill-prose-align.md`.
-- Delegate source-bound prose compile requests to
-  `skill-prose-compile.md`.
-- Do not inspect `.tmp`, `unapproved/`, `knowledge/`, `dist/`, or
-  `node_modules/@c4a/context/dist` with ad hoc scripts to decide project state.
-- Only run commands surfaced by the current status route, current phase view,
-  review gate, verify/build gate, or package guidance. Do not invent alternate
-  lifecycle commands from memory.
-
-<reference>
-
-## Safe Mechanical Commands
-
-These can run when already implied by current status and no placeholder/human
-choice remains:
-
-| State / hint | Allowed action |
-|---|---|
-| source already declared | `context source ensure`, `context source list`, `context source get` |
-| declared phase that does not read new source body or require a semantic choice | `context run <phase-id>` |
-| prose align evidence read | `context run align:<type>:<source>:<collection> --view <view>` |
-| prose structure validation | `context run align:<type>:<source>:<collection> --validate --input <structure.yaml>` |
-| prose compile evidence read | `context run compile:<type>:<source>:<collection> --view <view>` |
-| prose compile action validation | `context run compile:<type>:<source>:<collection> --validate --input <compile-actions.yaml>` |
-| copied review payload supplied by user | `context review apply <payload-file>` |
-| close required after review | `context close --format json` |
-| package already declared and close is clean | `context build` |
-| validation requested | `context verify` |
-
-Capture phases are not safe mechanical commands by default. `capture:file:*`
-and `capture:lark:*` read local or remote source bodies and update committed
-snapshots, so they require the source read-permission gate unless the current
-turn already contains explicit user confirmation for that exact source.
-An explicit request to capture, ingest, fetch, read, or include the exact
-file/Lark path or URL is that confirmation; do not ask again after registration.
-Mere mention, source discussion, or a register-only request is not confirmation,
-and an explicit refusal always overrides inferred permission.
-
-## Human Gates
-
-In ordinary mode, follow every gate below. In explicit current-conversation
-managed mode, the CLI may resolve classification, extraction scope, structure
-confirmation, Review, and package-output choices without pausing. It still
-must not infer a source boundary, read an unapproved source body, perform an
-external repository/system operation, or bypass validation/verify errors.
-
-Stop and ask, or wait for user input, for:
-
-- `Human gate:` in CLI output.
-- placeholders such as `<name>`, `<repo-or-subdir>`, `<phase-id>`, `<collection>`.
-- missing source selection.
-- source boundary/name decisions, because they affect `knowledge/` paths and
-  `source_ref` prefixes.
-- source repo operations: clone, checkout, reset, fetch, install, build, test.
-- source scope, package/subdirectory, symbol group, or glob choices.
-- file/Lark capture or refresh, including capture preview, until the user has
-  confirmed which local path or remote document may be read.
-- review approval/rejection decisions.
-- document structure confirmation, section ownership, edge confirmation,
-  rewrite intent, conflict, weak-evidence, or cross-document organization
-  choices unless they are being handled through prose align/compile evidence
-  views and validation.
-- package output type or template choices.
-
-When a human gate has a fixed small option set, use the host's native
-multi-choice tool when available (Claude Code `AskUserQuestion`, Codex's
-available native user-input tool such as `request_user_input` when exposed,
-Cursor Plan Mode `AskQuestion`). If unavailable, fall back to Markdown `A/B/C`
-choices. Each option must include the effect of choosing it.
-
-</reference>
-
-<procedures>
-
-### Step 0 — Confirm Workspace Exists
-
-If the current task is to create a new Context workspace, or the user has not
-identified an initialized Context workspace root for this turn, do not continue
-with this workflow. Initialize through the public Context init entry or
-`context init` first, run the setup command printed by init, then return to this workflow from the
-created workspace.
-
-### Step 1 — Read Status
-
-Run:
-
-```bash
-context status
-```
-
-Use `context status --managed --format json` instead only when the current
-conversation explicitly contains fully managed authorization. Keep `--managed`
-on commands returned by that status loop; otherwise never add it.
-
-Use the output as evidence. Explain status and next step in the user's language;
-do not forward a long raw transcript unless requested.
-
-### Step 2 — Route The State
-
-1. If status says `missing-source`, `needs-capture-phase`, `needs-capture`,
-   `needs-extract-phase`, or `ready-to-extract`,
-   source boundary/name is unclear, source scope is unclear, or an extract
-   phase needs first-run scope confirmation, follow
-   `skill-source-scope.md`.
-   When `routing.configuration` is present, make only that declared project
-   configuration change and rerun status. Otherwise follow
-   `routing.command_plan`: run `immediate` items directly and wait for current-
-   conversation confirmation before `after-human-confirmation` items.
-   For mixed sources, status intentionally returns `ready-to-extract` before
-   `captured-ready-to-investigate` while all document snapshots are captured,
-   document structure is untouched, and code extraction is missing, pending,
-   or stale. Explain that code is processed first, then follow the exact
-   extraction preview/rerun command.
-2. If status says `captured-ready-to-classify`, run every immediate
-   collection-neutral investigation command, summarize evidence across all
-   targets, and ask the user to confirm the proposed mainline collection(s)
-   before editing `src/index.ts`. If status says `needs-prose-configuration`, apply only the generic
-   `routing.configuration` change in `src/index.ts`, rerun status, and do not
-   create a new workspace. If status says `captured-ready-to-investigate` or `needs-structure`, or the
-   user asks to split, merge, classify, relate, or semantically organize
-   document evidence before draft pages exist, follow
-   `skill-prose-align.md`.
-3. If status says `needs-prose-compile` or `structure-ready`, or the user asks
-   to turn confirmed structure into source-bound draft pages, follow
-   `skill-prose-compile.md`.
-4. If the latest phase result has `next_action.human_gate=false`, follow its
-   command and do not invent a Review gate. This includes
-   `continue_compile_batch` and `continue-codegraph-batch`: finish the whole
-   prepared round first. If status says
-   `compile-ready-for-review`, or the latest result has
-   `next_action.human_gate=true`, follow
-   `skill-review-gate.md`.
-5. If status says `compile-close-needed`, run `context close --format json`
-   unless CLI diagnostics require human repair, then return to **Step 1**.
-6. If status says `ready-to-build`, `built`, `needs-package-output`, or approved knowledge exists but
-   package output is not chosen or declared,
-   follow `skill-package-output.md`.
-   `built` is terminal only when both `unclassifiedDocumentTargets` and
-   `pendingStructureTargets` are empty. Use `structureBatch` for the complete
-   multi-source round: evidence Views are parallel-safe; stage, confirm, Review
-   apply, and close mutations are serial.
-7. If the next command is safe per [Safe Mechanical Commands](#safe-mechanical-commands),
-   run it and return to **Step 1**.
-8. If the next command crosses a [Human Gate](#human-gates), ask or wait; do not
-   guess.
-
-### Step 3 — Execute Safely
-
-Before editing `src/index.ts` or package templates, read:
-
-```text
-node_modules/@c4a/context/docs/guides/agent-guide.md
-node_modules/@c4a/context/docs/guides/package-outputs.md
-node_modules/@c4a/context/docs/reference/project-api.md
-node_modules/@c4a/context/docs/reference/package-templates.md
-```
-
-Do not write one-off scripts to parse source packages, count extracted symbols,
-or sample candidates. Use `context source inspect` and the extract no-write
-preview command.
-
-### Step 4 — Report
-
-Report only the meaningful state transition: commands run, current status,
-human gate reached, and the precise user decision needed next. Never present
-`context build`, `context verify`, or file counts as proof that a deliverable is
-usable; inspect generated package structure when package output is involved.
-
-### Step 5 — Self-verify Checklist
-
-- [ ] `context status` (or explicitly authorized `context status --managed`) was
-  run first. If not, return to **Step 1**.
-- [ ] No human gate was crossed without either direct user confirmation or the
-  current conversation's managed authorization. If not, stop and report the
-  protocol error.
-- [ ] No ad hoc file/script probing replaced CLI views. If not, discard that
-  conclusion and use the CLI view.
-
-</procedures>
-If top-level `state`, `next`, or `routing.command_plan` contradicts
-`draftCandidates`, `pendingReview`, `close.state`, package freshness, or verify
-counts, stop instead of rerunning a completed phase. Report
-`status-route-conflict` and preserve the detailed status output for diagnosis.

package/plugins/codex/skills/continue/references/internal-procedures/skill-init-workspace.md

@@ -1,74 +0,0 @@
----
-name: skill-init-workspace
-description: >
-  Internal procedure invoked by the public Context init entry; not a user slash command.
-  Initializes a Context knowledge workspace, executes only safe setup follow-up,
-  then hands off to the next-step workflow until the first human gate.
-tools:
-  - Bash
----
-
-# skill-init-workspace
-
-Initialize a Context workspace. The CLI creates files; the agent follows safe
-setup hints and stops before source/scope choices.
-
-## TL;DR
-
-- Use `context init`; do not add any extra project-local agent setup.
-- If init prints the standard setup `next:` command, run it instead of only
-  repeating it.
-- After the setup command succeeds, enter the workspace and read `AGENTS.md`
-  before running `context status`.
-- After setup, use `skill-continue-workflow.md`
-  for status-driven continuation.
-- Stop at source registration, extraction scope, review, package output, or any
-  external repo operation that needs user choice.
-- Explain in the user's conversation language. Keep CLI commands, flags, paths,
-  status values, JSONL keys, and copied CLI tokens unchanged.
-
-<procedures>
-
-### Step 1 — Run Init
-
-1. If the user gave no directory, run `context init`.
-2. If the user gave a directory, run `context init <project-dir>`.
-3. If the user supplied a project name option, pass it as `--name <name>`.
-4. Read the CLI feedback block and preserve the project root path.
-
-### Step 2 — Execute Safe Setup
-
-1. If CLI prints `next: cd "<project-root>" && bun install`,
-   execute that command.
-2. If install fails, report the failure and stop.
-3. If setup succeeds, read `<project-root>/AGENTS.md`.
-4. After reading `AGENTS.md`, run `context status` from `<project-root>` and
-   treat that output as the current workspace state.
-
-### Step 3 — Handoff Or Stop
-
-1. If status is ready for a safe mechanical step, continue with
-   `skill-continue-workflow.md`.
-2. If status is `missing-source`, `Human gate:`, or contains placeholders such as
-   `<name>`, `<repo-or-subdir>`, `<phase-id>`, or `<collection>`, ask for the
-   missing human choice and stop. For missing sources, ask for the knowledge
-   source boundary first; do not ask for a raw source name as an isolated
-   parameter.
-3. Do not infer repo source, source boundary, source name, package, or
-   extraction scope from cwd, parent directories, package names, monorepo
-   layout, or git remote.
-
-### Step 4 — Report
-
-Summarize what was initialized, what setup command ran, current status, and the
-human choice needed next. Do not paste a long raw CLI transcript unless the user
-asks for exact output.
-
-### Step 5 — Self-verify Checklist
-
-- [ ] Safe setup was executed when CLI provided the standard setup `next:`. If
-  not, return to **Step 2**.
-- [ ] No repo source or extraction scope was inferred. If not, stop and ask the
-  user to confirm the source boundary and scope.
-
-</procedures>