skf-quick-skill
Fast skill from a package name or GitHub URL — no brief needed. Use when the user requests a "quick skill" or "skill from URL" or "skill from package."
Install
npx skills add https://github.com/armelhbobdad/bmad-module-skill-forge/tree/main/src/skf-quick-skill
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install armelhbobdad-bmad-module-skill-forge@llmmart
git clone https://github.com/armelhbobdad/bmad-module-skill-forge.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole armelhbobdad/bmad-module-skill-forge collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
Quick Skill
Overview
The fastest path to a skill — accept a GitHub URL or package name, resolve to source, extract the public API surface, and produce a best-effort SKILL.md with context snippet and metadata. No brief needed. Output is always community-tier quality, regardless of which tools are available.
Conventions
- Bare paths (e.g.
references/<name>.md) resolve from the skill root,{skill-root}: this skill's installed directory, wherecustomize.tomllives. That holds inside areferences/file too: only a stage's frontmatternextStepFileand batch-mode.md'shealthCheckStepFilename a file beside it. {project-root}-prefixed paths resolve from the project working directory.- Module-level path exception: bare paths beginning with
knowledge/orshared/resolve from the SKF module root ({project-root}/_bmad/skf/installed,src/in dev), not the skill root; e.g.shared/health-check.md, which the terminal step chains to. - Sibling skills: a path that names another SKF skill's folder (
skf-<name>/...) resolves from the SKF module root, and that skill must be installed with this one.
Role
You are a rapid skill compiler collaborating with a developer. You bring source analysis and skill document assembly expertise, while the user brings the target package or repository. Work together efficiently — speed is the priority.
Workflow Rules
These rules apply to every step in this workflow:
- Never fabricate content — all data must come from source extraction or user input
- Never write into a skill folder SKF did not generate
- Only load one step file at a time — never preload future steps
- Run every subagent in the foreground, passing
run_in_background: falseon every Agent call (Claude Code runs a subagent in the background when the flag is left out), with parallel ones as several such calls in one message, and wait for every long-running command to exit before the next instruction; in a headless run, never end a turn while either still runs, since underclaude -pa run stops when its turn ends. - Always communicate in
{communication_language} - Universal cancel-line affordance: at any interactive prompt the user may type
cancel,exit,:q, or select the[X] Cancel and exitmenu option (where surfaced) to leave cleanly. HARD HALT with exit code 6 (user-cancelled): stage{"phase": "<the step's slug>", "halt_reason": "user-cancelled", "reason": "Cancelled. No files were written.", "skill_package": null}as{run_dir}/halt.jsonand runuv run {emitEnvelopeHelper} emit-halt --workflow skf-quick-skill --run-dir "{run_dir}" --target stderr < "{run_dir}/halt.json"(references/halt-contract.md). In step 4 §6 the equivalent affordance is[Q] Quit without writing, with the same exit code and envelope. Step 6 §1 comes after the write: a cancel there keeps the pointer, as its [K] does. - If
{headless_mode}is true, auto-proceed through confirmation gates with their default action, and record each auto-decision in the run folder the moment its gate decides, so the envelope'sheadless_decisionscarries it: stage{"gate": "<the gate's name>", "default_action": "<X>", "taken_action": "<X>", "reason": "headless: <why>"}as{run_dir}/decision.jsonand runuv run {emitEnvelopeHelper} record --workflow skf-quick-skill --run-dir "{run_dir}" --decision < "{run_dir}/decision.json". Each gate names its gate and default where it decides. - If
{headless_mode}is true, print the one-line JSON progress events on stderr thatreferences/halt-contract.md(Headless Events) defines: when each step starts, just before it chains on, and at a HARD HALT.
Stages
| # | Step | File | Auto-proceed |
|---|---|---|---|
| 1 | Resolve Target | references/resolve-target.md | Conditional (no target, an ambiguous one, or a missing tag) |
| 2 | Ecosystem Check | references/ecosystem-check.md | Yes |
| 3 | Quick Extract | references/quick-extract.md | Conditional (an unusual repo shape, zero exports) |
| 4 | Compile | references/compile.md | No (review) |
| 5 | Write & Validate | references/write-and-validate.md | Conditional (the skill folder exists) |
| 6 | Finalize | references/finalize.md | Conditional (active on another workflow's build) |
| 7 | Workflow Health Check | references/health-check.md | Yes |
Invocation Contract
Headless callers and pipelines: the inputs, flags, gates, outputs, exit codes and the SKF_QUICK_SKILL_RESULT_JSON and --batch reading rules live in references/invocation-contract.md. Interactive runs do not need it.
On Activation
Check the runtime, then load the config and the helpers. Every helper this workflow runs, the envelope emitter and the preflight included, runs through
uv run, so first confirm thatpython3anduvare both on$PATH(command -v python3andcommand -v uv). If either is missing, HARD HALT with exit code 3 (resolution-failure): display "Quick Skill needs{the missing tool}, which is not on your PATH. Install it (uvfrom https://docs.astral.sh/uv/getting-started/installation/,python3from https://www.python.org/downloads/), then re-run." No envelope is printed: the emitter needsuvtoo.Then resolve
{emitEnvelopeHelper}← the first existing path of{project-root}/_bmad/skf/shared/scripts/skf-emit-result-envelope.pyand{project-root}/src/shared/scripts/skf-emit-result-envelope.py, the shared emitter every envelope and auto-decision goes through. With no emitter path (an incomplete install), each halt displays its message alone and step 6 §3 writes no result contract.Then load the config:
{preflightHelper}←{project-root}/_bmad/skf/shared/scripts/skf-preflight.py, else{project-root}/src/shared/scripts/skf-preflight.py(the first that exists). Run:uv run {preflightHelper} "{project-root}" --allow-missing-sidecarIt parses
{project-root}/_bmad/skf/config.yamlandpreferences.yamlinto one JSON object: bindproject_name,user_name,communication_languageanddocument_output_languagefrom itsconfig, andoutput_folder,skills_output_folder,forge_data_folderandsidecar_pathfromconfig.<name>_resolved, each folder's absolute path. Withsidecar.preferences_error(apreferences.yamlthat is there but does not load), go on with the defaults and display that error in one line;derived.headless_modeis then false, so only--headlessor-Hmakes the run headless. If neither path exists, or the call exits non-zero or prints no JSON, HARD HALT with exit code 3 (resolution-failure): display "Quick Skill cannot load its config. {itserror, else its first stderr line, else: SKF's preflight (skf-preflight.py) is missing from{project-root}/_bmad/skf/shared/scripts/, so re-install SKF.}" and emit with nothing to stage in, since no run folder exists yet. The payload'sreasonis the message's first sentence alone: preflight's error names an absolute path, which typed into JSON can break it, so only the display carries it:uv run {emitEnvelopeHelper} emit-halt --workflow skf-quick-skill --target stderr <<'SKF_JSON' {"phase": "on-activation", "halt_reason": "resolution-failure", "reason": "Quick Skill cannot load its config.", "skill_package": null, "details": {"cause": "<its code, preflight-missing with no path, or preflight-error after a call that printed no JSON>"}} SKF_JSONThen create the run folder:
mkdir -p "{project-root}/_bmad-output/.skf-run" && mktemp -d "{project-root}/_bmad-output/.skf-run/skf-quick-skill-XXXXXXXX"Bind
{run_dir}← the path it prints (a finished run deletes it; a halted one keeps it). If it cannot be created, HARD HALT with exit code 4 (write-failure): display "Quick Skill cannot start: the run folder could not be created. " and emit with nothing to stage in, that stderr line again in the display alone:uv run {emitEnvelopeHelper} emit-halt --workflow skf-quick-skill --target stderr <<'SKF_JSON' {"phase": "on-activation", "halt_reason": "write-failure", "reason": "Quick Skill cannot start: the run folder could not be created.", "skill_package": null} SKF_JSONThen resolve every helper the stages run, before any stage loads:
uv run {preflightHelper} "{project-root}" --allow-missing-sidecar --helpers "{skill-root}" > "{run_dir}/helpers.json"It writes the same JSON object with a
helpersmap,{<stem>: <absolute path or null>}, one key for each<stem>ProbeOrderarray in the stages' frontmatter; each stage binds its helpers from that file (its Rules). If the call exits non-zero, HARD HALT with exit code 3 (resolution-failure): display "Quick Skill cannot start: SKF helpers are missing. {theerrorin{run_dir}/helpers.json, which names each missing helper, else its first stderr line, else: the preflight printed no JSON, so re-install SKF.}" Stage{"phase": "on-activation", "halt_reason": "resolution-failure", "reason": "Quick Skill cannot start: SKF helpers are missing.", "skill_package": null, "details": {"cause": "helpers-missing", "missing": [<its helpers_missing, if any>]}}as{run_dir}/halt.json, with"details": {"cause": "preflight-error"}when the file holds no JSON, and emit it with the cancel-line rule's command (Workflow Rules).Resolve
{headless_mode}: true if--headlessor-Hwas passed as an argument, or if step 1's preflight gavederived.headless_modetrue (headless_mode: truein{sidecar_path}/preferences.yaml). Default: false.Resolve workflow customization. Bind
{resolveCustomizationHelper}←helpers.resolveCustomizationin{run_dir}/helpers.json, which step 1 wrote (step 1 halts when the script is missing), and run:uv run {resolveCustomizationHelper} --skill {skill-root} --project-root {project-root} --key workflow --factsIt merges the bundled
{skill-root}/customize.tomlwith{project-root}/_bmad/custom/skf-quick-skill.toml(team overrides, committed) and.user.toml(personal overrides, gitignored). When it exits non-zero or prints no JSON, print one line,[activation/warn] customization_resolver_unavailable: <reason>(<reason>: its first stderr line,no JSONwhen it printed none). If the resolver cannot run, read{skill-root}/customize.tomlalone and use its bundled defaults: the{project-root}/_bmad/custom/overrides do not apply to this run. In that case keep the reason as{customization_resolver_unavailable}(unset when the resolver ran) and, when{emitEnvelopeHelper}has a path, record it in the run sink: writecustomization_resolver_unavailable: {customization_resolver_unavailable}to{run_dir}/resolver-warning.txtwith a file write, neverecho(the reason can hold quotes or$( )), then runuv run {emitEnvelopeHelper} record --run-dir "{run_dir}" --warning "$(cat "{run_dir}/resolver-warning.txt")". Under--batch,references/batch-mode.md§2 records that file in each target's run folder.Bind these three as workflow-context variables, taking the default when the merged value is empty or absent:
{skillTemplatePath}←workflow.skill_template_path, elseassets/skill-template.md{batchOutputPath}←workflow.batch_output_path, else{skills_output_folder}/_batch/{onCompleteCommand}←workflow.on_complete, else empty (step 6 §3 then runs no hook)
Run each
workflow.activation_steps_prependentry now, in order. Hold everyworkflow.persistent_factsentry as standing context for the whole run (the bundled default loads everyproject-context.mdunder{project-root}, none in{project-root}/_bmad-output/.skf-run/; if the resolver ran,--factshas applied each!entry, which drops each earlier entry it names, and expanded each glob, so afile:entry names one file). Once On Activation step 4 has parsed the flags, before On Activation step 5 or 6 starts the run, run eachworkflow.activation_steps_appendentry in order.Parse CLI overrides into the workflow context as
{overrides}:Flag Effect --language-hint <lang>Sets language_hint: step 1 §4 takes it as the language, with no detection and no multi-language gate, and step 1 §3 asks only that language's registry.--scope-hint <path>Sets scope_hint: the folder step 3 reads the entry points and skill folders from.--description "<string>"Replaces the extracted description in step 4 §2, which checks its length and voice as it checks an extracted one. --exports "<name1,name2,...>"Replaces the extracted export list in step 4 §2: comma-separated, each name trimmed, empty items skipped. --skip-snippetNo context-snippet.md: step 4 §4 and step 5 §2 skip it. --no-active-pointerStep 6 §1 leaves {skill_group}/activeas it is.--batch <file>Compiles every target the file lists, headless (On Activation step 5); --skip-snippetand--no-active-pointerapply to every target in the batch.--fail-fastWith --batch: the batch stops at the first failed target.--language-hint,--scope-hint,--descriptionand--exportsare single-target flags: batch mode refuses them.If
--batchis set, load and readreferences/batch-mode.mdin full before anything else and follow it.Load, read the full file, and then execute
references/resolve-target.mdto begin the workflow; when{headless_mode}is true, print step 1'sstartevent first (references/halt-contract.md). In batch mode,references/batch-mode.mdloads it for each target instead.
Files (bmad-module-skill-forge)
-
assets
-
skill-template.md 3.5 KB
Loading…
-
-
references
-
batch-mode.md 10.7 KB
Loading… -
compile.md 13.3 KB
Loading… -
ecosystem-check.md 829 B
Loading… -
finalize.md 14.2 KB
Loading… -
halt-contract.md 5.9 KB
Loading… -
health-check.md 1.1 KB
Loading… -
invocation-contract.md 3.2 KB
Loading… -
quick-extract.md 23.5 KB
Loading… -
resolve-target.md 24.6 KB
Loading… -
write-and-validate.md 27.1 KB
Loading…
-
-
customize.toml 4 KB
Loading… -
SKILL.md 13.7 KB
--- name: skf-quick-skill description: Fast skill from a package name or GitHub URL — no brief needed. Use when the user requests a "quick skill" or "skill from URL" or "skill from package." --- # Quick Skill ## Overview The fastest path to a skill — accept a GitHub URL or package name, resolve to source, extract the public API surface, and produce a best-effort SKILL.md with context snippet and metadata. No brief needed. Output is always community-tier quality, regardless of which tools are available. ## Conventions - Bare paths (e.g. `references/<name>.md`) resolve from the skill root, `{skill-root}`: this skill's installed directory, where `customize.toml` lives. That holds inside a `references/` file too: only a stage's frontmatter `nextStepFile` and batch-mode.md's `healthCheckStepFile` name a file beside it. - `{project-root}`-prefixed paths resolve from the project working directory. - **Module-level path exception:** bare paths beginning with `knowledge/` or `shared/` resolve from the SKF module root (`{project-root}/_bmad/skf/` installed, `src/` in dev), not the skill root; e.g. `shared/health-check.md`, which the terminal step chains to. - **Sibling skills:** a path that names another SKF skill's folder (`skf-<name>/...`) resolves from the SKF module root, and that skill must be installed with this one. ## Role You are a rapid skill compiler collaborating with a developer. You bring source analysis and skill document assembly expertise, while the user brings the target package or repository. Work together efficiently — speed is the priority. ## Workflow Rules These rules apply to every step in this workflow: - Never fabricate content — all data must come from source extraction or user input - Never write into a skill folder SKF did not generate - Only load one step file at a time — never preload future steps - Run every subagent in the foreground, passing `run_in_background: false` on every Agent call (Claude Code runs a subagent in the background when the flag is left out), with parallel ones as several such calls in one message, and wait for every long-running command to exit before the next instruction; in a headless run, never end a turn while either still runs, since under `claude -p` a run stops when its turn ends. - Always communicate in `{communication_language}` - **Universal cancel-line affordance**: at any interactive prompt the user may type `cancel`, `exit`, `:q`, or select the `[X] Cancel and exit` menu option (where surfaced) to leave cleanly. HARD HALT with **exit code 6 (user-cancelled)**: stage `{"phase": "<the step's slug>", "halt_reason": "user-cancelled", "reason": "Cancelled. No files were written.", "skill_package": null}` as `{run_dir}/halt.json` and run `uv run {emitEnvelopeHelper} emit-halt --workflow skf-quick-skill --run-dir "{run_dir}" --target stderr < "{run_dir}/halt.json"` (`references/halt-contract.md`). In step 4 §6 the equivalent affordance is `[Q] Quit without writing`, with the same exit code and envelope. Step 6 §1 comes after the write: a cancel there keeps the pointer, as its [K] does. - If `{headless_mode}` is true, auto-proceed through confirmation gates with their default action, and record each auto-decision in the run folder the moment its gate decides, so the envelope's `headless_decisions` carries it: stage `{"gate": "<the gate's name>", "default_action": "<X>", "taken_action": "<X>", "reason": "headless: <why>"}` as `{run_dir}/decision.json` and run `uv run {emitEnvelopeHelper} record --workflow skf-quick-skill --run-dir "{run_dir}" --decision < "{run_dir}/decision.json"`. Each gate names its gate and default where it decides. - If `{headless_mode}` is true, print the one-line JSON progress events on stderr that `references/halt-contract.md` (Headless Events) defines: when each step starts, just before it chains on, and at a HARD HALT. ## Stages | # | Step | File | Auto-proceed | |---|------|------|--------------| | 1 | Resolve Target | references/resolve-target.md | Conditional (no target, an ambiguous one, or a missing tag) | | 2 | Ecosystem Check | references/ecosystem-check.md | Yes | | 3 | Quick Extract | references/quick-extract.md | Conditional (an unusual repo shape, zero exports) | | 4 | Compile | references/compile.md | No (review) | | 5 | Write & Validate | references/write-and-validate.md | Conditional (the skill folder exists) | | 6 | Finalize | references/finalize.md | Conditional (`active` on another workflow's build) | | 7 | Workflow Health Check | references/health-check.md | Yes | ## Invocation Contract Headless callers and pipelines: the inputs, flags, gates, outputs, exit codes and the `SKF_QUICK_SKILL_RESULT_JSON` and `--batch` reading rules live in `references/invocation-contract.md`. Interactive runs do not need it. ## On Activation 1. **Check the runtime, then load the config and the helpers.** Every helper this workflow runs, the envelope emitter and the preflight included, runs through `uv run`, so first confirm that `python3` and `uv` are both on `$PATH` (`command -v python3` and `command -v uv`). If either is missing, HARD HALT with **exit code 3 (resolution-failure)**: display "**Quick Skill needs `{the missing tool}`, which is not on your PATH.** Install it (`uv` from <https://docs.astral.sh/uv/getting-started/installation/>, `python3` from <https://www.python.org/downloads/>), then re-run." No envelope is printed: the emitter needs `uv` too. Then resolve `{emitEnvelopeHelper}` ← the first existing path of `{project-root}/_bmad/skf/shared/scripts/skf-emit-result-envelope.py` and `{project-root}/src/shared/scripts/skf-emit-result-envelope.py`, the shared emitter every envelope and auto-decision goes through. With no emitter path (an incomplete install), each halt displays its message alone and step 6 §3 writes no result contract. Then load the config: `{preflightHelper}` ← `{project-root}/_bmad/skf/shared/scripts/skf-preflight.py`, else `{project-root}/src/shared/scripts/skf-preflight.py` (the first that exists). Run: ```bash uv run {preflightHelper} "{project-root}" --allow-missing-sidecar ``` It parses `{project-root}/_bmad/skf/config.yaml` and `preferences.yaml` into one JSON object: bind `project_name`, `user_name`, `communication_language` and `document_output_language` from its `config`, and `output_folder`, `skills_output_folder`, `forge_data_folder` and `sidecar_path` from `config.<name>_resolved`, each folder's absolute path. With `sidecar.preferences_error` (a `preferences.yaml` that is there but does not load), go on with the defaults and display that error in one line; `derived.headless_mode` is then false, so only `--headless` or `-H` makes the run headless. If neither path exists, or the call exits non-zero or prints no JSON, HARD HALT with **exit code 3 (resolution-failure)**: display "**Quick Skill cannot load its config.** {its `error`, else its first stderr line, else: SKF's preflight (`skf-preflight.py`) is missing from `{project-root}/_bmad/skf/shared/scripts/`, so re-install SKF.}" and emit with nothing to stage in, since no run folder exists yet. The payload's `reason` is the message's first sentence alone: preflight's error names an absolute path, which typed into JSON can break it, so only the display carries it: ```bash uv run {emitEnvelopeHelper} emit-halt --workflow skf-quick-skill --target stderr <<'SKF_JSON' {"phase": "on-activation", "halt_reason": "resolution-failure", "reason": "Quick Skill cannot load its config.", "skill_package": null, "details": {"cause": "<its code, preflight-missing with no path, or preflight-error after a call that printed no JSON>"}} SKF_JSON ``` Then create the run folder: ```bash mkdir -p "{project-root}/_bmad-output/.skf-run" && mktemp -d "{project-root}/_bmad-output/.skf-run/skf-quick-skill-XXXXXXXX" ``` Bind `{run_dir}` ← the path it prints (a finished run deletes it; a halted one keeps it). If it cannot be created, HARD HALT with **exit code 4 (write-failure)**: display "**Quick Skill cannot start: the run folder could not be created.** {the first stderr line}" and emit with nothing to stage in, that stderr line again in the display alone: ```bash uv run {emitEnvelopeHelper} emit-halt --workflow skf-quick-skill --target stderr <<'SKF_JSON' {"phase": "on-activation", "halt_reason": "write-failure", "reason": "Quick Skill cannot start: the run folder could not be created.", "skill_package": null} SKF_JSON ``` Then resolve every helper the stages run, before any stage loads: ```bash uv run {preflightHelper} "{project-root}" --allow-missing-sidecar --helpers "{skill-root}" > "{run_dir}/helpers.json" ``` It writes the same JSON object with a `helpers` map, `{<stem>: <absolute path or null>}`, one key for each `<stem>ProbeOrder` array in the stages' frontmatter; each stage binds its helpers from that file (its Rules). If the call exits non-zero, HARD HALT with **exit code 3 (resolution-failure)**: display "**Quick Skill cannot start: SKF helpers are missing.** {the `error` in `{run_dir}/helpers.json`, which names each missing helper, else its first stderr line, else: the preflight printed no JSON, so re-install SKF.}" Stage `{"phase": "on-activation", "halt_reason": "resolution-failure", "reason": "Quick Skill cannot start: SKF helpers are missing.", "skill_package": null, "details": {"cause": "helpers-missing", "missing": [<its helpers_missing, if any>]}}` as `{run_dir}/halt.json`, with `"details": {"cause": "preflight-error"}` when the file holds no JSON, and emit it with the cancel-line rule's command (Workflow Rules). 2. **Resolve `{headless_mode}`**: true if `--headless` or `-H` was passed as an argument, or if step 1's preflight gave `derived.headless_mode` true (`headless_mode: true` in `{sidecar_path}/preferences.yaml`). Default: false. 3. **Resolve workflow customization.** Bind `{resolveCustomizationHelper}` ← `helpers.resolveCustomization` in `{run_dir}/helpers.json`, which step 1 wrote (step 1 halts when the script is missing), and run: ```bash uv run {resolveCustomizationHelper} --skill {skill-root} --project-root {project-root} --key workflow --facts ``` It merges the bundled `{skill-root}/customize.toml` with `{project-root}/_bmad/custom/skf-quick-skill.toml` (team overrides, committed) and `.user.toml` (personal overrides, gitignored). When it exits non-zero or prints no JSON, print one line, `[activation/warn] customization_resolver_unavailable: <reason>` (`<reason>`: its first stderr line, `no JSON` when it printed none). If the resolver cannot run, read `{skill-root}/customize.toml` alone and use its bundled defaults: the `{project-root}/_bmad/custom/` overrides do not apply to this run. In that case keep the reason as `{customization_resolver_unavailable}` (unset when the resolver ran) and, when `{emitEnvelopeHelper}` has a path, record it in the run sink: write `customization_resolver_unavailable: {customization_resolver_unavailable}` to `{run_dir}/resolver-warning.txt` with a file write, never `echo` (the reason can hold quotes or `$( )`), then run `uv run {emitEnvelopeHelper} record --run-dir "{run_dir}" --warning "$(cat "{run_dir}/resolver-warning.txt")"`. Under `--batch`, `references/batch-mode.md` §2 records that file in each target's run folder. Bind these three as workflow-context variables, taking the default when the merged value is empty or absent: - `{skillTemplatePath}` ← `workflow.skill_template_path`, else `assets/skill-template.md` - `{batchOutputPath}` ← `workflow.batch_output_path`, else `{skills_output_folder}/_batch/` - `{onCompleteCommand}` ← `workflow.on_complete`, else empty (step 6 §3 then runs no hook) Run each `workflow.activation_steps_prepend` entry now, in order. Hold every `workflow.persistent_facts` entry as standing context for the whole run (the bundled default loads every `project-context.md` under `{project-root}`, none in `{project-root}/_bmad-output/.skf-run/`; if the resolver ran, `--facts` has applied each `!` entry, which drops each earlier entry it names, and expanded each glob, so a `file:` entry names one file). Once On Activation step 4 has parsed the flags, before On Activation step 5 or 6 starts the run, run each `workflow.activation_steps_append` entry in order. 4. **Parse CLI overrides** into the workflow context as `{overrides}`: | Flag | Effect | | --- | --- | | `--language-hint <lang>` | Sets `language_hint`: step 1 §4 takes it as the language, with no detection and no multi-language gate, and step 1 §3 asks only that language's registry. | | `--scope-hint <path>` | Sets `scope_hint`: the folder step 3 reads the entry points and skill folders from. | | `--description "<string>"` | Replaces the extracted description in step 4 §2, which checks its length and voice as it checks an extracted one. | | `--exports "<name1,name2,...>"` | Replaces the extracted export list in step 4 §2: comma-separated, each name trimmed, empty items skipped. | | `--skip-snippet` | No context-snippet.md: step 4 §4 and step 5 §2 skip it. | | `--no-active-pointer` | Step 6 §1 leaves `{skill_group}/active` as it is. | | `--batch <file>` | Compiles every target the file lists, headless (On Activation step 5); `--skip-snippet` and `--no-active-pointer` apply to every target in the batch. | | `--fail-fast` | With `--batch`: the batch stops at the first failed target. | `--language-hint`, `--scope-hint`, `--description` and `--exports` are single-target flags: batch mode refuses them. 5. **If `--batch` is set**, load and read `references/batch-mode.md` in full before anything else and follow it. 6. Load, read the full file, and then execute `references/resolve-target.md` to begin the workflow; when `{headless_mode}` is true, print step 1's `start` event first (`references/halt-contract.md`). In batch mode, `references/batch-mode.md` loads it for each target instead.
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.