session-orchestrator 4.1.0 → 5.0.0

package/skills/bootstrap/_shared-template.md

@@ -24,21 +24,39 @@ Idempotency is handled by the writer itself:
 Shell:
 ```bash
 mkdir -p "$REPO_ROOT/.claude"
-node "$PLUGIN_ROOT/scripts/lib/rules-sync.mjs" --repo-root "$REPO_ROOT"
-cp "$PLUGIN_ROOT/templates/_shared/loop.md" "$REPO_ROOT/.claude/loop.md"
+export PLUGIN_ROOT REPO_ROOT CONFIRMED_ARCHETYPE
+RULES_RESULT=$(node --input-type=module <<'NODE'
+import { pathToFileURL } from 'node:url';
+const { syncBootstrapRules } = await import(pathToFileURL(`${process.env.PLUGIN_ROOT}/scripts/lib/baseline-archetypes.mjs`));
+const result = await syncBootstrapRules({ repoRoot: process.env.REPO_ROOT, archetype: process.env.CONFIRMED_ARCHETYPE || undefined });
+process.stdout.write(`${JSON.stringify(result)}\n`);
+if (result.status === 'error') process.exitCode = 2;
+NODE
+) || exit 2
+printf '%s\n' "$RULES_RESULT"
+while IFS= read -r _file; do BOOTSTRAP_FILES+=("$_file"); done \
+  < <(printf '%s\n' "$RULES_RESULT" | jq -r '.created[]')
+if [[ ! -e "$REPO_ROOT/.claude/loop.md" && ! -L "$REPO_ROOT/.claude/loop.md" ]]; then
+  cp "$PLUGIN_ROOT/templates/_shared/loop.md" "$REPO_ROOT/.claude/loop.md"
+  BOOTSTRAP_FILES+=(.claude/loop.md)
+fi
 ```
 
 The command prints a JSON report (`written` / `skipped` / `preserved` / `errors` / `warnings` / `sanitizer`) and exits non-zero on any error. Surface `errors[]` to the operator; a non-empty `preserved[]` is normal and means a repo-private rule was left alone.
 
 Also surface `sanitizer[]` (issue #1098) — `{file, line, kind, text}` records for citations that read fine inside the plugin repo and dangle once vendored (`repo-local-path`, `unresolvable-see-also`). The CLI additionally prints each one to stderr as `rules-sync: sanitizer <kind> <file>:<line> — <text>`. **Report it to the operator; do not act on it automatically** — the sanitizer never rewrites content and never changes the exit code, because silently stripping a citation would change a rule's meaning at vendoring time. A human decides whether the citation is a leak.
 
-Archetype-scoped entries in `rules/_index.md` resolve from `.orchestrator/bootstrap.lock`, which does not exist yet at this step — they report `archetype-unknown` and are skipped. The always-on rules (including `parallel-sessions.md`) are universal and vendor regardless. Re-run `/bootstrap --sync-rules` after the lock is written to pick up the archetype-scoped ones.
+The wrapper re-reads a configured private contract and passes its required plugin
+basenames into the canonical writer. The full set must resolve uniquely before
+any rule is written; source/provenance validation and local preservation still
+apply. On the public path, normal archetype filtering is unchanged. The selected
+ID is explicit during bootstrap; later `/bootstrap --sync-rules` can use the lock.
 
 Why: PSA-003 destructive-command safeguards require every consumer repo to carry the parallel-sessions rule. See issue #155. The `loop.md` vendor gives bare `/loop` a repo-aware maintenance prompt (issue #633 Hebel 3).
 
-Why one writer (issue #1060): a literal `cp` from a second source directory bypasses the pre-write validator AND lands a file carrying no provenance header. On the next `--sync-rules` a headerless file is classified as a repo-private override and preserved forever — so the plugin can never update it again, and whichever rival copy is smaller silently wins. `rules/` is the only source with a manifest, archetype scoping, a basename-collision guard and a pre-write validator, so it is the only sanctioned writer to `.claude/rules/`.
+Why one writer (issue #1060): a literal `cp` from a second source directory bypasses the pre-write validator AND lands a file carrying no provenance header. On the next `--sync-rules` a headerless file is classified as a repo-private override and preserved forever — so the plugin can never update it again, and whichever rival copy is smaller silently wins. For every basename declared in `rules/_index.md`, `rules-sync.mjs` is the sole writer: it owns the manifest, archetype scoping, basename-collision guard and pre-write validation. S99 may deliver baseline-only rules after excluding all plugin-owned basenames.
 
-Note: This step runs before the baseline-fetch step (S99/D99), and S99 must NOT overwrite a rule that `rules/` owns. The baseline's copy carries no provenance header, so letting it win would permanently mark the target as a repo-private override — the exact failure described above. `.claude/rules/parallel-sessions.md` has therefore been removed from the S99 manifest. Any other basename present in BOTH `rules/_index.md` and the S99 manifest has the same defect and needs the same treatment.
+Note: This step runs before S99/D99. Both the private local rule projection and the optional public fetch filter every basename in `rules/_index.md`, including currently nonmatching scoped entries. `parallel-sessions.md` and any future plugin-owned rule therefore remain under the same single writer.
 
 ---
 
@@ -48,7 +66,13 @@ Copy the opinionated agent templates into the consumer repo:
 
 ```bash
 mkdir -p "$REPO_ROOT/.claude/agents"
-cp "$PLUGIN_ROOT/skills/bootstrap/templates/agents/"*.md "$REPO_ROOT/.claude/agents/"
+for _source in "$PLUGIN_ROOT/skills/bootstrap/templates/agents/"*.md; do
+  _target=".claude/agents/$(basename "$_source")"
+  if [[ ! -e "$REPO_ROOT/$_target" && ! -L "$REPO_ROOT/$_target" ]]; then
+    cp "$_source" "$REPO_ROOT/$_target"
+    BOOTSTRAP_FILES+=("$_target")
+  fi
+done
 ```
 
 This scaffolds 3 opinionated agents (`project-discovery`, `project-code-review`, `project-quality-gate`) following CLAUDE.md Agent Authoring Rules. Consumer repos should edit descriptions/bodies to match project specifics — but keep the frontmatter structure intact (validated by `agent-frontmatter-invalid` probe).
@@ -103,7 +127,13 @@ vault:
 
 ## #baseline-fetch — Step S99: (Optional) Fetch Canonical Rules + Agents from Baseline
 
-This step is OPT-IN and only executes when ALL of the following are true:
+For `PATH_TYPE = private` and a confirmed archetype, this step applies only the
+validated local contract rule targets from `private-contract.md`. It is offline,
+rechecks conditional dependencies after scaffolding, preserves existing files,
+and fails closed on an invalid configured contract.
+
+For `PATH_TYPE = public`, the existing remote fetch remains OPT-IN and only
+executes when ALL of the following are true:
 - `baseline-ref` is present in Session Config (e.g., `baseline-ref: main`)
 - `GITLAB_TOKEN` env var is set
 - The session-orchestrator plugin includes `scripts/lib/fetch-baseline.mjs`
@@ -116,6 +146,23 @@ Without this step, rules arrive in the repo via Clank's weekly baseline sync MRs
 **Implementation:**
 
 ```bash
+if [[ "${PATH_TYPE:-public}" = "private" ]]; then
+  export PLUGIN_ROOT REPO_ROOT CONFIRMED_ARCHETYPE
+  BASELINE_RULES_RESULT=$(node --input-type=module <<'NODE'
+import { pathToFileURL } from 'node:url';
+const { applyBaselineRules } = await import(pathToFileURL(`${process.env.PLUGIN_ROOT}/scripts/lib/baseline-archetypes.mjs`));
+const result = await applyBaselineRules({
+  repoRoot: process.env.REPO_ROOT,
+  archetype: process.env.CONFIRMED_ARCHETYPE,
+});
+process.stdout.write(`${JSON.stringify(result)}\n`);
+if (result.status === 'error') process.exitCode = 2;
+NODE
+) || exit 2
+  printf '%s\n' "$BASELINE_RULES_RESULT"
+  while IFS= read -r _file; do BOOTSTRAP_FILES+=("$_file"); done \
+    < <(printf '%s\n' "$BASELINE_RULES_RESULT" | jq -r '.created[]')
+else
 BASELINE_REF=$(echo "$CONFIG" | jq -r '."baseline-ref" // empty')
 BASELINE_PROJECT_ID=$(echo "$CONFIG" | jq -r '."baseline-project-id" // "52"')
 
@@ -145,6 +192,19 @@ if [[ -n "$BASELINE_REF" && -n "${GITLAB_TOKEN:-}" && -n "${GITLAB_HOST:-}" && -
 .claude/rules/ai-agent.md
 .claude/rules/claude-code-usage.md
 MANIFEST
+  # Every plugin-owned basename is excluded, including currently unmatched scoped
+  # rules. rules-sync is their sole writer; ownership does not depend on scope.
+  export PLUGIN_ROOT RULES_MANIFEST
+  node --input-type=module <<'NODE'
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const { pluginRuleTargets } = await import(pathToFileURL(`${process.env.PLUGIN_ROOT}/scripts/lib/baseline-archetypes.mjs`));
+const owned = new Set(pluginRuleTargets(process.env.PLUGIN_ROOT));
+const files = readFileSync(process.env.RULES_MANIFEST, 'utf8').split('\n')
+  .filter(file => file && !owned.has(path.posix.basename(file)));
+writeFileSync(process.env.RULES_MANIFEST, files.join('\n') + '\n');
+NODE
 
   echo "Fetching canonical rules from baseline (project $BASELINE_PROJECT_ID, ref $BASELINE_REF)…"
   # The .mjs CLI is single-file: it prints ONE file body to stdout, exit 0 on success
@@ -153,10 +213,13 @@ MANIFEST
   SUCCESS_LOG=$(mktemp)
   while IFS= read -r rule_path; do
     [[ -z "$rule_path" ]] && continue
+    _RULE_CREATED=false
+    [[ -e "$REPO_ROOT/$rule_path" || -L "$REPO_ROOT/$rule_path" ]] || _RULE_CREATED=true
     mkdir -p "$REPO_ROOT/$(dirname "$rule_path")"
     if node "$PLUGIN_ROOT/scripts/lib/fetch-baseline.mjs" \
          "$BASELINE_PROJECT_ID" "$rule_path" "$BASELINE_REF" > "$REPO_ROOT/$rule_path"; then
       printf '%s\n' "$rule_path" >> "$SUCCESS_LOG"
+      if [[ "$_RULE_CREATED" = true ]]; then BOOTSTRAP_FILES+=("$rule_path"); fi
     else
       # A 404 (or any error) for one rule must not abort the batch — drop the empty
       # target the redirect created and continue with the next manifest line.
@@ -167,6 +230,8 @@ MANIFEST
   if [[ -s "$SUCCESS_LOG" ]]; then
     FETCHED_JSON=$(jq -R . < "$SUCCESS_LOG" | jq -s .)
     LOCK_FILE="$REPO_ROOT/.claude/.baseline-fetch.lock"
+    _FETCH_LOCK_CREATED=false
+    [[ -e "$LOCK_FILE" || -L "$LOCK_FILE" ]] || _FETCH_LOCK_CREATED=true
     mkdir -p "$REPO_ROOT/.claude"
     FETCHED_JSON="$FETCHED_JSON" BASELINE_PROJECT_ID="$BASELINE_PROJECT_ID" \
       BASELINE_REF="$BASELINE_REF" LOCK_FILE="$LOCK_FILE" \
@@ -183,6 +248,7 @@ MANIFEST
       writeFileSync(process.env.LOCK_FILE, JSON.stringify(lock, null, 2) + '\n');
     "
     echo "Wrote .claude/.baseline-fetch.lock ($(wc -l < "$SUCCESS_LOG" | tr -d ' ') files)"
+    if [[ "$_FETCH_LOCK_CREATED" = true ]]; then BOOTSTRAP_FILES+=(.claude/.baseline-fetch.lock); fi
   else
     echo "WARNING: baseline fetch produced no files; rules will arrive via Clank sync MRs (legacy path)" >&2
   fi
@@ -191,23 +257,39 @@ MANIFEST
 else
   echo "Skipping baseline fetch: baseline-ref / GITLAB_TOKEN / GITLAB_HOST not configured (legacy Clank-sync path)"
 fi
+fi
 ```
 
-**Failure handling:** If the fetch fails, this step DOES NOT abort bootstrap. The repo still has its scaffold; rules will arrive via the legacy Clank weekly sync MR. The user is informed via stderr.
+**Failure handling:** A private contract/apply error aborts bootstrap. For the public optional remote path, if the fetch fails, this step DOES NOT abort bootstrap. The repo still has its scaffold; rules will arrive via the legacy Clank weekly sync MR. The user is informed via stderr.
 
-**Idempotency:** Re-running bootstrap on an existing repo will overwrite `.claude/rules/*.md` files. Local edits to baseline rules in a repo will be lost on re-fetch — this is intentional (rules are canonical). Repo-specific extensions belong in `.claude/rules/local/*.md` (not fetched).
+**Idempotency:** Private local rules preserve existing files and report them for review. On the public optional remote path, re-running bootstrap on an existing repo will overwrite `.claude/rules/*.md` files. Local edits to baseline rules in a repo will be lost on re-fetch — this is intentional (rules are canonical). Repo-specific extensions belong in `.claude/rules/local/*.md` (not fetched).
 
 ---
 
 ## #quality-gate-policy — Step 6.5: Quality-Gate Policy File (#183)
 
-Write the canonical quality-gate commands to `.orchestrator/policy/quality-gates.json`. Bootstrap detects the package manager and writes sensible defaults; users may hand-edit afterwards.
+Write canonical commands to `.orchestrator/policy/quality-gates.json`. A private
+contract supplies exact test/typecheck/lint IDs, with `false` and an unavailable
+reason for absent IDs. Public bootstrap retains package-manager defaults.
 
 **Idempotency:** Skip this step if `.orchestrator/policy/quality-gates.json` already exists. Do not overwrite user edits.
 
 ```bash
 POLICY_FILE="$REPO_ROOT/.orchestrator/policy/quality-gates.json"
-if [[ ! -f "$POLICY_FILE" ]]; then
+if [[ "${PATH_TYPE:-public}" = private ]]; then
+  export PLUGIN_ROOT REPO_ROOT CONFIRMED_ARCHETYPE
+  POLICY_RESULT=$(node --input-type=module <<'NODE'
+import { pathToFileURL } from 'node:url';
+const { writeBaselineQualityPolicy } = await import(pathToFileURL(`${process.env.PLUGIN_ROOT}/scripts/lib/baseline-archetypes.mjs`));
+const result = await writeBaselineQualityPolicy({ repoRoot: process.env.REPO_ROOT, archetype: process.env.CONFIRMED_ARCHETYPE });
+process.stdout.write(`${JSON.stringify(result)}\n`);
+if (result.status === 'error') process.exitCode = 2;
+NODE
+) || exit 2
+  printf '%s\n' "$POLICY_RESULT"
+  while IFS= read -r _file; do BOOTSTRAP_FILES+=("$_file"); done \
+    < <(printf '%s\n' "$POLICY_RESULT" | jq -r '.created[]')
+elif [[ ! -e "$POLICY_FILE" && ! -L "$POLICY_FILE" ]]; then
   mkdir -p "$REPO_ROOT/.orchestrator/policy"
   # Detect package manager via scripts/lib/package-manager.mjs (falls back to npm defaults)
   PM_JSON="$(node --input-type=module -e "
@@ -226,6 +308,7 @@ if [[ ! -f "$POLICY_FILE" ]]; then
     "rationale": "Canonical quality-gate commands. Generated by bootstrap. Edit to change test/typecheck/lint invocations across skills. Schema: .orchestrator/policy/quality-gates.schema.json",
     "commands": $cmds
   }' > "$POLICY_FILE"
+  BOOTSTRAP_FILES+=(.orchestrator/policy/quality-gates.json)
   echo "Wrote $POLICY_FILE"
 fi
 ```
@@ -234,16 +317,18 @@ fi
 
 ## #state-md-scaffold — Step 6.6: STATE.md Scaffold (#184)
 
-Scaffold a placeholder `.claude/STATE.md` using the template at `skills/bootstrap/STATE.md.template`. The placeholder records `status: idle` — sessions overwrite it at Pre-Wave 1b.
+Scaffold a placeholder `.claude/STATE.md`. <!-- path-check: example -->
+Use the template at `skills/bootstrap/STATE.md.template`; the placeholder records `status: idle` — sessions overwrite it at Pre-Wave 1b.
 
-**Idempotency:** Skip if `.claude/STATE.md` already exists.
+**Idempotency:** Skip if `.claude/STATE.md` already exists. <!-- path-check: example -->
 
 ```bash
 STATE_FILE="$REPO_ROOT/.claude/STATE.md"
-if [[ ! -f "$STATE_FILE" ]]; then
+if [[ ! -e "$STATE_FILE" && ! -L "$STATE_FILE" ]]; then
   mkdir -p "$REPO_ROOT/.claude"
   ISO_NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
   sed "s|<ISO>|$ISO_NOW|g" "$PLUGIN_ROOT/skills/bootstrap/STATE.md.template" > "$STATE_FILE"
+  BOOTSTRAP_FILES+=(.claude/STATE.md)
   echo "Wrote $STATE_FILE"
 fi
 ```

package/skills/bootstrap/deep-template.md

@@ -5,6 +5,9 @@
 
 Deep tier is a strict superset of Standard tier. Execute all Standard-tier steps first, then the Deep-specific steps below.
 
+Keep the inherited `BOOTSTRAP_FILES` array. Append each new governance file by
+its relative filename when created; do not append existing files or directories.
+
 ## Step 1–8: Execute Standard Tier
 
 Read and execute `skills/bootstrap/standard-template.md` Steps 1–8 in full. Do not skip any step.
@@ -30,7 +33,13 @@ If `VCS` is empty or `none`, skip CI pipeline, issue templates, MR/PR template,
 
 ## Step D1: CI Pipeline
 
-Create the CI pipeline file. Mutually exclusive — create exactly one based on `VCS`.
+When `PATH_TYPE = private`, keep the selected baseline's rendered CI and
+`ci.profile` from `private-contract.md`. Respect `ci.required: false`; do not
+create a generic Node pipeline for an exempt archetype. A required CI missing
+from staging already aborts. Resolve VCS mismatch explicitly before changing
+canonical CI. Skip the public D1 examples below and continue at D2.
+
+For `PATH_TYPE = public`, create exactly one pipeline based on `VCS`.
 
 ### If `VCS = gitlab`: `.gitlab-ci.yml`
 
@@ -208,7 +217,7 @@ Replace `<YYYY-MM-DD>` with today's date in ISO 8601 format (e.g., `2026-04-16`)
 mkdir -p "$REPO_ROOT/.gitlab/issue_templates"
 ```
 
-Write `.gitlab/issue_templates/Bug.md`:
+In the consuming repository, create `.gitlab/issue_templates/Bug.md`: <!-- path-check: example -->
 
 ```markdown
 ## Summary
@@ -239,7 +248,7 @@ Write `.gitlab/issue_templates/Bug.md`:
 <!-- Screenshots, logs, related issues -->
 ```
 
-Write `.gitlab/issue_templates/Feature.md`:
+In the consuming repository, create `.gitlab/issue_templates/Feature.md`: <!-- path-check: example -->
 
 ```markdown
 ## Summary
@@ -334,7 +343,7 @@ labels: enhancement
 mkdir -p "$REPO_ROOT/.gitlab/merge_request_templates"
 ```
 
-Write `.gitlab/merge_request_templates/Default.md`:
+In the consuming repository, create `.gitlab/merge_request_templates/Default.md`: <!-- path-check: example -->
 
 ```markdown
 ## Summary
@@ -492,12 +501,11 @@ If the call fails, log the structured message above and continue. Raw API respon
 
 Canonical implementation in [`_shared-template.md#parallel-sessions-rule`](_shared-template.md).
 
-Run `node "$PLUGIN_ROOT/scripts/lib/rules-sync.mjs" --repo-root "$REPO_ROOT"` — it vendors every
-rule registered in `rules/_index.md` (idempotent: missing→create, identical→skip, differs→overwrite),
-and it is the only writer that applies the pre-write validator, the basename-collision guard and the
-copy-on-write branch that preserves repo-private rules. The shared partial also runs
-`cp "$PLUGIN_ROOT/templates/_shared/loop.md" "$REPO_ROOT/.claude/loop.md"` so bare `/loop` gets a
-repo-aware maintenance prompt. See shared partial for full shell command. Issues #155, #633, #1060.
+Execute the shared partial's `syncBootstrapRules` action. It supplies private
+required basenames to `scripts/lib/rules-sync.mjs`, preserving its manifest,
+pre-write validation and local-override checks. The partial appends actual newly
+created rule paths, and creates `.claude/loop.md` only when missing. See the
+shared partial for the executable shell command. Issues #155, #633, #1060.
 
 Note: Runs before D99. D99 (via inherited S99) no longer fetches `parallel-sessions.md` from the
 baseline — that entry was removed from the S99 manifest in #1060. The baseline copy carries no
@@ -511,11 +519,13 @@ Deep tier creates both learnings and sessions metrics plus a schema-linking READ
 
 ```bash
 mkdir -p "$REPO_ROOT/.orchestrator/metrics"
-[[ -f "$REPO_ROOT/.orchestrator/metrics/learnings.jsonl" ]] || \
-  : > "$REPO_ROOT/.orchestrator/metrics/learnings.jsonl"
-[[ -f "$REPO_ROOT/.orchestrator/metrics/sessions.jsonl" ]] || \
-  : > "$REPO_ROOT/.orchestrator/metrics/sessions.jsonl"
-
+for _file in learnings.jsonl sessions.jsonl; do
+  if [[ ! -e "$REPO_ROOT/.orchestrator/metrics/$_file" && ! -L "$REPO_ROOT/.orchestrator/metrics/$_file" ]]; then
+    : > "$REPO_ROOT/.orchestrator/metrics/$_file"
+    BOOTSTRAP_FILES+=(".orchestrator/metrics/$_file")
+  fi
+done
+if [[ ! -e "$REPO_ROOT/.orchestrator/metrics/README.md" && ! -L "$REPO_ROOT/.orchestrator/metrics/README.md" ]]; then
 cat > "$REPO_ROOT/.orchestrator/metrics/README.md" <<'README'
 # Metrics
 
@@ -530,6 +540,8 @@ Schema: https://github.com/Kanevry/session-orchestrator
 **Do NOT gitignore** — these files are project artifacts intended to persist
 across sessions and contributors.
 README
+  BOOTSTRAP_FILES+=(.orchestrator/metrics/README.md)
+fi
 ```
 
 **Idempotent.** Existing files are preserved.
@@ -547,8 +559,10 @@ Standard-template Step S99 already executed as part of "Step 1–8: Execute Stan
 No additional fetch action is needed here.
 
 If S99 ran successfully, `.claude/rules/*.md` and `.claude/.baseline-fetch.lock` are already written
-to `$REPO_ROOT`. These files are included in the Deep commit at Step D8 via the `.claude/` entry
-in `BOOTSTRAP_FILES`. If S99 was skipped, rules arrive via the legacy Clank weekly sync MR path.
+to `$REPO_ROOT`. Their individual newly created paths remain in `BOOTSTRAP_FILES`
+for the Deep commit at Step D8. If the private contract applies, S99 already
+delivered its local filtered rule union. If public S99 was skipped, rules arrive
+via the legacy Clank weekly sync MR path.
 
 ---
 
@@ -580,6 +594,8 @@ Write `.orchestrator/bootstrap.lock` **atomically** (mktemp + mv prevents a corr
 process is interrupted mid-write):
 
 ```bash
+_LOCK_CREATED=false
+[[ -e "$REPO_ROOT/.orchestrator/bootstrap.lock" || -L "$REPO_ROOT/.orchestrator/bootstrap.lock" ]] || _LOCK_CREATED=true
 _LOCK_TMP=$(mktemp "$REPO_ROOT/.orchestrator/bootstrap.lock.XXXXXX")
 cat > "$_LOCK_TMP" << LOCK
 # .orchestrator/bootstrap.lock
@@ -592,6 +608,7 @@ plugin-version: <session-orchestrator plugin version — read from $PLUGIN_ROOT/
 bootstrapped-at: <current ISO 8601 UTC — same value as timestamp; distinct field for age-validation probe>
 LOCK
 mv "$_LOCK_TMP" "$REPO_ROOT/.orchestrator/bootstrap.lock"
+if [[ "$_LOCK_CREATED" = true ]]; then BOOTSTRAP_FILES+=(.orchestrator/bootstrap.lock); fi
 ```
 
 Set `source` using the same logic as fast-template Step 5.
@@ -604,16 +621,9 @@ Stage all created files and commit:
 
 ```bash
 cd "$REPO_ROOT"
-BOOTSTRAP_FILES=(
-  CLAUDE.md AGENTS.md .gitignore README.md .orchestrator/bootstrap.lock
-  .orchestrator/policy/quality-gates.json
-  package.json pyproject.toml tsconfig.json eslint.config.mjs .prettierrc
-  .editorconfig src/ tests/ CHANGELOG.md CODEOWNERS
-  .gitlab/ .github/ .claude/
-)
 # Add only the files bootstrap created — no sweeping -u/-A to avoid catching pre-existing files
-for _f in "${BOOTSTRAP_FILES[@]}"; do
-  [[ -e "$_f" ]] && git add -- "$_f"
+for _f in ${BOOTSTRAP_FILES[@]+"${BOOTSTRAP_FILES[@]}"}; do
+  [[ -f "$_f" && ! -L "$_f" ]] && git add -- "$_f"
 done
 git commit -m "chore: bootstrap (deep)"
 ```

package/skills/bootstrap/fast-template.md

@@ -14,6 +14,10 @@
 
 Intentionally absent: `package.json`, frameworks, tests, CI config. The feature that follows brings its own stack.
 
+Maintain the inherited `BOOTSTRAP_FILES` array and append every newly created
+relative file at creation. Preserve existing owner files and never reset this
+array when Fast is inherited by Standard or Deep.
+
 ## Step 1: Ensure Git Repo is Initialized
 
 ```bash
@@ -38,7 +42,12 @@ After `public-fallback.md` completes CLAUDE.md generation, continue to Step 2b t
 
 **If `PATH_TYPE = private`:**
 
-Use the baseline scripts at `$BASELINE_PATH` as directed by the baseline's own documentation. Proceed with baseline-driven CLAUDE.md generation, then continue to Step 2b.
+For Standard/Deep inheritance, `private-contract.md` already rendered the
+instruction file and stack into the repo. Preserve those files and continue
+to Step 2b; use its quality-gate command mapping for missing Session Config
+fields. Preserve the rendered README and `.gitignore` in subsequent Fast steps.
+For a standalone Fast tier, no archetype is selected: use `public-fallback.md`'s
+minimal Fast instruction-file generation and report `source: plugin-template`.
 
 **Step 2b: Verify Session Config block.** After writing or updating CLAUDE.md, check for the sentinel string `## Session Config`:
 
@@ -107,7 +116,8 @@ elif ls *.ts *.js package.json 2>/dev/null | head -1 | grep -q .; then STACK="no
 else STACK="generic"; fi
 ```
 
-Write `.gitignore` with the appropriate content:
+If absent, write `.gitignore` with the appropriate content and append `.gitignore`
+to `BOOTSTRAP_FILES`. Preserve an existing file.
 
 **Generic (no stack detected):**
 ```gitignore
@@ -166,6 +176,10 @@ Note: `.orchestrator/` is NOT gitignored — `bootstrap.lock` must be committed.
 
 Vendor the canonical always-on rules from the plugin's `rules/` library into `$REPO_ROOT/.claude/rules/`. `rules/` is the single source of truth for every distributable rule — never `cp` a rule file from anywhere else.
 
+`syncBootstrapRules` calls the canonical `scripts/lib/rules-sync.mjs` writer.
+Standalone Fast uses ordinary plugin rules without private archetype selection;
+inherited Fast passes the confirmed contract ID and records all created paths.
+
 Idempotency is handled by the writer itself:
 - Missing → create
 - Exists, plugin-owned (first line is the `<!-- source: session-orchestrator plugin ... -->` header) and byte-identical → skip silently
@@ -175,11 +189,28 @@ Idempotency is handled by the writer itself:
 Shell:
 ```bash
 mkdir -p "$REPO_ROOT/.claude"
-node "$PLUGIN_ROOT/scripts/lib/rules-sync.mjs" --repo-root "$REPO_ROOT"
-cp "$PLUGIN_ROOT/templates/_shared/loop.md" "$REPO_ROOT/.claude/loop.md"
+export PLUGIN_ROOT REPO_ROOT CONFIRMED_ARCHETYPE
+RULES_RESULT=$(node --input-type=module <<'NODE'
+import { pathToFileURL } from 'node:url';
+const { syncBootstrapRules } = await import(pathToFileURL(`${process.env.PLUGIN_ROOT}/scripts/lib/baseline-archetypes.mjs`));
+const result = await syncBootstrapRules({ repoRoot: process.env.REPO_ROOT,
+  archetype: process.env.CONFIRMED_ARCHETYPE || undefined, minimal: !process.env.CONFIRMED_ARCHETYPE });
+process.stdout.write(`${JSON.stringify(result)}\n`);
+if (result.status === 'error') process.exitCode = 2;
+NODE
+) || exit 2
+printf '%s\n' "$RULES_RESULT"
+while IFS= read -r _file; do BOOTSTRAP_FILES+=("$_file"); done \
+  < <(printf '%s\n' "$RULES_RESULT" | jq -r '.created[]')
+if [[ ! -e "$REPO_ROOT/.claude/loop.md" && ! -L "$REPO_ROOT/.claude/loop.md" ]]; then
+  cp "$PLUGIN_ROOT/templates/_shared/loop.md" "$REPO_ROOT/.claude/loop.md"
+  BOOTSTRAP_FILES+=(.claude/loop.md)
+fi
 ```
 
-The command prints a JSON report (`written` / `skipped` / `preserved` / `errors` / `warnings` / `sanitizer`) and exits non-zero on any error. At fast tier `.orchestrator/bootstrap.lock` does not exist yet (Step 5 writes it), so archetype-scoped entries report `archetype-unknown` and are skipped — the always-on rules vendor regardless.
+The command prints a JSON report and exits non-zero on any error. At standalone
+Fast tier the lock and selected ID are absent, so scoped rules are skipped.
+Inherited Fast delivers private required targets through the same writer.
 
 Surface `errors[]` and `sanitizer[]` to the operator. `sanitizer[]` (issue #1098) carries `{file, line, kind, text}` records for citations that read fine inside the plugin repo and dangle once vendored (`repo-local-path`, `unresolvable-see-also`); the CLI also prints each to stderr as `rules-sync: sanitizer <kind> <file>:<line> — <text>`. **Report it, do not act on it automatically** — it never rewrites content and never changes the exit code, so a human decides whether the citation is a leak.
 
@@ -189,6 +220,9 @@ Why one writer (issue #1060): a literal `cp` from a second source directory bypa
 
 ## Step 4: Generate README.md
 
+If absent, write the stub below and append `README.md` to `BOOTSTRAP_FILES`.
+Preserve an existing README.
+
 ```markdown
 # <REPO_NAME>
 
@@ -207,6 +241,8 @@ Write `.orchestrator/bootstrap.lock` **atomically** (mktemp + mv prevents a corr
 process is interrupted mid-write):
 
 ```bash
+_LOCK_CREATED=false
+[[ -e "$REPO_ROOT/.orchestrator/bootstrap.lock" || -L "$REPO_ROOT/.orchestrator/bootstrap.lock" ]] || _LOCK_CREATED=true
 _LOCK_TMP=$(mktemp "$REPO_ROOT/.orchestrator/bootstrap.lock.XXXXXX")
 cat > "$_LOCK_TMP" << LOCK
 # .orchestrator/bootstrap.lock
@@ -219,6 +255,7 @@ plugin-version: <session-orchestrator plugin version — read from $PLUGIN_ROOT/
 bootstrapped-at: <current ISO 8601 UTC — same value as timestamp; distinct field for age-validation probe>
 LOCK
 mv "$_LOCK_TMP" "$REPO_ROOT/.orchestrator/bootstrap.lock"
+if [[ "$_LOCK_CREATED" = true ]]; then BOOTSTRAP_FILES+=(.orchestrator/bootstrap.lock); fi
 ```
 
 Set `source`:
@@ -231,10 +268,9 @@ Stage all created files and commit:
 
 ```bash
 cd "$REPO_ROOT"
-BOOTSTRAP_FILES=(CLAUDE.md AGENTS.md .gitignore README.md .orchestrator/bootstrap.lock .claude/rules/parallel-sessions.md)
 # Add only the files bootstrap created — no sweeping -u/-A to avoid catching pre-existing files
-for _f in "${BOOTSTRAP_FILES[@]}"; do
-  [[ -e "$_f" ]] && git add -- "$_f"
+for _f in ${BOOTSTRAP_FILES[@]+"${BOOTSTRAP_FILES[@]}"}; do
+  [[ -f "$_f" && ! -L "$_f" ]] && git add -- "$_f"
 done
 git commit -m "chore: bootstrap (fast)"
 ```

package/skills/bootstrap/intensity-heuristic.md

@@ -8,7 +8,7 @@
 After executing this algorithm, report:
 
 - `RECOMMENDED_TIER`: `fast` | `standard` | `deep`
-- `RECOMMENDED_ARCHETYPE`: `static-html` | `node-minimal` | `nextjs-minimal` | `python-uv` | `null`
+- `RECOMMENDED_ARCHETYPE`: a validated private contract ID, one of the public IDs, or `null`
 - `HEURISTIC_REASON`: one sentence explaining the recommendation (shown to user)
 - `ARCHETYPE_CONFIDENCE`: `high` | `low` (used to decide whether to ask the optional second question)
 
@@ -54,7 +54,13 @@ Examples:
 
 **Fast tier:** Always `RECOMMENDED_ARCHETYPE = null`, `ARCHETYPE_CONFIDENCE = high`. No stack needed — skip to output.
 
-**Private path (baseline configured):** Always `RECOMMENDED_ARCHETYPE = null` at this stage. The baseline's own archetype selector is used during Standard/Deep scaffolding. Set `ARCHETYPE_CONFIDENCE = high`.
+**Private path (valid configured contract):** Use `BOOTSTRAP_CONTRACT.selected.id`
+from Phase 0.5 and set `ARCHETYPE_CONFIDENCE = high` when markers match. An
+explicit user ID must pass the reader's `--archetype` lookup and takes priority.
+If no markers match, set `RECOMMENDED_ARCHETYPE = null` and
+`ARCHETYPE_CONFIDENCE = low`; select from the returned ordered catalog using
+`private-contract.md` before Standard/Deep scaffolding. Detection follows the
+exported signal predicates and priority; no public default applies here.
 
 **Public path + Standard or Deep:** Scan the prompt for these signals:
 
@@ -66,7 +72,7 @@ Examples:
 | python, py, data, daten, ml, machine learning, api (python context), django, fastapi, flask, pandas, numpy | `python-uv` | high |
 | Ambiguous — prompt mentions multiple stacks, no clear frontend/backend split, or is too vague (e.g., "Ich brauche ein Projekt", "neues Repo", "etwas bauen") | `node-minimal` (safe default) | `low` |
 
-When `ARCHETYPE_CONFIDENCE = low`, the bootstrap skill will ask a second `AskUserQuestion` to confirm the archetype. `node-minimal` is the pre-selected default for that question.
+On the public path, when `ARCHETYPE_CONFIDENCE = low`, the bootstrap skill will ask a second `AskUserQuestion` to confirm the archetype. `node-minimal` is the pre-selected default for that question.
 
 ## Step 5: Output
 
@@ -74,7 +80,7 @@ Return all four values to `SKILL.md` Phase 1:
 
 ```
 RECOMMENDED_TIER: fast | standard | deep
-RECOMMENDED_ARCHETYPE: static-html | node-minimal | nextjs-minimal | python-uv | null
+RECOMMENDED_ARCHETYPE: <validated private ID> | static-html | node-minimal | nextjs-minimal | python-uv | null
 HEURISTIC_REASON: <one sentence>
 ARCHETYPE_CONFIDENCE: high | low
 ```

package/skills/bootstrap/private-contract.md

@@ -0,0 +1,119 @@
+# Configured Baseline Bootstrap
+
+Use this flow only after `public-fallback.md` returned `PATH_TYPE = private`.
+The configured local baseline owns the archetype catalog. The plugin consumes
+its validated, reduced export; it carries no private archetype table.
+
+## Select
+
+For Standard/Deep, use the `selected.id` returned by Phase 0.5 when repository
+markers match. An explicit owner-supplied ID takes precedence: validate it with
+`--archetype` before accepting it. A user description can help present choices,
+but cannot invent a catalog ID. When `selected` is null, present the returned
+`archetypes` in `order`, showing their runtime, package manager, UI/API and deploy
+metadata. Ask for the needed selection; paginate if the UI limits option count.
+Do not substitute a public default for missing evidence or an invalid choice.
+
+Once selected, set `CONFIRMED_ARCHETYPE` and refresh the contract:
+
+```bash
+BOOTSTRAP_CONTRACT=$(node "$PLUGIN_ROOT/scripts/baseline-archetypes.mjs" \
+  --repo "$REPO_ROOT" --archetype "$CONFIRMED_ARCHETYPE") || exit 2
+export BOOTSTRAP_CONTRACT
+```
+
+`status: error` aborts before scaffolding. Its reason is safe to report; do not
+print baseline paths, raw producer diagnostics, or private catalog files.
+`insufficient-evidence` is a selection state, not permission to use `node-minimal`.
+Fast tier has no archetype; use the plugin's minimal instruction-file flow and
+skip this file's scaffold/rules actions until upgrading to Standard/Deep.
+
+## Scaffold
+
+Execute this before Standard inherits the Fast steps. It runs only the local
+baseline's `render_archetype_dir`, `render_shared_and_substitute`, and
+`render_archetype_metadata` functions in temporary staging. It excludes all
+staged rules; S99 below and `rules-sync` own rule delivery. It never invokes the
+interactive setup script, package installation, Git, or a remote service.
+
+```bash
+export PLUGIN_ROOT REPO_ROOT CONFIRMED_ARCHETYPE REPO_NAME
+SCAFFOLD_RESULT=$(node --input-type=module <<'NODE'
+import { pathToFileURL } from 'node:url';
+const { scaffoldBaselineArchetype } = await import(pathToFileURL(`${process.env.PLUGIN_ROOT}/scripts/lib/baseline-archetypes.mjs`));
+const result = await scaffoldBaselineArchetype({
+  repoRoot: process.env.REPO_ROOT,
+  archetype: process.env.CONFIRMED_ARCHETYPE,
+  projectName: process.env.REPO_NAME,
+});
+process.stdout.write(`${JSON.stringify(result)}\n`);
+if (result.status === 'error') process.exitCode = 2;
+NODE
+) || exit 2
+printf '%s\n' "$SCAFFOLD_RESULT"
+while IFS= read -r _file; do BOOTSTRAP_FILES+=("$_file"); done \
+  < <(printf '%s\n' "$SCAFFOLD_RESULT" | jq -r '.created[]')
+```
+
+The report lists relative `created` and `preserved` files plus `unavailableGates`. Add only `created`
+files to `BOOTSTRAP_FILES`; an existing file is preserved for owner review.
+All sources and destinations are checked for symlinks before the first copy.
+The renderer's commands are fixed function calls; exported `commands` and
+`qualityGates[].command` remain data throughout lookup and staging.
+
+Continue Fast's common steps, preserving the rendered instruction files,
+README, manifests and configuration. Then skip Standard's four public stack
+sections and continue at Step 3a, S99 and the lock/quality-policy steps.
+
+## Expectations
+
+Use `selected.runtimes`, `packageManagers`, `ui`, `api`, `deploy`, `commands`,
+`qualityGates`, `ci`, and `browserAutomation` as the scaffold expectations.
+Keep rendered command documentation and CI. Staging normalizes new Session
+Config `test-command`, `typecheck-command`, and `lint-command` from exactly
+matching `qualityGates[].id` values (`test`, `typecheck`, `lint`). An absent gate
+gets the literal failing command `false` and an unavailable explanation, so a
+later generic gate runner cannot report an unsupported check as passing. No
+other ID is silently relabeled. Existing owner instruction files are preserved.
+
+For private verification, enumerate the selected `qualityGates` and report each
+declared result. Separately report absent test/typecheck/lint slots as
+unavailable; do not execute their `false` placeholders as if they were declared
+checks, or claim that all three generic checks passed. Command execution is a
+later explicit bootstrap step, separate from lookup and staging. Step 6.5 writes
+the same exact mapping to a new quality policy, whose commands take precedence
+at runtime. Existing owner policy is preserved; report any divergence for review.
+The generic quality runner is unchanged.
+
+Deep D1 preserves the baseline CI and its `ci.profile`. If `ci.required` is
+false, do not create a public Node CI pipeline. If true and the baseline did
+not render CI, staging fails. VCS mismatch or a required translation needs an
+explicit owner choice; do not silently replace the canonical CI with a public
+template. The remaining Deep governance steps apply normally.
+
+## Rules
+
+S99 re-reads the selected contract after rendering, so dependency-conditional
+targets include the new package manifest. `ruleTargets` is the exported union;
+`pluginRuleTargets` is its intersection with all basenames in `rules/_index.md`.
+Only `baselineRules` may be copied from the local baseline. Every source is a
+validated relative file under `.claude/rules/` or
+`templates/shared/.claude/rules/`, and every target belongs to that union.
+Existing rules are preserved. Plugin rule basenames, including
+`parallel-sessions.md`, are written only by `rules-sync.mjs`. Step 3a invokes
+`syncBootstrapRules`, which reloads the contract and passes `pluginRuleTargets`
+as the writer's validated required basenames. This delivers private requirements
+even when plugin scope tags do not name that archetype. The same action backs
+later `/bootstrap --sync-rules`, resolving the explicit ID, then the lock ID,
+then repository markers. Public/default rule selection remains unchanged.
+Later sync of a valid Fast/null lock without stack markers also uses ordinary
+plugin rules; a configured contract must still validate before that refresh.
+
+## Created files
+
+Keep one `BOOTSTRAP_FILES` array throughout inherited Fast/Standard/Deep steps.
+Each writer appends only relative files it actually creates; do not replace the
+array with a stack-specific list. Existing owner files and directories are never
+added merely because they exist. A repeated writer reporting `created: []`
+leaves accumulated paths intact. New governance files are appended individually
+at creation, and commit steps consume this accumulated list without broad globs.