@pareto4/pp-core 1.5.4 → 1.6.0

package/pp-core/workflows/init.md

@@ -0,0 +1,530 @@
+<purpose>
+Universal front door for initializing any project with Pareto. Takes any directory — empty
+or containing an existing codebase — from zero to: git-initialized, minimal identity
+captured, remote wired, and handed off to either /pp-discovery or /pp-new-project.
+
+Implements decisions: D-02 (no Obsidian/board scaffolding), D-03 (no discovery session
+scaffolding here — /pp-discovery self-generates them), D-04 (ASK handoff with smart
+default), D-06 (generic remote wiring: prompt URL → git remote add → confirmed push,
+zero provider API), D-07 (minimal identity only — no CLAUDE.md client-context block),
+D-13 (gate on .platform-bindings.json via the Phase 7 reader).
+
+Inert of all Pareto/GitLab behavior when no .platform-bindings.json is present.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+## Shim hoist
+
+Resolve `pp_run` before any step — required for the platform-bindings preflight (D-13).
+
+```bash
+```
+
+## Text mode (resolve before any prompt — WR-02)
+
+Resolve `TEXT_MODE` here, **before Step 0**, because the Step 0 drift prompt is the first
+`AskUserQuestion` a non-Claude runtime hits. Set `TEXT_MODE=true` if `--text` is present in
+`$ARGUMENTS`. When `TEXT_MODE` is active, replace every `AskUserQuestion` call (including the
+Step 0 drift prompt) with a plain-text numbered list and ask the user to type their choice
+number. This is required for non-Claude runtimes where `AskUserQuestion` is unavailable.
+
+---
+
+## 0. Platform-version preflight (Pareto satellite repos)
+
+**Runs before Step 1. Inert for non-Pareto projects** — gated entirely on
+`.platform-bindings.json` existing (D-13), so generic projects skip it with no effect.
+
+A repo scaffolded by `/pareto-new-app` pins the Pareto platform at a specific `vX.Y.Z` tag
+(module `?ref=` pins, the `.gitlab-ci.yml` include `ref:`, and the canonical
+`.platform-bindings.json` → `platform.tag`). Project initiation is the moment to confirm
+the app is on the **latest** platform before any building starts — bumping after a
+milestone is built is far more expensive.
+
+```bash
+_PP_SHIM_NAME="pp-tools.cjs"; _PP_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; PP_TOOLS="${_PP_RUNTIME_ROOT}/pp-core/bin/${_PP_SHIM_NAME}"; if [ -f "$PP_TOOLS" ]; then pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif command -v pp-tools >/dev/null 2>&1; then PP_TOOLS="$(command -v pp-tools)"; pp_run() { "$PP_TOOLS" "$@"; }; elif [ -f "$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; else echo "ERROR: pp-tools.cjs not found at $PP_TOOLS and pp-tools is not on PATH. Run: npx -y @pareto4/pp-core@latest --claude --local" >&2; exit 1; fi; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${PP_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${PP_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+# Gate on presence via reader — absent file → {present:false} exit 0 (inert, step skipped, no jq)
+if [ "$(pp_run query platform-bindings --pick present 2>/dev/null)" = "true" ]; then
+  PINNED=$(pp_run query platform-bindings --pick platform.tag)
+  REPO=$(pp_run query platform-bindings --pick platform.repo)
+  HOST_FROM_BINDINGS=$(pp_run query platform-bindings --pick platform.host 2>/dev/null)
+  PLATFORM_HOST="${HOST_FROM_BINDINGS:-${HOST:-gitlab.com}}"
+  PLATFORM_REPO_URL="https://${PLATFORM_HOST}/${REPO}.git"
+  # Resolve latest STABLE tag from remote — never hard-block if offline (empty LATEST → skip drift check)
+  # Keep --refs to strip ^{} annotated-tag rows; --sort=-v:refname sorts server-side
+  # Stable filter fixes prerelease mis-ordering: git ranks v1.4.0-rc.1 after v1.4.0 (wrong by semver)
+  # semver-compare.cjs is the single blessed source for comparison — do NOT reimplement
+  REMOTE_TAGS=$(git ls-remote --tags --refs --sort=-v:refname "$PLATFORM_REPO_URL" 'v*' 2>/dev/null | sed 's#.*/##')
+  # IN-03: pass the lib dir via env (PP_LIB_DIR) rather than interpolating ${PP_TOOLS%/*}
+  # into the JS program text — keeps the path out of the evaluated source.
+  LATEST=$(printf '%s\n' "$REMOTE_TAGS" | PP_LIB_DIR="${PP_TOOLS%/*}/lib" node -e "
+const sc = require(process.env.PP_LIB_DIR + '/semver-compare.cjs');
+const lines = require('fs').readFileSync(0, 'utf-8').split('\n').map(s=>s.trim()).filter(Boolean);
+const stable = lines.filter(sc.isStableTripletSemver).sort(sc.compareSemverCore);
+process.stdout.write((stable[stable.length-1] || '') + '\n');
+" 2>/dev/null)
+  echo "platform preflight: pinned=${PINNED:-<none>} latest=${LATEST:-<unresolved>}"
+  if [ -n "$LATEST" ] && [ -n "$PINNED" ] && [ "$PINNED" != "$LATEST" ]; then
+    echo "PP_PLATFORM_DRIFT=1"
+  fi
+fi
+```
+
+**If the block printed `PP_PLATFORM_DRIFT=1`:** the app is pinned behind the latest platform
+tag. STOP before Step 1 and use `AskUserQuestion` to let the user choose:
+- **Bump first (recommended)** — pause initiation; bump the module `?ref=` pins, the
+  `.gitlab-ci.yml` include `ref:`, and `.platform-bindings.json` `platform.tag` to
+  `${LATEST}` (review `CHANGELOG.md` between the two tags for breaking changes), then
+  re-run `/pp-init`.
+- **Proceed on the older pin** — continue knowingly; record the deferral in `PROJECT.md`
+  so it is a conscious decision, not silent drift.
+
+If `LATEST` was unresolved (offline / no network), note it and proceed — never hard-block
+initiation on an unreachable remote. For non-Pareto repos the block is a no-op and this
+step is skipped entirely.
+
+---
+
+## 1. Worktree-aware git init
+
+Parse the init signals by running the query below. `init.execute-phase` is reused here
+deliberately (IN-02): it is the shared verb that emits the generic git-state signals
+(`has_git`, `in_nested_subdir`, `git_worktree_root`) this step needs — no phase work is
+triggered when called with an empty phase argument.
+
+```bash
+INIT=$(pp_run query init.execute-phase "" 2>/dev/null || echo '{}')
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Extract from the JSON: `has_git`, `in_nested_subdir`, `git_worktree_root`.
+
+Apply the `#3491` guard (never nest `.git` inside an existing worktree):
+
+- If `has_git` is `true` and `in_nested_subdir` is `true`: **skip `git init`**; warn the
+  user: "Initializing inside an existing worktree (`${git_worktree_root}`); planning files
+  will track to the outer repo." Do not call `git init`. This case pairs with the
+  `--skipGitInit` flag used by the gated GitLab provisioning path in Plan 02.
+- If `has_git` is `true` and `in_nested_subdir` is `false`: **skip `git init`** (already
+  at the worktree root).
+- If `has_git` is `false`: run `git init` to initialize a new repository.
+
+**Text mode:** `TEXT_MODE` was already resolved in the "Text mode" section above (before
+Step 0). Continue honoring it for every `AskUserQuestion` call in this and later steps.
+
+---
+
+## 2. Minimal identity capture (D-07)
+
+Capture ONLY the five identity fields below. Persist them as a stub in
+`.planning/config.json` under a top-level `"project"` key, merged with any existing
+config. These fields are used by the gated GitLab provisioning path (Plan 02) for
+`group/repo-slug` and `visibility`; they do NOT produce a `CLAUDE.md` client-context
+block — that is Phase 9 (CTX-01..03) territory. Do NOT write a coding-standards,
+architecture, or DoD block here; executor and Phase 9 must not double-capture these.
+
+Ask the user with `AskUserQuestion` (or plain-text prompts in TEXT_MODE):
+
+```text
+1. Project name (human-readable, e.g. "Acme Dashboard")
+2. Project slug (kebab-case, e.g. "acme-dashboard")
+3. Client name (company / team, e.g. "Acme Corp") — type "internal" if none
+4. Client slug (kebab-case, e.g. "acme") — type "internal" if none
+5. One-line description (what this project does)
+```
+
+Also ask — used only by the gated GitLab path (D-13, Plan 02):
+
+```text
+6. Provider (gitlab / github / other / none)
+7. Visibility (private / public / internal)
+```
+
+Write these to `.planning/config.json`:
+
+```json
+{
+  "project": {
+    "name": "<value>",
+    "slug": "<value>",
+    "client_name": "<value>",
+    "client_slug": "<value>",
+    "description": "<value>",
+    "provider": "<value>",
+    "visibility": "<value>"
+  }
+}
+```
+
+`mkdir -p .planning` before writing if the directory does not exist.
+
+**Scope boundary:** this step writes identity only. All coding-standards, architecture
+context, client-engagement CLAUDE.md blocks, and discovery-session scaffolding are out of
+scope here. Phase 9 owns those; /pp-discovery self-generates its own session files (D-03).
+
+---
+
+## 3. Remote wiring — provider-agnostic (non-Pareto / no bindings)
+
+**Gate (D-06, D-13):** this step is the active path when
+`pp_run query platform-bindings --pick present 2>/dev/null` does NOT equal `"true"`.
+When bindings ARE present, see the gated GitLab provisioning section below instead.
+
+On the generic path:
+
+1. Ask the user for the remote URL (any host — GitHub, GitLab, Gitea, Bitbucket, etc.):
+
+   ```text
+   Remote URL for this repository (e.g. https://github.com/org/repo.git):
+   ```
+
+2. Show the exact command and target, then confirm before firing:
+
+   ```text
+   About to run:
+     git remote add origin <url>
+
+   Proceed? [y/N]
+   ```
+
+   If confirmed, run `git remote add origin <url>`. If a remote named `origin` already
+   exists, offer to update it with `git remote set-url origin <url>` instead (show the
+   same per-action confirm pattern).
+
+3. Offer a first push. Show the exact command and target before firing:
+
+   ```text
+   About to run:
+     git push -u origin <current-branch>
+
+   Proceed? [y/N]
+   ```
+
+   If confirmed, run `git push -u origin <current-branch>`. If the user declines, skip
+   the push and note that they can run `git push -u origin <branch>` later.
+
+**Security (T-08-01, T-08-02):** every outward action (`git remote add`, `git push`)
+gets its own per-action confirmation immediately before it fires — nothing batched. This
+step makes **ZERO `gh`/`glab`/provider-API calls**. The push target is the user-supplied
+URL only.
+
+### Gated GitLab provisioning (Pareto projects — bindings present)
+
+This path runs **instead of** the generic remote-wiring path above when
+`pp_run query platform-bindings --pick present 2>/dev/null` equals `"true"`. Implements
+D-05 (per-action confirmation), D-09 (existence probe → adopt-if-exists), D-10 (private
+by default), D-11 (auth verify-only), D-12 (adopt-if-exists reconciliation), D-13
+(bindings gate). Covers INIT-02 and the cross-cutting SAFE-01 invariant.
+
+**Security invariants — landmine guards:**
+- Always use the group-qualified `$GROUP/$SLUG` path — never a bare slug (T-08-04, D-09).
+  A bare slug creates under the user's personal namespace, not the client group.
+- Always pass `--private` explicitly — never inherit `glab`'s default `--internal`
+  visibility (T-08-05, D-10). The `--internal` flag is what makes this dangerous; the
+  locked recipe must carry `--private` and must NOT emit `--internal`.
+- Always confirm immediately before each outward action — nothing batched (T-08-06, D-05).
+- Verify-only auth via `glab auth status` — never run `glab auth login`, never read
+  or write the user's token (T-08-08, D-11). Bindings hold only non-secret routing data.
+- Always reconcile create with a `glab repo view` probe — a non-zero create exit does
+  NOT mean nothing happened (T-08-09, D-09).
+
+#### G-1. Config reads from the bindings reader (Pattern C, D-09, D-13)
+
+All values come from the Phase 7 bindings reader. **Never hardcoded.**
+
+```bash
+GROUP=$(pp_run query platform-bindings --pick gitlab.group 2>/dev/null)
+SLUG=$(pp_run query platform-bindings --pick gitlab.repo_slug 2>/dev/null)
+VIS_RAW=$(pp_run query platform-bindings --pick gitlab.visibility 2>/dev/null)
+HOST=$(pp_run query platform-bindings --pick gitlab.host 2>/dev/null)
+# D-10: hard-default to private when field is absent or empty
+VIS="${VIS_RAW:-private}"
+DESC=$(pp_run query config-get project.description 2>/dev/null || echo "")
+```
+
+The `gitlab.*` namespace is provisional — the bindings reader is lenient on unknown fields
+(it only hard-validates `schemaVersion`, `platform.repo`, and `platform.tag`). Treat any
+absent `gitlab.*` field gracefully: fall back to safe defaults, never fail hard on a
+missing key. `HOST` defaults to `gitlab.com` in remote URLs when empty.
+
+#### G-2. Auth verify-only (D-11)
+
+`/pp-init` **never establishes auth and never reads or writes the user's token.**
+Secrets stay in the environment or OS keyring. Only verify that a session exists:
+
+```bash
+glab auth status >/dev/null 2>&1 || {
+  echo "Not authenticated to GitLab. Run: glab auth login"
+  exit 1
+}
+```
+
+If this check fails, stop immediately. Do not proceed to probe or create.
+Never run `glab auth login` from within `/pp-init`.
+
+#### G-3. Existence probe → adopt-if-exists (D-09, D-12)
+
+Pre-check with a read-only probe before any create attempt. `glab repo create` is **not
+idempotent** — re-running it against an existing project errors but may still produce side
+effects (the GitLab project is created before the remote-add step that then fails). The
+probe avoids this landmine.
+
+This is one self-contained block: it sets `PROJECT_EXISTS` and, on the exists path,
+adopts (links the remote). It NEVER creates — create lives in its own G-4 block, gated
+on `PROJECT_EXISTS=false`, so the create invocation can never fall inside the exists
+branch.
+
+```bash
+if glab repo view "$GROUP/$SLUG" -F json >/dev/null 2>&1; then
+  # Project already exists — ADOPT: link remote only, skip create (D-12)
+  PROJECT_EXISTS=true
+  echo "GitLab project $GROUP/$SLUG already exists — adopting (linking remote, skipping create)."
+  # IN-01: match the remote scheme glab itself uses on the create path — honor the
+  # user's `glab config get git_protocol` (https default) instead of hardcoding SSH,
+  # so adopt and create produce a consistent origin URL.
+  GIT_PROTO=$(glab config get git_protocol 2>/dev/null || echo https)
+  if [ "$GIT_PROTO" = "ssh" ]; then
+    ADOPT_URL="git@${HOST:-gitlab.com}:$GROUP/$SLUG.git"
+  else
+    ADOPT_URL="https://${HOST:-gitlab.com}/$GROUP/$SLUG.git"
+  fi
+  git remote get-url origin >/dev/null 2>&1 || git remote add origin "$ADOPT_URL"
+  echo "Remote 'origin' → $ADOPT_URL"
+else
+  # Project not found — defer to G-4 for confirm-then-create
+  PROJECT_EXISTS=false
+  echo "GitLab project $GROUP/$SLUG not found — will confirm before create."
+fi
+```
+
+If the project exists (`PROJECT_EXISTS=true`), the remote is already linked above
+(skipping create entirely) — proceed straight to G-5 reconciliation. The adopt path does
+not show a create confirmation — it only links the remote, which is a local-only
+operation and can be undone with `git remote remove origin`.
+
+#### G-4. Per-action confirmation, then create (D-05, D-09, D-10, SAFE-01)
+
+**Only run this step when `PROJECT_EXISTS=false`** (the existence probe in G-3 found no
+project). If `PROJECT_EXISTS=true`, skip G-4 entirely — the project was already adopted —
+and go to G-5. When creating, **show the exact command and target before firing**. The
+user must confirm explicitly. Nothing is batched. (D-05)
+
+Present to the user (via `AskUserQuestion` or TEXT_MODE numbered list):
+
+```text
+About to create GitLab project:
+  Command:        glab repo create "$GROUP/$SLUG"
+  Group path:     $GROUP/$SLUG
+  Visibility:     private (enforced --private; never the glab default --internal)
+  Requested:      $VIS  (from bindings gitlab.visibility — see note below)
+  Default branch: main
+  Skip git init:  yes  (local repo already initialized — --skipGitInit)
+  Remote name:    origin
+
+Proceed? [y/N]
+```
+
+`$VIS` (from G-1) is surfaced in the confirmation so the binding's requested visibility is
+never silently ignored (WR-01). pp-core always **creates private** regardless; a
+non-private binding must be applied as a deliberate, separate post-create change.
+
+Only after the user confirms — and only with `PROJECT_EXISTS=false` — run the locked
+create recipe (D-09, D-10). This is a standalone block: it carries no `if`/`else`/`fi`, so
+it can only ever run as the deliberate, confirmed not-exists path:
+
+```bash
+glab repo create "$GROUP/$SLUG" \
+  --description "$DESC" \
+  --private \
+  --defaultBranch main \
+  --skipGitInit \
+  --remoteName origin
+```
+
+**Visibility hard-default (D-10):** the create invocation always carries `--private`.
+Never omit it and let `glab` silently apply `--internal`. `VIS` from bindings is read in
+G-1 and **surfaced in the G-4 confirmation** (WR-01) so a `public`/`internal` request is
+visible to the user — but pp-core still creates the project **private**. Applying a
+non-private visibility is a deliberate, separate post-create action (e.g. `glab repo edit
+--visibility …`) the operator performs knowingly; `/pp-init` never auto-relaxes visibility.
+
+#### G-5. Post-create reconciliation (D-09)
+
+After the create (or after the adopt path), re-probe existence. A non-zero exit from
+`glab repo create` does **not** mean the project was not created — `glab` exits non-zero
+(code 3) when the GitLab project was created but the subsequent `git remote add` step
+then failed (e.g., because `origin` already existed). The `repo view` probe is the source
+of truth, not the exit code (research §1 "Remote-add caveat — VERIFIED"):
+
+```bash
+if glab repo view "$GROUP/$SLUG" -F json >/dev/null 2>&1; then
+  echo "Reconciled: GitLab project $GROUP/$SLUG confirmed."
+else
+  echo "WARN: glab repo view $GROUP/$SLUG returned non-zero — verify the project was created before continuing."
+fi
+```
+
+If reconciliation warns, do not auto-retry. Prompt the user to check GitLab directly
+before proceeding to Step 4 (handoff routing).
+
+### Gated client-context capture (Pareto projects — bindings present)
+
+This step runs **only when** `pp_run query platform-bindings --pick present 2>/dev/null` equals
+`"true"`. Non-Pareto projects are **fully inert**: no prompts fire and no block is written (D-04,
+success criterion #4). All capture is **offline-only** — no Obsidian, no MCP, no network (D-05 /
+T-09-05).
+
+```bash
+if [ "$(pp_run query platform-bindings --pick present 2>/dev/null)" = "true" ]; then
+  # ── D-05: edit-on-re-run — read existing block first ──────────────────────────
+  EXISTING=$(pp_run query generate-client-context --read 2>/dev/null || echo '{"present":false}')
+  EXISTING_PRESENT=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(String(o.present||'false'));}catch{process.stdout.write('false');}")
+
+  if [ "$EXISTING_PRESENT" = "true" ]; then
+    echo ""
+    echo "Existing client-context block found. Press Enter to keep each value, or type to replace it."
+    EXISTING_CLIENT_NAME=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(o.client_name||'');}catch{}" 2>/dev/null)
+    EXISTING_CLIENT_SLUG=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(o.client_slug||'');}catch{}" 2>/dev/null)
+    EXISTING_CODING=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(o.coding_standards||'');}catch{}" 2>/dev/null)
+    EXISTING_ARCH=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(o.architecture_patterns||'');}catch{}" 2>/dev/null)
+    EXISTING_UI=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(o.ui_brand_conventions||'');}catch{}" 2>/dev/null)
+    EXISTING_DOD=$(echo "$EXISTING" | node -e "const d=require('fs').readFileSync(0,'utf-8');try{const o=JSON.parse(d);process.stdout.write(o.definition_of_done||'');}catch{}" 2>/dev/null)
+  fi
+fi
+```
+
+**Field capture — one field at a time (D-01, D-02):** Prompt the user for each of the five fields
+sequentially. All five are required — **re-prompt on empty input until a non-empty value is given**
+(no skip, no catch-all). Multi-line values are accepted: instruct the user to type or paste, then
+enter a blank line (or a sentinel line such as `EOF`) to signal end-of-field. Do not call any
+network resource during capture.
+
+Capture these fields, in this order:
+
+1. **Client name** — the human-readable client or project name (e.g. "Acme Corp").
+   - On re-run: show the current value (`$EXISTING_CLIENT_NAME`) and let the user keep or replace.
+   - After capturing, derive a URL-safe slug via `pp_run query generate-slug` on the name; present
+     the suggested slug and let the user confirm or override. Store as `CLIENT_SLUG`.
+
+2. **Coding standards** — the conventions and rules the Build agent must follow (e.g. language,
+   style guide, patterns to use/avoid). Multi-line OK.
+   - On re-run: show `$EXISTING_CODING`.
+
+3. **Architecture patterns** — the structural patterns and constraints the Build agent must respect
+   (e.g. layering, module boundaries, framework idioms). Multi-line OK.
+   - On re-run: show `$EXISTING_ARCH`.
+
+4. **UI / brand conventions** — visual and component standards the Build agent must apply (e.g.
+   design system, color tokens, typography rules). Multi-line OK.
+   - On re-run: show `$EXISTING_UI`.
+
+5. **Definition of done** — the quality gates that must pass before any task is marked complete
+   (e.g. tests green, lint clean, accessibility checked). Multi-line OK.
+   - On re-run: show `$EXISTING_DOD`.
+
+**Write block** — after all five fields are captured, write them to a temp file and invoke the
+managed-block writer:
+
+```bash
+if [ "$(pp_run query platform-bindings --pick present 2>/dev/null)" = "true" ]; then
+  # Write collected values to a temp JSON file using node + JSON.stringify so that
+  # multi-line values, embedded quotes, backslashes, and $(...) sequences are encoded
+  # correctly (CR-02: an unquoted heredoc would produce invalid JSON for any multi-line
+  # field, breaking cmdGenerateClientContext with "Failed to parse JSON input").
+  TMP_CTX=$(mktemp /tmp/pp-client-ctx-XXXXXX.json)
+  CLIENT_NAME="$CLIENT_NAME" \
+  CLIENT_SLUG="$CLIENT_SLUG" \
+  CODING_STANDARDS="$CODING_STANDARDS" \
+  ARCHITECTURE_PATTERNS="$ARCHITECTURE_PATTERNS" \
+  UI_BRAND_CONVENTIONS="$UI_BRAND_CONVENTIONS" \
+  DEFINITION_OF_DONE="$DEFINITION_OF_DONE" \
+  node -e "
+const e = process.env;
+const fs = require('fs');
+fs.writeFileSync(process.argv[1], JSON.stringify({
+  client_name: e.CLIENT_NAME,
+  client_slug: e.CLIENT_SLUG,
+  coding_standards: e.CODING_STANDARDS,
+  architecture_patterns: e.ARCHITECTURE_PATTERNS,
+  ui_brand_conventions: e.UI_BRAND_CONVENTIONS,
+  definition_of_done: e.DEFINITION_OF_DONE
+}));
+" "$TMP_CTX"
+
+  # Invoke the Plan 09-01 writer — routes through updateSection, marker-bounded, idempotent
+  pp_run query generate-client-context --from-json "$TMP_CTX"
+  rm -f "$TMP_CTX"
+  echo "Client context written to CLAUDE.md (<!-- PP:client-context-start --> block)."
+fi
+```
+
+This writes a `## Client Context & Patterns` block bounded by
+`<!-- PP:client-context-start -->` … `<!-- PP:client-context-end -->` markers into the local
+CLAUDE.md (config-driven path, default `./.claude/CLAUDE.md`). The write is idempotent —
+re-running `/pp-init` replaces the bounded block, never duplicates it. All values stay local;
+no network or external service is involved.
+
+---
+
+## 4. Handoff routing (D-04)
+
+After git init, metadata, and remote wiring are complete, ask the user which workflow to
+continue with. `/pp-init` does NOT scaffold discovery session files itself — `/pp-discovery`
+self-generates them (D-03). Do not silently auto-chain to either option.
+
+Determine the smart default from signals captured in Steps 0–2:
+- `platform-bindings --pick present` == `true`, OR `provider` == `"gitlab"`, OR
+  `client_slug` is not `"internal"` → pre-select **`/pp-discovery`** (Pareto engagement
+  or client work).
+- Otherwise (internal project, known stack, no bindings) → pre-select
+  **`/pp-new-project`** (freeform planning, requirements, roadmap).
+
+Present to the user with `AskUserQuestion`:
+
+```text
+AskUserQuestion([
+  {
+    header: "Next step",
+    question: "Where would you like to go next?",
+    multiSelect: false,
+    options: [
+      {
+        label: "/pp-discovery (Recommended for client/Pareto projects)",
+        description: "Run the 13-session Discovery Sprint — self-generates all session files"
+      },
+      {
+        label: "/pp-new-project",
+        description: "Gather requirements and generate a phased roadmap for a known-stack project"
+      },
+      {
+        label: "Stop here",
+        description: "I will continue manually — the repo is initialized"
+      }
+    ]
+  }
+])
+```
+
+Pre-select the option matching the smart default computed above (indicate it with
+`(Recommended)` in the label, as shown). When the user confirms or overrides, invoke the
+chosen command or stop cleanly.
+
+---
+
+## 5. Commit
+
+Commit the `.planning/config.json` identity stub created in Step 2:
+
+```bash
+pp_run query commit "docs: initialize project" --files .planning/config.json
+```
+
+If `.planning/config.json` is the only new file, stage only that file. If other planning
+artifacts were created (e.g. `.planning/` directory structure), include them.
+
+</process>

package/pp-core/workflows/new-project.md

@@ -52,12 +52,65 @@ The document should describe what you want to build.
 
 <process>
 
+## 0. Platform-version preflight (Pareto satellite repos)
+
+**Runs before Setup. Inert for non-Pareto projects** — gated entirely on
+`.platform-bindings.json` existing, so generic projects skip it with no effect.
+
+A repo scaffolded by `/pareto-new-app` pins the Pareto platform at a specific
+`vX.Y.Z` tag (module `?ref=` pins, the `.gitlab-ci.yml` include `ref:`, and the
+canonical `.platform-bindings.json` → `platform.tag`). Project initiation is the
+moment to confirm the app is on the **latest** platform before any building
+starts — bumping after a milestone is built is far more expensive.
+
+```bash
+_PP_SHIM_NAME="pp-tools.cjs"; _PP_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; PP_TOOLS="${_PP_RUNTIME_ROOT}/pp-core/bin/${_PP_SHIM_NAME}"; if [ -f "$PP_TOOLS" ]; then pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif command -v pp-tools >/dev/null 2>&1; then PP_TOOLS="$(command -v pp-tools)"; pp_run() { "$PP_TOOLS" "$@"; }; elif [ -f "$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; else echo "ERROR: pp-tools.cjs not found at $PP_TOOLS and pp-tools is not on PATH. Run: npx -y @pareto4/pp-core@latest --claude --local" >&2; exit 1; fi; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${PP_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${PP_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+# Resolve pp_run before Step 1 — reader required for platform-bindings preflight (BIND-04)
+
+# Gate on presence via reader — absent file → {present:false} exit 0 (inert, step skipped, no jq)
+if [ "$(pp_run query platform-bindings --pick present 2>/dev/null)" = "true" ]; then
+  PINNED=$(pp_run query platform-bindings --pick platform.tag)
+  REPO=$(pp_run query platform-bindings --pick platform.repo)
+  HOST_FROM_BINDINGS=$(pp_run query platform-bindings --pick platform.host 2>/dev/null)
+  PLATFORM_HOST="${HOST_FROM_BINDINGS:-${HOST:-gitlab.com}}"
+  PLATFORM_REPO_URL="https://${PLATFORM_HOST}/${REPO}.git"
+  # Resolve latest STABLE tag from remote — never hard-block if offline (empty LATEST → skip drift check)
+  # Keep --refs to strip ^{} annotated-tag rows; --sort=-v:refname sorts server-side
+  # Stable filter fixes prerelease mis-ordering: git ranks v1.4.0-rc.1 after v1.4.0 (wrong by semver)
+  # semver-compare.cjs is the single blessed source for comparison — do NOT reimplement
+  REMOTE_TAGS=$(git ls-remote --tags --refs --sort=-v:refname "$PLATFORM_REPO_URL" 'v*' 2>/dev/null | sed 's#.*/##')
+  LATEST=$(printf '%s\n' "$REMOTE_TAGS" | node -e "
+const sc = require('${PP_TOOLS%/*}/lib/semver-compare.cjs');
+const lines = require('fs').readFileSync(0, 'utf-8').split('\n').map(s=>s.trim()).filter(Boolean);
+const stable = lines.filter(sc.isStableTripletSemver).sort(sc.compareSemverCore);
+process.stdout.write((stable[stable.length-1] || '') + '\n');
+" 2>/dev/null)
+  echo "platform preflight: pinned=${PINNED:-<none>} latest=${LATEST:-<unresolved>}"
+  if [ -n "$LATEST" ] && [ -n "$PINNED" ] && [ "$PINNED" != "$LATEST" ]; then
+    echo "PP_PLATFORM_DRIFT=1"
+  fi
+fi
+```
+
+**If the block printed `PP_PLATFORM_DRIFT=1`:** the app is pinned behind the
+latest platform tag. STOP before Setup and use `AskUserQuestion` to let the user
+choose:
+- **Bump first (recommended)** — pause initiation; bump the module `?ref=` pins,
+  the `.gitlab-ci.yml` include `ref:`, and `.platform-bindings.json` `platform.tag`
+  to `${LATEST}` (review `CHANGELOG.md` between the two tags for breaking changes),
+  then re-run `/pp-new-project`.
+- **Proceed on the older pin** — continue knowingly; record the deferral in
+  `PROJECT.md` so it's a conscious decision, not silent drift.
+
+If `LATEST` was unresolved (offline / no network), note it and proceed — never
+hard-block initiation on an unreachable remote. For non-Pareto repos the block is
+a no-op and this step is skipped entirely.
+
 ## 1. Setup
 
 **MANDATORY FIRST STEP — Execute these checks before ANY user interaction:**
 
 ```bash
-_PP_SHIM_NAME="pp-tools.cjs"; _PP_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; PP_TOOLS="${_PP_RUNTIME_ROOT}/pp-core/bin/${_PP_SHIM_NAME}"; if [ -f "$PP_TOOLS" ]; then pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif command -v pp-tools >/dev/null 2>&1; then PP_TOOLS="$(command -v pp-tools)"; pp_run() { "$PP_TOOLS" "$@"; }; elif [ -f "$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; else echo "ERROR: pp-tools.cjs not found at $PP_TOOLS and pp-tools is not on PATH. Run: npx -y @pareto4/pp-core@latest --claude --local" >&2; exit 1; fi; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${PP_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${PP_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
 INIT=$(pp_run query init.new-project)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_RESEARCHER=$(pp_run query agent-skills pp-project-researcher)