the01geek/prflow/init

PRFlow Init

Scaffold this repo's PRFlow config files. One command does everything — do not hand-write config.json or guess field values.

Portable helper anchor (single-statement). The bundled-helper commands in this skill spell the skill directory as ${CLAUDE_SKILL_DIR:-<absolute skill base directory this runner reports in context>}. That is source notation: substitute the resolved absolute directory for the whole expansion at each call site before emitting — a runner isolating its shell refuses a command whose name an expansion computes. Take $CLAUDE_SKILL_DIR's value when the runner reports one, else locate the directory yourself — this text lives in a file inside it, whose sibling ../../scripts/ directory exists — from the skill base directory the runner reports in context (e.g. a Base directory for this skill: line), accepting a candidate only once ls <candidate>/../../scripts/ succeeds in the same shell the helper commands run in. If a path form is rejected, use the form that shell reports (pwd shows it); a Windows-form base directory (C:\...) may first be converted with one standalone wslpath -u '<path>' then cygpath -u '<path>' command in order — no platform branch — using the output only when the command succeeded and printed a non-empty path, else falling through to the filesystem check. Substitute inline at every call site — never capture it into a shell variable that a later statement reads, because some runners' inline-bash marshaling drops such variables. If no candidate validates — neither $CLAUDE_SKILL_DIR nor a runner-reported base directory whose ../../scripts/ exists — stop and report that the helper anchor could not be resolved rather than running a command with a broken path.

Consumer prompt extension (load first). Before doing this skill's work, load any consumer-supplied prompt extension for this skill and honor it. From the repo root, run:

"${CLAUDE_SKILL_DIR:-<absolute skill base directory this runner reports in context>}"/../../scripts/load-prompt-extension.sh init

If the invocation fails because the helper path does not exist (No such file, exit 127, or the platform equivalent), that is the anchor failure above: fix the anchor; do not report a missing extension. Otherwise, if the helper exits non-zero, a consumer extension exists but could not be loaded — surface its stderr message and do not silently proceed as if none existed. No PROMPT-EXTENSION-STATUS: line on stderr, as after a refusal, is an unestablished extension to report, never an empty one. If it exits 0 and prints text, treat that text as additional instructions appended to the end of this skill's own prompt for this run. If it exits 0 and prints nothing, proceed unchanged.

Independently of that exit code, any helper in this run may write a prflow: reading the superseded .devflow/ state directory line to stderr. It is not an error and it does not change which arm you take above. The next step is what acts on it; do not relay it separately, or the user reads the same fact several times in one run.

First: refuse a self-install into PRFlow's own engine checkout

/prflow:init scaffolds a consumer repo; running it against PRFlow's own engine tree would rewrite the tracked engine files it must never touch. Before any migrate, sweep, scaffold, install, or provisioning step below, run this guard from the repo root — it reads the running plugin's own accepted name through the skill anchor and the repo root's .claude-plugin/plugin.json name with a bash-builtin read, matching with case, prints the refusal only on an accepted-name match while DEVFLOW_ALLOW_SELF_INSTALL is empty, and always ends by printing self-install-guard: checked so a fence that never ran is distinguishable from one that found no match:

if [ -z "${DEVFLOW_ALLOW_SELF_INSTALL:-}" ]; then
  _si_name() {  # $1 = plugin.json path → prints its "name", empty when absent/unparseable
    [ -r "$1" ] || return 0
    local _j _a; IFS= read -r -d '' _j < "$1" 2>/dev/null || :
    case "$_j" in *'"name"'*) _a="${_j#*\"name\"}"; _a="${_a#*:}"; _a="${_a#"${_a%%[![:space:]]*}"}";
      case "$_a" in '"'*) _a="${_a#\"}"; printf '%s' "${_a%%\"*}" ;; esac ;; esac
  }
  _si_accepted="$(_si_name "${CLAUDE_SKILL_DIR:-<absolute skill base directory this runner reports in context>}"/../../.claude-plugin/plugin.json)"
  _si_root="$(git rev-parse --show-toplevel 2>/dev/null)" || _si_root=
  _si_here="$([ -n "$_si_root" ] && _si_name "$_si_root/.claude-plugin/plugin.json")"
  if [ -n "$_si_here" ]; then case "$_si_here" in "$_si_accepted"|prflow|devflow)
    printf '%s\n' "refusing to install into PRFlow's own engine checkout (.claude-plugin/plugin.json name=\"$_si_here\"): running /prflow:init here would rewrite the tracked engine tree. Set DEVFLOW_ALLOW_SELF_INSTALL=1 for an intentional self-install (or a repo whose plugin is coincidentally named the same)." ;;
  esac; fi
fi
printf '%s\n' 'self-install-guard: checked'

Route on the lines the fence printed, never on a captured variable, and treat silence as unestablished rather than as an answer:

• Printed the refusing to install … line — STOP /prflow:init now and make no writes; this checkout is PRFlow's own engine (its .claude-plugin/plugin.json names an accepted plugin name — prflow or the superseded devflow — and DEVFLOW_ALLOW_SELF_INSTALL is empty). Relay that line and the DEVFLOW_ALLOW_SELF_INSTALL=1 remedy it names.
• Printed self-install-guard: checked and no refusal line — proceed; a repo with no .claude-plugin/plugin.json, a different name, an unparseable manifest, or a non-empty DEVFLOW_ALLOW_SELF_INSTALL (an intentional self-install, or a plugin coincidentally sharing the name) is not PRFlow's engine and is unaffected.
• Any other outcome — neither line, a harness refusal, or an error — STOP and make no writes, reporting that the guard could not run. Some runners refuse a fence carrying command substitution outright and print nothing at all, so reading that silence as "not the engine" would install into the engine tree this guard exists to protect. Re-run on a runner that executes the fence, or set DEVFLOW_ALLOW_SELF_INSTALL=1 once you have confirmed by hand that the repo root's .claude-plugin/plugin.json name is neither prflow nor devflow.

Then: migrate a repository still on the superseded layout

Repositories set up before the PRFlow rename keep their state in .devflow/, with the vendored plugin at .devflow/vendor/devflow/, devflow_* config keys, workflow bodies naming those paths, and a marketplace source pointing at the old vendored directory. Those four move as one unit or not at all — the shipped workflows invoke bundled helpers at the vendored path as repo-relative leading tokens and the cloud allowlist grants are per-literal-path, so a half-moved tree is not merely broken, it is silently denied.

Run this before the scaffolder, so everything after it operates on the migrated tree. From the repo root:

"${CLAUDE_SKILL_DIR:-<absolute skill base directory this runner reports in context>}"/../../scripts/migrate-consumer-tier1.sh

That is the preview: it classifies the repository, plans the four members, validates every precondition, and writes nothing. Show the user its plan. Then perform the migration:

"${CLAUDE_SKILL_DIR:-<absolute skill base directory this runner reports in context>}"/../../scripts/migrate-consumer-tier1.sh --apply --pin-from-plugin

--pin-from-plugin stamps the migrated version pin from this plugin's own published version. Read the helper's prflow-migrate: lines and respond per the matching branch:

• NOTHING TO MIGRATE … — no state directory at either name, so this is a first-time install (not an un-migrated consumer); say nothing about migration and carry on, since the scaffolder below creates the directory.
• ALREADY MIGRATED … — the repository is already on the current layout with nothing changed, so say nothing beyond that and carry on, except that a matching incomplete rename-sweep ledger (see Then: offer an opt-in PRFlow rename sweep below) triggers the renewed-consent resume described there.
• PREVIEW … / PLAN … followed by will migrate lines — relay the plan, each line naming one member of the atomic unit (the state-directory move, the workflow-content rewrite, the marketplace-source rewrite, and the version pin).
• APPLIED every member of the atomic unit landed together. — the migration succeeded, so tell the user their state directory moved to .prflow/, name the atomic-unit members, say the large mechanical diff needs review before committing, and then offer the opt-in rename sweep this terminal APPLIED triggers (see Then: offer an opt-in PRFlow rename sweep below, whose Trigger subsection states the authoritative rule).
• REFUSED … — nothing was migrated and the repository is byte-identical, so present the migration as not done and relay every blocked line and the refusal's own remedy verbatim, then carry on, since the repository still works through the transitional read-through and a refusal is a report, not an init failure.
• could not migrate … lines (which appear on the success path too) — relay each one naming the specific file, since these are items the migration deliberately does not own, chiefly a retained workflow install.sh does not ship and cannot refresh.

Two things this step must not do. Never invent a partial migration — do not move the directory, edit a workflow, or rewrite the marketplace source with your file-edit tools when the helper refused. And never treat a refusal as a stop: nothing in this step may end /prflow:init.

Report each fact once. The apply re-prints the same plan the preview showed, and the scaffolder further down reports the same retained unshipped workflow this step already named. Relay each distinct fact once per run, in whichever step surfaced it first, and say nothing when a later step merely repeats it — a report that says the same thing three times reads as three problems.

Then: migrate a pre-rename telemetry branch

The Tier-1 migration above moves the state directory but not the telemetry branch. A repository set up before the rename keeps its cost/effectiveness records on the superseded devflow-telemetry branch, where the weekly retrospective cannot see them. Run the bundled helper once, after the Tier-1 report arms above, to move those records onto the branch PRFlow now writes to. From the repo root:

"${CLAUDE_SKILL_DIR:-<absolute skill base directory this runner reports in context>}"/../../scripts/migrate-telemetry-branch.sh .

It is best-effort and exits 0. Relay each migrate-telemetry-branch: line it prints, once each — whether it migrated the records, found nothing to migrate, or skipped for a stated reason — then carry on; a skip is a report, not an init failure.

Then: offer an opt-in PRFlow rename sweep (consent-gated)

The atomic migration renames only the mechanical forms lib/rename-map.json enumerates, not prose. This step offers a repository-wide semantic sweep repairing stale DevFlow product-name mentions.

Trigger — terminal APPLIED only. Offer this only after the migration step reported the terminal APPLIED marker. PLAN/PREVIEW is not terminal and never suppresses the offer; NOTHING TO MIGRATE, REFUSED, a migration exit 2, and any unrecognized output issue no offer. ALREADY MIGRATED issues only the renewed-consent resume arm below, and only when a matching incomplete ledger exists.

The consent gate (ask first — disclose model access before any read)

Consent to the migration's edits is not consent to model access: the sweep reads file contents to classify them. Before asking anything, disclose that and get an explicit yes: