@lovehlmmm/primekit 1.0.0

package/skills/bootstrap/references/workflow-auto.md

@@ -0,0 +1,55 @@
+# Auto Workflow (`--auto`) — Explicit Opt-In
+
+**Thinking level:** Ultrathink
+**User gates:** Design approval only. All other phases proceed automatically because the user explicitly selected `--auto`.
+
+The opening brainstorm contract in the parent skill is already satisfied;
+explicit auto mode may proceed without a routine approval pause.
+
+## Step 1: Research
+
+Spawn multiple `researcher` subagents in parallel:
+- Explore request, idea validation, challenges, best solutions
+- Keep every report ≤150 lines
+
+No user gate — proceed automatically.
+
+## Step 2: Tech Stack
+
+1. Use `planner` + multiple `researcher` subagents in parallel for best-fit stack
+2. Write tech stack to `./docs` directory
+
+No user gate — auto-select best option.
+
+## Step 3: Wireframe & Design
+
+1. Use `ui-ux-designer` + `researcher` subagents in parallel:
+   - Research style, trends, fonts (predict Google Fonts name, NOT just Inter/Poppins), colors, spacing, positions
+   - Describe assets for `pk:ai-multimodal` skill generation
+2. `ui-ux-designer` creates:
+   - Design guidelines at the documentation path discovered from repository instructions
+   - Wireframes in HTML at `./docs/wireframe/`
+3. If no logo provided: generate with `pk:ai-multimodal` skill
+4. Screenshot wireframes with `pk:agent-browser` -> save to `./docs/wireframes/`
+
+**Gate:** Ask user to approve design. Repeat if rejected.
+
+**Image tools:** `pk:ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 4: Planning
+
+Activate **pk:plan** skill: `/pk:plan --auto <requirements>`
+- Planning skill auto-detects complexity and picks appropriate mode
+- Creates plan directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+
+No user gate after planning in explicit auto mode — proceed to implementation.
+
+## Step 5: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **pk:cook** skill: `/pk:cook --auto <plan-path>`
+- Skips cook review gates because `--auto` was explicitly requested
+- Auto-approves if score≥9.5 and 0 critical issues
+- Continues through all phases without stopping

package/skills/bootstrap/references/workflow-fast.md

@@ -0,0 +1,53 @@
+# Fast Workflow (`--fast`)
+
+**Thinking level:** Think hard
+**User gates:** Fast pre-planning path, then normal cook review gates.
+
+The opening brainstorm contract in the parent skill is already satisfied; fast
+mode reduces research overhead, not intent quality.
+
+## Step 1: Combined Research & Planning
+
+All research happens in parallel, then feeds into planning:
+
+**Parallel research batch** (spawn these simultaneously):
+- 2 `researcher` subagents (max 5 sources each): explore request, validate idea, find solutions
+- 2 `researcher` subagents (max 5 sources each): find best-fit tech stack
+- 2 `researcher` subagents (max 5 sources each): research design style, trends, fonts, colors, spacing, positions
+  - Predict Google Fonts name (NOT just Inter/Poppins)
+  - Describe assets for `pk:ai-multimodal` generation
+
+Keep all reports ≤150 lines.
+
+## Step 2: Design
+
+1. `ui-ux-designer` subagent analyzes research, creates:
+   - Design guidelines at the documentation path discovered from repository instructions
+   - Wireframes in HTML at `./docs/wireframe/`
+2. If no logo provided: generate with `pk:ai-multimodal` skill
+3. Screenshot wireframes with `pk:agent-browser` -> save to `./docs/wireframes/`
+
+**Image tools:** `pk:ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+No design gate in fast mode — proceed directly to planning.
+
+## Step 3: Planning
+
+Activate **pk:plan** skill: `/pk:plan --fast <requirements>`
+- Skip research (already done above)
+- Read codebase docs → create plan directly
+- Plan directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+
+No pre-implementation gate here — hand off to cook, which keeps review gates unless the user separately asked for `--auto`.
+
+## Step 4: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **pk:cook** skill: `/pk:cook <plan-path>`
+- Skips redundant research because planning already happened
+- Keeps cook review gates; add `--auto` only when the user explicitly asked for autonomous bootstrap
+- Continues according to normal cook mode
+
+**Note:** Fast mode optimizes setup speed, not approval bypass. Use `git-manager` only after normal cook completion.

package/skills/bootstrap/references/workflow-full.md

@@ -0,0 +1,63 @@
+# Full Interactive Workflow (`--full`)
+
+**Thinking level:** Ultrathink
+**User gates:** Every major phase requires user approval before proceeding.
+
+The opening brainstorm contract in the parent skill is already satisfied.
+
+## Step 1: Refine Requirements
+
+Resolve only material gaps discovered in the opening contract.
+- Ask 1 question at a time, wait for answer before next
+- Inspect before asking for facts available from the workspace
+- Challenge assumptions when evidence reveals a real trade-off
+- Stop when outcome, constraints, non-goals, and acceptance criteria are
+  concrete enough to verify
+
+## Step 2: Research
+
+Spawn multiple `researcher` subagents in parallel:
+- Explore request validity, challenges, best solutions
+- Keep every report ≤150 lines
+
+**Gate:** Present findings to user. Proceed only with approval.
+
+## Step 3: Tech Stack
+
+1. Ask user for preferred tech stack. If provided, skip to step 4.
+2. Use `planner` + multiple `researcher` subagents in parallel to find best-fit stack
+3. Present 2-3 options with pros/cons via `ask_user capability`
+4. Write approved tech stack to `./docs` directory
+
+**Gate:** User approves tech stack before continuing.
+
+## Step 4: Wireframe & Design
+
+1. Ask user if they want wireframes/design. If no → skip to Step 5.
+2. Use `ui-ux-designer` + `researcher` subagents in parallel:
+   - Research style, trends, fonts (predict Google Fonts name, NOT just Inter/Poppins), colors, spacing, positions
+   - Describe assets for `pk:ai-multimodal` skill generation
+3. `ui-ux-designer` creates:
+   - Design guidelines at the documentation path discovered from repository instructions
+   - Wireframes in HTML at `./docs/wireframe/`
+4. If no logo provided: generate with `pk:ai-multimodal` skill
+5. Screenshot wireframes with `pk:agent-browser` -> save to `./docs/wireframes/`
+
+**Gate:** User approves design. Repeat if rejected.
+
+**Image tools:** `pk:ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 5: Planning
+
+Activate **pk:plan** skill: `/pk:plan --hard <requirements>`
+- Planner creates directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+- Present pros/cons of plan
+
+**Gate:** User approves plan. DO NOT start implementing without approval.
+
+## Step 6: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **pk:cook** skill: `/pk:cook <plan-path>` (interactive mode — review gates at each step)

package/skills/bootstrap/references/workflow-parallel.md

@@ -0,0 +1,63 @@
+# Parallel Workflow (`--parallel`)
+
+**Thinking level:** Ultrathink parallel
+**User gates:** Design approval, then normal parallel cook review gates. Implementation uses multi-agent parallel execution after user-approved cook continuation.
+
+The opening brainstorm contract in the parent skill is already satisfied and
+must be passed to every independent planning branch.
+
+## Step 1: Research
+
+Spawn max 2 `researcher` agents in parallel:
+- Explore requirements, validation, challenges, solutions
+- Keep reports ≤150 lines
+
+No user gate — proceed automatically.
+
+## Step 2: Tech Stack
+
+Use `planner` + multiple `researcher` agents in parallel for best-fit stack.
+Write to `./docs` directory (≤150 lines).
+
+No user gate — proceed automatically.
+
+## Step 3: Wireframe & Design
+
+1. Use `ui-ux-designer` + `researcher` agents in parallel:
+   - Research style, trends, fonts, colors, spacing, positions
+   - Predict Google Fonts name (NOT just Inter/Poppins)
+   - Describe assets for `pk:ai-multimodal` generation
+2. `ui-ux-designer` creates:
+   - Design guidelines at the documentation path discovered from repository instructions
+   - Wireframes in HTML at `./docs/wireframe/`
+3. If no logo: generate with `pk:ai-multimodal` skill
+4. Screenshot with `pk:agent-browser` -> save to `./docs/wireframes/`
+
+**Gate:** Ask user to approve design. Repeat if rejected.
+
+**Image tools:** `pk:ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 4: Parallel Planning
+
+Activate **pk:plan** skill: `/pk:plan --parallel <requirements>`
+- Creates phases with **exclusive file ownership** per phase (no overlap)
+- **Dependency matrix**: which phases run concurrently vs sequentially
+- `plan.md` includes dependency graph, execution strategy, file ownership matrix
+- Task hydration with `addBlockedBy` for sequential deps, no blockers for parallel groups
+
+After planning, hand off to cook with normal review gates. Add `--auto` only if the user explicitly asked for autonomous bootstrap.
+
+## Step 5: Parallel Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **pk:cook** skill: `/pk:cook --parallel <plan-path>`
+- Read `plan.md` for dependency graph and execution strategy
+- Launch multiple `fullstack-developer` agents in PARALLEL for concurrent phases
+  - Pass: phase file path, environment info
+- Use `ui-ux-designer` for frontend (generate/analyze assets with `pk:ai-multimodal`, edit with `imagemagick`)
+- Respect file ownership boundaries
+- Run type checking after implementation
+- Keep cook review gates; `--parallel` controls execution shape, not approval bypass
+
+Cook handles testing, review, docs, onboarding, final report per `shared-phases.md`.

package/skills/brainstorm/SKILL.md

@@ -0,0 +1,249 @@
+---
+name: pk:brainstorm
+description: "Turn unclear intent into an accepted outcome and compare viable approaches before delivery."
+user-invocable: true
+when_to_use: "Use at the opening of multi-step delivery or when a diagnosed problem has meaningful solution choices."
+category: utilities
+keywords: [ideation, tradeoffs, decisions, intent, acceptance]
+license: MIT
+argument-hint: "[topic or problem] [--advice] [--html] [--report] [--ultra] [--yagni] [--no-antv|--no-diagram-design|--no-editorial-visuals]"
+metadata:
+  author: primekit
+  version: "2.7.0"
+  workflow:
+    precedes: [primekit-plan, primekit-cook]
+---
+
+# Brainstorm
+
+Turn incomplete intent into a bounded delivery contract. Stay honest about
+evidence, trade-offs, and uncertainty without turning a clear request into a
+ceremonial interview.
+
+## Brainstorm contract
+
+Every multi-step product, code, documentation, or maintainer delivery starts by
+capturing:
+
+- **Outcome:** the user-visible or operational end state.
+- **Constraints:** safety, compatibility, time, technology, and ownership
+  boundaries that shape the work.
+- **Non-goals:** nearby work that this delivery will not absorb.
+- **Acceptance criteria:** observable evidence that will prove completion.
+
+An accepted design or plan satisfies the opening gate when it already contains
+these fields. Reuse it and identify only material gaps; do not make the user
+repeat settled decisions.
+
+## Proportional behavior
+
+- For a concrete request, summarize the four fields briefly and continue.
+- Ask a concise question only when a missing answer would materially change the
+  result, safety boundary, or public contract and cannot be discovered.
+- Explicit autonomous execution may continue once the four fields are concrete;
+  it does not require a routine approval pause.
+- Direct answers and low-level read-only utilities do not require a design loop.
+  If investigation turns into workspace mutation or delivery, satisfy the gate
+  before that boundary.
+- Separate target intent from current evidence. Inspect relevant repository or
+  live state before claiming an approach is feasible.
+- Separate uncertainty that can be discovered from uncertainty that cannot. Most
+  unknowns are resolvable by reading source, docs, tests, or live state — resolve
+  those instead of hedging against them. Reserve robustness reasoning for what
+  stays unknowable at decision time, such as future requirements, third-party
+  behavior, or audience response.
+
+## Bug routing
+
+For bugs, start by framing the expected repaired behavior, constraints,
+non-goals, and acceptance evidence. Do not propose fixes from the symptom.
+
+1. Scout the affected path and capture the failing state.
+2. Diagnose and prove the root cause.
+3. Compare cause-aligned solutions only after diagnosis.
+4. Use a full options discussion when multiple viable fixes or an architecture
+   decision remain; otherwise record why the direct fix is sufficient.
+
+This preserves brainstorm-first intent without allowing brainstorming to replace
+root-cause analysis.
+
+## Option exploration
+
+When the work has a real design choice:
+
+1. Inspect the smallest relevant source, docs, tests, and current plans.
+2. State the confirmed constraints and any evidence gaps.
+3. Present up to three viable approaches with meaningful trade-offs. For each,
+   name the assumption it depends on most and the condition under which it fails
+   first. Compare approaches on their worst plausible case, not only their best.
+4. Recommend the smallest approach that satisfies the contract. When a
+   load-bearing assumption cannot be resolved now, prefer the approach that is
+   cheapest to abandon.
+5. Resolve material disagreement before implementation begins.
+
+Challenge assumptions with evidence. Apply KISS and DRY. Deliver the full
+requested scope — never trim or defer what the user explicitly asked for. Do not
+invent extra components, migrations, or governance to make a design look
+complete. With `--yagni`, additionally challenge and cut any scope not needed for
+the stated outcome.
+
+## Authoritative flow
+
+```mermaid
+flowchart TD
+    A[Request] --> B{Multi-step delivery?}
+    B -->|No| C[Answer or read-only utility]
+    B -->|Yes| D{Accepted contract exists?}
+    D -->|Yes| E[Reuse outcome, constraints, non-goals, acceptance]
+    D -->|No| F[Capture bounded brainstorm contract]
+    E --> G{Bug or failure?}
+    F --> G
+    G -->|Yes| H[Scout and diagnose root cause]
+    H --> I[Choose cause-aligned solution]
+    G -->|No| J[Inspect relevant evidence]
+    J --> K[Compare approaches when choice is material]
+    I --> L[Plan or fix]
+    K --> L2[Plan or cook]
+```
+
+The opening contract is always first for delivery. Detailed solution exploration
+may occur later when diagnosis or inspection provides the evidence it needs.
+
+## Handoff
+
+Pass the four contract fields, chosen direction, evidence, and unresolved risks
+to the next owning workflow:
+
+- feature or documentation delivery: the installed plan skill, then `/pk:cook`;
+- diagnosed bug: `/pk:fix`;
+- exploration only: report the recommendation and stop.
+
+If the user passed `--yagni`, include the literal flag in every downstream skill
+or subagent handoff. Otherwise, do not introduce it during handoff.
+
+Write a durable summary only when the decision must survive the session or feed
+a plan. Use the repository's configured report location and naming convention;
+do not create a report merely to satisfy the gate.
+
+## HTML Output Mode (`--html`)
+
+When `--html` is present, capture the accepted brainstorm outcome as a
+self-contained HTML brief the user can preview before delivery starts. The brief
+augments the handoff; it never replaces the four contract fields passed to the
+next workflow.
+
+- Write `brainstorm.html` in the repository's configured report location.
+  Self-contained: inline CSS and JavaScript, no build step, no network-required
+  assets, safe to open directly from disk. Keep it accessible, responsive, and
+  reduced-motion friendly.
+- Include the four contract fields, the compared approaches with trade-offs, the
+  recommendation and its rationale, and any unresolved risks or questions.
+- **Implementation workflow diagram (required):** render at least one inline
+  diagram (HTML/CSS/SVG) that visualizes what the chosen direction will build
+  and how its steps or components connect — the delivery flow, not only the
+  decision tree.
+- **UI/UX mockups with annotations (required when the topic touches UI/UX):**
+  embed annotated mockups of the proposed interface directly in the HTML so the
+  user previews intended UI before planning. Derive layout, color, type,
+  spacing, and component states from the project design guidelines
+  (`docs/design-guidelines.md` when present, otherwise a restrained built-in
+  editorial contract). Add callouts tying each element to design tokens,
+  interaction states, and the acceptance evidence it satisfies.
+- When the installed frontend-design skill is available, activate it before
+  composing the HTML so the visuals follow current design intelligence.
+- If image or diagram generation is unavailable, fall back to CSS/SVG structure
+  and state the limitation in the final response; do not block the brainstorm.
+- **Editorial visual layer (on by default, additive):** for approach comparisons, prefer the
+  diagram-design Quadrant vernacular over a plain 2×2 table when
+  `.prefs.visual.diagramDesign.enabled` (read from
+  `primekit config prefs resolve --json`). For KPI-shaped tiles (approach
+  effort/impact scoring), prefer AntV Infographic `CandyCardLite` /
+  `CompactCard` when `.prefs.visual.antv.enabled`. Nested keys arrive in
+  the hook-facing camelCase spelling — `diagram_design` in `config.yaml`
+  resolves as `diagramDesign` at that surface. Kill switches: `--no-antv`,
+  `--no-diagram-design`, `--no-editorial-visuals`. See the sibling `primekit-preview`
+  skill's `../primekit-preview/references/html-diagram-design.md` and
+  `../primekit-preview/references/html-antv-infographic.md` for exact template usage.
+
+## Report Output Mode (`--report`)
+
+When `--report` is present, persist the accepted brainstorm as a durable
+markdown report following the installed project-organization skill's
+conventions (path resolution, naming, and markdown body standards):
+
+- **Path:** the plan-scoped reports directory (`plans/{plan-dir}/reports/`)
+  when an active plan exists, otherwise the standalone `plans/reports/`
+  directory — or the injected `Report:` path from the `## Naming` section when
+  the runtime provides one.
+- **Naming:** timestamped kebab-case per the naming convention, e.g.
+  `brainstorm-{YYMMDD-HHmm}-{slug}.md`.
+- **Body:** the report template — frontmatter, summary, the four contract
+  fields, options considered with trade-offs, recommendation, and unresolved
+  questions last.
+
+`--report` composes with every other flag: with `--html` both artifacts are
+written; with `--ultra` the report records the winning candidate plus the short
+ranking appendix. Without `--report`, keep the existing behavior — write a
+durable summary only when the decision must survive the session or feed a plan.
+
+## Advisory supervision (`--advice`)
+
+When `--advice` is present, run this skill under `kongming` supervision.
+Load `references/advisory-supervision.md` for supervisor identity, host
+detection, and model routing (Claude subscription → Fable 5; Codex →
+`gpt-5.6-sol` + high effort; Cursor → `claude-fable-5-high`).
+
+Spawn `kongming` at these checkpoints:
+
+- **After each phase, step, or decision round completes** — pass the goal, what
+  changed or was concluded, and the evidence; ask for a go/no-go and the next
+  risk to watch before continuing.
+- **When stuck** — repeated failures, a blocked step, or contradictory evidence;
+  pass everything already tried and the exact obstacle.
+- **Before a high-stakes decision** — a design fork, a public-contract or
+  security-sensitive change, or an irreversible action; get counsel first.
+
+**When the workflow reaches a PR** (here, via the handed-off plan/cook/fix
+workflow): pass `--advice` to the downstream skill so supervision persists
+across the handoff. Watch and fix CI until every required check is green, then
+spawn `kongming` to review the whole implementation and post its assessment
+plus concrete next steps as a comment directly on the PR and the source issue
+(when one exists).
+
+## Ultra Verifier Mode (`--ultra`)
+
+When `--ultra` is present, run the brainstorm as a best-of-5 verifier pass
+instead of a single draft. The controller builds one immutable evidence packet
+plus a rubric, dispatches exactly five independent read-only candidate
+brainstorms in one parallel wave, then a single strongest-model verifier scores
+and ranks them and selects the winning candidate (or rejects all).
+
+- **Candidate task:** each candidate produces a complete bounded contract —
+  outcome, constraints, non-goals, acceptance criteria — plus its recommended
+  direction and trade-offs.
+- **Rubric:** faithfulness to the request, evidence grounding, sharpness of the
+  acceptance criteria, and honesty about unknowns.
+- **Finalizer:** the verifier selects the single winning contract; the
+  controller emits that winner unchanged (it does not blend candidates) and
+  records a short ranking appendix. On reject-all, hard-stop and report why.
+
+Full mechanics — evidence packet, anonymization, the five-usable-candidate gate
+with one bounded re-dispatch, the fail-closed runtime rule, and reject-all — are
+in `references/ultra-verifier-mode.md`. `--ultra` composes with `--html`,
+`--report`, `--advice`, and `--yagni`, and adds no new conflicts. It is a best-of-5 verifier
+mode inspired by LLM-as-a-Verifier, not the full framework; never claim its
+logprob/tournament algorithm.
+
+## Boundaries
+
+- This skill shapes intent and choices; it does not implement the solution.
+- Never claim current behavior from intent alone.
+- Never expose secrets or unrelated private files during inspection.
+- List unresolved questions last when any remain.
+
+## Workflow position
+
+**Typically precedes:** `primekit-plan`, `/pk:cook`.
+
+**Bug path:** opening intent frame -> scout and debug -> solution brainstorm when
+needed -> `/pk:fix`.

package/skills/brainstorm/references/advisory-supervision.md

@@ -0,0 +1,80 @@
+# Advisory Supervision (`--advice`)
+
+Shared protocol for the opt-in `--advice` mode of workflow skills
+(`pk:brainstorm`, `pk:plan`, `pk:cook`, `pk:fix`, `pk:code-review`,
+`pk:review-pr`, `pk:ship`, and siblings that opt in). Each skill keeps its own
+checkpoint list, then defers here for supervisor identity and model routing.
+
+## What this is
+
+`--advice` runs the skill under **`kongming` advisory supervision**. Kongming
+returns counsel only — never code, never file edits, never gate overrides. The
+main agent stays responsible for every decision, edit, test, review, and
+security policy.
+
+## Supervisor identity
+
+Always spawn the kit agent `kongming` (portable frontmatter `model: fable`).
+Do not substitute `advisor` / `pk:advise` for these checkpoints — those are
+interview-driven and interactive. Kongming is one-shot autonomous counsel.
+
+Invoke shape (capability names vary by runtime):
+
+```
+delegate_agent capability(
+  subagent_type="kongming",
+  prompt="<task, evidence, approaches tried, the exact question>",
+  description="advice: <checkpoint>",
+  /* model / effort: see Model routing below when the host requires them */
+)
+```
+
+Give enough redacted context for one reply. No secrets, credentials, personal
+data, or private environment values. Empty or error counsel is a non-fatal
+advisory failure; authoritative skill gates still decide whether to proceed.
+
+## Model routing (detect host, then pin)
+
+Kongming must run on the **strongest advisory tier** for the host. Detect the
+active coding-agent host from the session (runtime identity, provider, or
+auth mode), then apply exactly one row:
+
+| Detected host | Model for kongming | Effort / notes |
+|---------------|--------------------|----------------|
+| **Claude Code with subscription / OAuth** (Claude Max or equivalent; not API-key-only) | Claude **Fable 5** via kit tier `fable` (Claude Code keeps `model: fable` on the agent) | Prefer subscription sessions — Fable is subscription-backed. If Fable is unavailable on the account, hard-stop the advice spawn and say so; do not silently fall back to Sonnet/Opus and claim `--advice` ran on Fable. |
+| **Codex** | **`gpt-5.6-sol`** | **`high`** reasoning effort. Prefer the emitted `.codex/agents/kongming.toml` override (`model` + `model_reasoning_effort`). When the host requires an explicit model/effort on the delegate call, pass those same values. |
+| **Cursor** | Emitted agent model for `fable` → **`claude-fable-5-high`** | When `delegate_agent` requires an explicit `model` argument, pass that Cursor ID. Do not pass bare `fable`. |
+| **Other / single-model hosts** (e.g. Pi inherit-only, Grok) | Strongest available session model | Tell the user in one sentence that `--advice` could not pin Fable/Sol and is same-model counsel. Still spawn `kongming` for the protocol; do not invent unavailable IDs. |
+
+### Detection rules (practical)
+
+1. **Prefer emitted agent config.** If the installed `kongming` agent already
+   carries the correct host model (Claude `fable`, Codex `gpt-5.6-sol` + high,
+   Cursor `claude-fable-5-high`), spawn by `subagent_type="kongming"` and let
+   the runtime load that definition.
+2. **When the delegate API requires an explicit model**, pin using the table
+   above — do not inherit a weaker parent session model for advice checkpoints.
+3. **Subscription vs API on Claude Code:** treat OAuth / subscription Max
+   sessions as the Fable path. Treat API-key-only Claude sessions as "Fable
+   may be unavailable"; if spawn fails or the host rejects `fable`, hard-stop
+   advice rather than pretending.
+4. **Never** remap Codex advice to a Claude model ID, or Claude advice to a
+   GPT ID, inside skill prose. Adapters own emit-time remaps; skills only pin
+   when the live call needs an explicit argument.
+
+## Forward-carry and PR gate
+
+When handing off to a downstream workflow skill, pass `--advice` so supervision
+persists. After required CI is terminal-green on a PR, spawn kongming once more
+to review the whole implementation and post assessment plus concrete next steps
+on the PR and source issue (when one exists) — unless a skill (e.g.
+`pk:review-pr`) already owns that checkpoint.
+
+## Non-negotiables
+
+- `--advice` never bypasses approval gates, tests, review blockers, branch
+  protections, or security policy.
+- Do not skip checkpoints because counsel was empty; record the miss and
+  continue under the skill's authoritative gates.
+- Do not claim Fable or `gpt-5.6-sol` high was used unless the spawn actually
+  targeted that tier.