@pieai/pro-gov 0.4.2 → 0.4.4

package/README.md

@@ -9,10 +9,10 @@ Think of Project Governance System as a librarian, traffic desk, and inspection
 station:
 
 - `pro-gov` shows which reusable project-governance parts are present or missing;
-- `@pieai/doc-gov` checks documents, routing, links, hooks, and CI;
-- Superpowers may provide the engineering process;
-- Compound Engineering may provide the post-work learning capture tail;
-- Ponytail may provide an optional simplicity review.
+- `@pieai/doc-gov` checks documents, routing, links, guardrails, and CI;
+- the AI host and project checks own normal execution;
+- optional Matt skills trigger only when their narrow descriptions match;
+- `capture-learning` records a reusable lesson only when one exists.
 
 The current `pro-gov` release is conservative by design. Public init and sync
 commands inspect and compare; they do not silently overwrite another project's
@@ -53,7 +53,6 @@ pro-gov init --profile engineering-runtime --dry-run
 pro-gov init --profile engineering-runtime --apply
 pro-gov init --profile doc-only --dry-run
 pro-gov sync --check --profile engineering-runtime
-pro-gov sync --apply-host-hooks --profile engineering-runtime
 pro-gov doctor
 ```
 
@@ -72,8 +71,7 @@ What these commands do:
 | `lens report` | Writes the requested report file. | Only the explicit output |
 | `init --dry-run` | Shows starter/profile files that would be needed. | No |
 | `init --apply` | Installs one profile into a fresh target; refuses the whole operation if any target file exists. Optional CI and Lefthook references are not installed. | Yes |
-| `sync --check` | Strictly compares shared core files and checks only the presence of project-local seed files. | No |
-| `sync --apply-host-hooks` | Merges current PGS Compound Gate entries into engineering-runtime host configs while preserving consumer-owned keys and hooks. | Only the three host config files |
+| `sync --check` | Strictly compares shared core files, checks project-local seeds for presence, and leaves optional guardrail contents consumer-owned. | No |
 | `doctor` | Checks required packaged assets and whether `doc-gov` is available. | No |
 
 ## Full Checkout Commands
@@ -129,71 +127,31 @@ the private-source and public-copy hashes recorded during promotion.
   reviewable plan in a full upstream checkout.
 - `pro-gov lens inspect|report` provides read-only inspection and an explicit
   report output.
-- `doc-gov` remains the document, router, manifest, link, hook, CI, and migration
+- `doc-gov` remains the document, router, manifest, link, CI, and migration
   validator.
 - Product truth stays in the target project.
 - `pro-gov init --apply` is intentionally fresh-target only. Existing projects
   use `--dry-run` and a deliberate migration so local truth is never overwritten.
-- Superpowers, Compound Engineering, and Ponytail are external tools, not
-  bundled runtime dependencies.
+- PGS does not require or bootstrap a workflow plugin.
 - Optional `hostTooling` entries let `portfolio doctor` verify required Codex or
   Claude Code plugins. PGS does not install or upgrade those plugins.
 
-## Recommended Companion Tools
+## Lightweight Agent Workflow
 
-Superpowers is recommended for engineering/runtime projects that need
-brainstorming, plans, TDD, debugging, verification, and worktree discipline.
+The AI host and the target project's proof commands own ordinary work. Matt
+Pocock's skills may be exposed as an optional unchanged library; each skill
+triggers from its own narrow description and does not become a mandatory
+pipeline or workflow owner.
 
-Compound Engineering is recommended for knowledge capture after verified
-engineering work. The default PGS pattern is a Compound Gate: run
-`ce-compound` when there is reusable learning, or report why compounding was
-skipped. Full CE workflows such as `ce-plan`, `ce-work`, and `lfg` remain
-explicit user choices.
-
-PGS Learning Recall is the pre-work companion to that post-work gate. Before
+Before
 non-trivial implementation, debugging, release, architecture, or portfolio-sync
 work, run `pro-gov learn recall --query "<task summary>"` and read relevant
 `docs/solutions/**` or `CONCEPTS.md` hits before changing files.
 
-Engineering-runtime starters include cross-host Stop hooks for Codex,
-Claude Code, and Antigravity. Those hooks call `pro-gov host-hook`. The starter
-default is `--compound-gate-mode off`: wiring is present, but the hook does not
-interrupt the main session. Use `--compound-gate-mode lite` for a short
-exit-door reminder, or `--compound-gate-mode strict` for the older blocking
-gate.
-
-When enabled, the hook expects the final report to include either:
-
-```text
-Compound Gate: ran ce-compound -> <path>
-Compound Gate: ran fallback capture -> <path>
-Compound Gate: skipped -> <reason>
-```
-
-Use `ran fallback capture` only when the Compound Engineering plugin or
-`ce-compound` skill is unavailable in the current host. It writes a minimal
-`docs/solutions/**` learning record through `pro-gov learn capture`; it does
-not replace or copy the full CE workflow.
-
-Use `pro-gov doctor --strict-hooks` after syncing an engineering project to
-verify that the host configs are wired. This is a wiring check: it proves the
-project calls `pro-gov host-hook` for Codex, Claude Code, and Antigravity. The
-host behavior contract is covered by PGS package tests against recorded
-per-host Stop/SubagentStop fixtures. Open a fresh AI session after installing or
-changing hooks; old sessions may not reload host configuration.
-
-Antigravity hook commands enable `PGS_HOST_HOOK_DEBUG=1` by default in PGS
-starters. The hook writes local diagnostics to `.git/pro-gov-hook-debug/` when
-it is actually invoked, including the input summary, decision, and output JSON.
-This directory lives inside Git's private metadata so it does not dirty the
-worktree. If an Antigravity test does not create a diagnostic file, inspect
-whether the host loaded `.agents/hooks.json` before changing PGS policy.
-`.pro-gov/assets.json` is only an asset-install manifest; its `host` field does
-not control runtime hook dispatch.
-
-Ponytail can be installed as an optional complexity adviser. Keep its global mode
-`off`; test `lite` in one isolated task before considering a stronger mode.
-Ponytail must not remove requested scope, tests, safety, accessibility, or proof.
+After verified work, use the small `capture-learning` skill only when the result
+will help future work. It calls `pro-gov learn capture` and writes a compact
+`docs/solutions/**` record. PGS does not install Stop/SubagentStop reminder
+hooks or require a completion ceremony.
 
 Read the
 [full project introduction](https://github.com/PieAIStudio/ProjectGovernanceSystem#readme)

package/assets/docs/reference/adoption/adoption-playbook.md

@@ -22,11 +22,10 @@ related:
 
 Use this when a project wants to migrate into the Project Governance System.
 
-Before choosing external AI workflow tools, read
+Before choosing optional AI skills, read
 `docs/reference/adoption/recommended-agent-tooling.md`. It explains which PGS
-packages are required, when Superpowers is recommended, how Compound
-Engineering's `ce-compound` fits as a post-work learning tail, and why Ponytail
-should remain globally `off` until it is tested in an isolated task.
+packages are required, how Matt skills remain trigger-based, and how the small
+native learning-capture path works.
 
 ## The Short Version
 
@@ -79,8 +78,7 @@ Current package-based method:
   merge local truth deliberately instead of asking PGS to overwrite it
 - run `pro-gov sync --check --profile <profile>` to compare shared core files;
   project-local router, policy, documentation map, and current-work files are
-  checked for presence rather than byte equality; host configs are compared by
-  PGS-owned entries rather than whole-file equality
+  checked for presence rather than byte equality
 - run `pro-gov assets discover --target <path>` and
   `pro-gov assets recommend --target <path>` to collect local project signals
   and suggested agent-asset bundles without changing the project
@@ -93,20 +91,8 @@ Current package-based method:
 - copy `starter/lefthook.template.yml` to `lefthook.yml` and
   `starter/.github/workflows/docs-check.yml` to `.github/workflows/docs-check.yml`
   when the target project is ready for standard guardrails
-- for an `engineering-runtime` target, install the three host-hook starter files
-  or merge their Stop/SubagentStop entries into the target's existing host
-  config:
-  - `.codex/hooks.json`
-  - `.claude/settings.json`
-  - `.agents/hooks.json`
-- prefer `pro-gov sync --apply-host-hooks --profile engineering-runtime` for
-  that merge; it preserves consumer `PreToolUse`, other events, other top-level
-  keys, and non-PGS Stop/SubagentStop entries
 - run `doc-gov doctor` after wiring guardrails to verify they are actually
   connected
-- run `pro-gov doctor --strict-hooks` after wiring host hooks to prove the
-  target has the expected host-hook configuration for Codex, Claude Code, and
-  Antigravity
 - treat the npm package as the CLI source and the local `docs/governance/`
   files as the project's checked-in governance contract
 
@@ -116,7 +102,6 @@ pnpm pro-gov init --profile engineering-runtime --dry-run
 pnpm pro-gov init --profile engineering-runtime --apply
 pnpm doc-gov scan
 pnpm pro-gov sync --check --profile engineering-runtime
-pnpm pro-gov sync --apply-host-hooks --profile engineering-runtime
 ```
 
 Use `--apply` only for a fresh target. Existing projects normally already own
@@ -211,13 +196,10 @@ The project must define local lanes and proof commands.
 Do not copy the upstream root `integrations/` directory into target projects by default.
 If a project needs local external-workflow guidance, keep it thin in `AGENTS.md` or put project-specific notes under `docs/reference/integrations/`.
 
-For engineering projects, keep Superpowers as the default engineering workflow.
-Use Compound Engineering by default only as the post-work Compound Gate:
-`ce-compound` captures reusable lessons when they exist; otherwise the agent
-reports a skip reason. If the current host cannot load the CE plugin, use
-`pro-gov learn capture` as the fallback capture path and report
-`Compound Gate: ran fallback capture -> <path>`. Full CE workflows require an
-explicit user request.
+For engineering projects, normal execution belongs to the AI host and the
+project's own proof commands. Matt Pocock's skills remain available as a
+lightweight library and trigger only when their narrow descriptions match; they
+are not a mandatory pipeline or workflow owner.
 
 Use PGS Learning Recall before non-trivial work:
 
@@ -225,22 +207,10 @@ Use PGS Learning Recall before non-trivial work:
 pro-gov learn recall --query "<task summary>"
 ```
 
-This reads the project's existing `docs/solutions/**` and `CONCEPTS.md` records
-so prior lessons can shape the work without making Compound Engineering the
-default execution workflow.
-
-The host-hook gate is deliberately small. It does not make Compound Engineering
-the main workflow. Starter hooks default to `--compound-gate-mode off`, so they
-prove the wiring without interrupting the main session. Switch a target to
-`--compound-gate-mode lite` for a short reminder, or `--compound-gate-mode
-strict` when a project intentionally wants the old blocking exit gate. In
-`lite` or `strict`, the hook checks whether a completion report says one of:
-
-```text
-Compound Gate: ran ce-compound -> <path>
-Compound Gate: ran fallback capture -> <path>
-Compound Gate: skipped -> <reason>
-```
+This reads the project's existing `docs/solutions/**` and `CONCEPTS.md` records.
+After verified work, use `capture-learning` only when the result is genuinely
+reusable. The skill calls `pro-gov learn capture`; no exit hook or completion
+ceremony is required.
 
 ### Doc-Only
 
@@ -251,15 +221,9 @@ Add:
 - AI-in-the-Loop rules linked from the project's external shared-rule source
 - canon/provenance/archive rules in `docs/policy/best-practice-for-this-project.md`
 
-Do not add Superpowers TDD or Directed Development by default.
-
-Do not add the Compound Engineering main workflow by default. If CE is installed
-in the AI host, doc-only projects should use it only for a real reusable
-learning that belongs in that workspace.
-
-Ponytail is also optional. If it is installed, keep its global mode `off` and
-activate it only for a bounded task or review after reading
-`integrations/ponytail.md`.
+Do not add engineering TDD workflow plugins or Directed Development by default.
+Use `capture-learning` only for a real reusable lesson that belongs in that
+workspace.
 
 ## Step 6: Create Current Work
 
@@ -301,7 +265,7 @@ For the v0.9 structural migration, use
 Minimum:
 
 ```bash
-pnpm pro-gov doctor --strict-hooks
+pnpm pro-gov doctor
 pnpm doc-gov check
 pnpm doc-gov router-check
 pnpm doc-gov scan --check
@@ -311,22 +275,6 @@ pnpm doc-gov doctor
 git diff --check
 ```
 
-Use `pro-gov doctor --strict-hooks` for engineering-runtime projects. Doc-only
-projects may omit strict host hooks unless they intentionally adopt the
-engineering runtime profile.
-
-`pro-gov doctor --strict-hooks` is a wiring check, not a live host simulation.
-It proves the project has hook files that call `pro-gov host-hook`; PGS package
-tests prove the expected Stop/SubagentStop behavior for `off`, `lite`, and
-`strict` modes across the supported host schemas. After installing or changing
-hooks, validate from a fresh AI session.
-For Antigravity, a real invocation writes diagnostics under
-`.git/pro-gov-hook-debug/` because the starter hook command sets
-`PGS_HOST_HOOK_DEBUG=1`. Absence of a diagnostic file after a fresh
-Antigravity session usually means the host did not load or run
-`.agents/hooks.json`. The `.pro-gov/assets.json` `host` field records asset
-placement only; it does not control runtime hook dispatch.
-
 Engineering projects should also run their local verification ladder.
 
 ## Example: Migrating A Runtime Product

package/assets/docs/reference/adoption/agent-workflow-methodology-comparison.md

@@ -2,8 +2,8 @@
 id: REF-AGENT-WORKFLOW-METHODOLOGY-COMPARISON
 title: Agent Workflow Methodology Comparison
 type: reference
-status: active
-canonical: true
+status: superseded
+canonical: false
 owner: project
 created: 2026-07-06
 last_reviewed: 2026-07-06
@@ -18,10 +18,18 @@ pinned: false
 related:
   - REF-PUBLIC-RELEASE-CHECKLIST
   - REF-DOWNSTREAM-PROJECT-REGISTRY
+superseded_by: REF-RECOMMENDED-AGENT-TOOLING
 ---
 
 # Agent Workflow Methodology Comparison
 
+> Historical snapshot only. The current decision is documented in
+> [Recommended Agent Tooling](recommended-agent-tooling.md): Superpowers,
+> Compound Engineering, and Ponytail are retired from the installed PGS stack;
+> Matt skills remain a trigger-based library, and `capture-learning` preserves
+> the small reusable-learning loop. The older analysis below is retained as
+> decision history, not current guidance.
+
 本文比较 4 套 AI agent 工作方法，观察时间点是 2026-07-06：
 
 1. **Superpowers**

package/assets/docs/reference/adoption/recommended-agent-tooling.md

@@ -6,14 +6,12 @@ status: stable
 canonical: true
 owner: human
 created: 2026-06-21
-last_reviewed: 2026-06-21
+last_reviewed: 2026-07-12
 domain: adoption
 tags:
   - adoption
   - tooling
-  - superpowers
-  - compound-engineering
-  - ponytail
+  - skills
 pinned: false
 related:
   - REF-ADOPTION-PLAYBOOK
@@ -23,130 +21,35 @@ related:
 
 # Recommended Agent Tooling
 
-This page separates what a project needs from what may help it.
+PGS keeps the default path small: Codex and the project router execute normal
+work; tools and skills add capabilities only when their narrow trigger matches.
 
-## The Beginner Version
+| Tool | Default | Purpose |
+| --- | --- | --- |
+| `@pieai/pro-gov` | required | Profiles, assets, learning recall/capture, portfolio checks |
+| `@pieai/doc-gov` | required | Governed-document and router validation |
+| mattpocock/skills | available | Optional specialist toolbox; no bootstrap or workflow owner |
+| `capture-learning` | available | Save a verified reusable lesson after completed work |
+| Superpowers | not installed | Retired mandatory workflow plugin |
+| Compound Engineering | not installed | Retired; native PGS capture keeps the useful learning loop |
+| Ponytail | not installed | Retired global mode/hooks; ordinary engineering judgment stays lean |
 
-Imagine a school workshop:
-
-- PGS labels the shelves, routes each job, and checks that the record is complete.
-- Superpowers gives the class a reliable build-and-test routine.
-- Compound Engineering keeps the class notebook of hard-won lessons.
-- Ponytail is the adviser who asks, "Can we make this with fewer unnecessary
-  parts?"
-
-Installing every tool does not mean every tool should run all the time.
-
-## Recommendation Table
-
-| Tool | Recommendation | Best fit | Default behavior |
-| --- | --- | --- | --- |
-| `@pieai/pro-gov` | Required for package-based PGS adoption | Projects adopting PGS starter/profile assets | Use its read-only discovery, init, sync, doctor, and Lens commands. |
-| `@pieai/doc-gov` | Required for package-based PGS adoption | All governed PGS projects | Run document, router, manifest, link, hook, and CI checks. |
-| Superpowers | Recommended for engineering/runtime projects | Apps, games, services, browser products, and other code-heavy work | Use the matching workflow when the selected PGS lane requires it. |
-| Compound Engineering | Recommended for knowledge capture | Engineering projects that benefit from reusable learnings | Default to `ce-compound` as the post-work Compound Gate; use full CE workflows only when explicit. |
-| Ponytail | Recommended as an installed, optional adviser | Projects that need help resisting unnecessary complexity | Keep the global mode `off`; activate it explicitly for a bounded task or review. |
-
-## Superpowers
-
-Superpowers owns engineering workflow discipline:
-
-- brainstorming before creative implementation;
-- implementation plans;
-- test-driven development;
-- systematic debugging;
-- verification before completion;
-- isolated worktree usage.
-
-PGS routes the task first. Superpowers then runs inside the selected lane.
-
-Engineering/runtime projects usually benefit from Superpowers. Doc-only
-projects should not inherit the full engineering ceremony unless their current
-task actually involves runtime or code behavior.
-
-Read `integrations/superpowers.md` for the exact boundary.
-
-## Compound Engineering
-
-Compound Engineering is useful for preserving lessons that should make future
-work easier. In PGS-governed projects, its default role is the post-work
-Compound Gate:
-
-```text
-Superpowers completes verified work
--> decide with CE criteria whether reusable learning exists
--> run ce-compound or report a skip reason
--> if CE is unavailable in this host, run pro-gov learn capture as fallback
-```
-
-PGS Learning Recall is the matching pre-work step:
+Before non-trivial work:
 
 ```bash
 pro-gov learn recall --query "<task summary>"
 ```
 
-It searches `docs/solutions/**` and `CONCEPTS.md` so agents can reuse prior
-lessons without making Compound Engineering the default execution workflow.
-
-The fallback path is deliberately smaller than CE:
+After verified work, `capture-learning` first checks for an existing lesson and
+then calls this only when a new reusable lesson exists:
 
 ```bash
 pro-gov learn capture --title "<learning title>" --summary "<reusable lesson>"
 ```
 
-Use it only when the CE plugin or skill is unavailable in the current host. It
-keeps the lesson searchable by Learning Recall without copying CE's full
-workflow into PGS.
-
-Do not make routine tasks choose between Superpowers and Compound Engineering as
-competing default engineering processes. Use CE's full `ce-plan`, `ce-work`, or
-`lfg` flow only when the user explicitly asks for it.
-
-Read `integrations/compound-engineering.md` for artifact ownership and Doc Gov
-compatibility.
-
-## Ponytail
-
-Ponytail advises the AI to prefer smaller, less speculative solutions. That can
-reduce unnecessary code, files, dependencies, and abstractions.
-
-Keep its global mode `off`. When a low-risk task needs a simplicity comparison,
-test `lite` in an isolated session first. Use `full` only as an optional stress
-test after checking that requirements, tests, verification, security,
-accessibility, and durable evidence remain intact.
-
-Ponytail is not a replacement for PGS or Superpowers. Shorter work is valuable
-only when it is still the complete, proven work the project asked for.
-
-Read `integrations/ponytail.md` for the mode policy and comparison protocol.
-
-## A Practical Default
-
-For an engineering/runtime project:
-
-```text
-install PGS packages
--> keep Superpowers available for engineering workflows
--> run pro-gov learn recall before non-trivial work
--> use Compound Engineering's ce-compound as the post-work learning tail
--> install Ponytail but keep global mode off
--> activate Ponytail only when a bounded simplicity review would help
-```
-
-For a doc-only project:
-
-```text
-install PGS packages
--> use doc-only routing and evidence rules
--> add engineering workflow tools only for a real engineering task
--> keep Ponytail optional and off by default
-```
-
-## What PGS Does Not Do
+Do not add Stop/SubagentStop workflow reminder hooks. Verification belongs in
+the task and the project's real command ladder.
 
-PGS does not automatically install, enable, update, or remove these external
-plugins in another person's AI host. It documents the recommended boundary and
-lets each project or user adopt tools deliberately. A user-owned portfolio may
-declare required Codex or Claude Code plugin ids in `hostTooling`; `portfolio
-doctor` then verifies installed/enabled state and reports observed versions.
-The host's native plugin manager remains the installation and update authority.
+Host plugins that provide external capabilities—such as GitHub, Vercel,
+Supabase, browsers, documents, or device control—remain independent choices.
+PGS does not require them unless a portfolio manifest explicitly declares one.

package/assets/integrations/compound-engineering.md

@@ -1,164 +1,11 @@
-# Compound Engineering Integration
+# Compound Engineering Integration (Retired)
 
-Compound Engineering is an external plugin/system. This repository does not
-vendor, rewrite, or require the Compound Engineering plugin.
+PGS no longer requires the Compound Engineering plugin or a Compound Gate.
 
-## The Beginner Version
+The retained idea is small: verified work sometimes produces a reusable lesson.
+The PGS-owned `capture-learning` skill decides whether a lesson is worth keeping,
+checks for duplicates, and writes it through `pro-gov learn capture`. There are
+no Stop hooks, modes, plugin configuration, or mandatory final-report ceremony.
 
-Think of an AI project as a workshop:
-
-- PGS is the traffic desk and filing cabinet.
-- Superpowers is the default cooking process for engineering work.
-- Compound Engineering's `ce-compound` is the recipe notebook written after a
-  non-trivial dish is proven to work.
-- `pro-gov learn recall` is the recipe-card search before the next dish starts.
-- Ponytail is the cost and complexity adviser.
-
-The default path is one main process with one learning tail. Do not make every
-task choose between two construction processes.
-
-## Default Rule
-
-For PGS-governed engineering/runtime projects, Superpowers remains the default
-engineering workflow. Compound Engineering is installed for its knowledge
-capture loop by default, not as a second default execution engine.
-
-Use this order:
-
-1. PGS routes the task and selects the project lane.
-2. For non-trivial engineering work, run Learning Recall against the task
-   summary and read relevant prior lessons.
-3. Superpowers handles the normal engineering workflow when that lane needs one.
-4. Ponytail may run as an explicit complexity review when useful.
-5. The agent must pass the Compound Gate before final reporting.
-6. Doc Gov validates governed documentation and ignores CE-owned external
-   artifacts.
-
-## Learning Recall
-
-CE writes the reusable lesson. PGS recalls it.
-
-Before non-trivial implementation, debugging, release, architecture, or
-portfolio-sync work, run:
-
-```bash
-pro-gov learn recall --query "<task summary>"
-```
-
-Read the relevant hits before changing files. A no-hit result is acceptable;
-do not scan every `docs/solutions/**` file by hand. The recall command is a
-small search surface over `docs/solutions/**` and `CONCEPTS.md`, not a second
-workflow engine, vector database, or CE replacement.
-
-## Compound Gate
-
-Every completed non-trivial engineering task must pass the Compound Gate:
-
-```text
-Was there reusable learning?
--> yes: run compound-engineering:ce-compound
--> yes, but CE is unavailable: run pro-gov learn capture
--> no: report "Compound Gate: skipped" and give the reason
-```
-
-Use Compound Engineering's own capture criteria when CE is available. PGS
-fallback capture exists only so hosts without the CE plugin can still preserve a
-searchable lesson. It is a minimal backup path, not a copied CE workflow and not
-a separate default process.
-
-Run `ce-compound` when the completed work produced a reusable lesson, such as:
-
-- a non-obvious bug diagnosis;
-- a repeated pattern or root cause;
-- a wrong assumption about a shared dependency, framework, convention, or tool;
-- a new reusable architecture, workflow, verification, or tooling pattern;
-- owner intent that the lesson should be remembered.
-
-Skip compounding when the work was:
-
-- unverified or still in progress;
-- a trivial typo or obvious one-line fix;
-- mechanical formatting, dependency bumping, or bulk sync work;
-- already covered by an existing `docs/solutions/**` learning.
-
-The skip must be explicit in the final report. This prevents agents from
-forgetting the gate while avoiding a low-value knowledge dump.
-
-If `compound-engineering:ce-compound` is unavailable in the current host, write
-a minimal fallback record:
-
-```bash
-pro-gov learn capture \
-  --title "<learning title>" \
-  --summary "<the reusable lesson future agents should recall>"
-```
-
-The fallback record should capture only verified, reusable learning. It should
-not document unfinished work, trivial changes, or lessons already covered by an
-existing `docs/solutions/**` record. Report it as:
-
-```text
-Compound Gate: ran fallback capture -> docs/solutions/<category>/<file>.md
-```
-
-## When CE May Own The Main Flow
-
-Use the full Compound Engineering flow only when the user explicitly names it,
-for example `ce-plan`, `ce-work`, `lfg`, or "use Compound Engineering full
-workflow."
-
-Do not auto-select between Superpowers and Compound Engineering for routine
-work. Automatic choice adds cognitive load and makes sessions harder to reason
-about.
-
-## CE-Owned Artifacts
-
-The following paths are Compound Engineering external artifacts:
-
-| Path | Owner | Rule |
-| --- | --- | --- |
-| `docs/solutions/**` | CE | Knowledge store written by `ce-compound`; uses CE frontmatter. |
-| `docs/brainstorms/**` | CE | CE brainstorm artifacts; explicit CE use only. |
-| `docs/pulse-reports/**` | CE | CE product-pulse reports; explicit CE use only. |
-| `docs/plans/*` | CE | CE-native root plan artifacts; explicit CE full workflow only. |
-
-PGS-owned plans remain:
-
-```text
-docs/plans/active/**
-docs/plans/completed/**
-```
-
-Doc Gov must not require CE-owned artifacts to use PGS frontmatter. The
-directory decides which schema applies:
-
-```text
-docs/solutions/** and other CE-owned paths -> CE schema
-PGS governed docs -> Doc Gov schema
-```
-
-Do not try to make one YAML block satisfy both systems.
-
-## Root Files
-
-Compound Engineering may read project root files when present, but PGS-governed
-projects keep these boundaries:
-
-| File | Rule |
-| --- | --- |
-| `STRATEGY.md` | CE must not create or overwrite this by default in PGS-governed projects. Product strategy belongs in the project's canon/control plane unless explicitly adopted. |
-| `CONCEPTS.md` | Allowed as a CE vocabulary helper, but it does not replace `docs/canon/**` or project runtime truth. |
-| `AGENTS.md` / `CLAUDE.md` | CE discoverability edits must stay short and must not replace the PGS router. |
-| `.compound-engineering/config.local.yaml` | Machine-local CE config; keep gitignored. |
-
-## Completion Report
-
-When a task finishes, report one of:
-
-```text
-Compound Gate: ran ce-compound -> docs/solutions/<category>/<file>.md
-Compound Gate: ran fallback capture -> docs/solutions/<category>/<file>.md
-Compound Gate: skipped -> <reason>
-```
-
-This is the durable signal that the learning tail was considered.
+Historical `docs/solutions/**` records remain valid inputs to
+`pro-gov learn recall`.

package/assets/integrations/directed-development.md

@@ -4,10 +4,8 @@ Directed Development is an optional workflow for mixed, cross-domain, interdepen
 
 It is not the default for every task.
 
-It is not a Superpowers startup adapter and not a second engineering plugin. It
-is a small PGS routing rule for cases where product work must be split into
-ordered dependency-aware Blocks before the selected lane uses its normal
-workflow. Superpowers still owns the engineering process inside that lane.
+It is a small PGS routing rule for cases where product work must be split into
+ordered dependency-aware Blocks before execution.
 
 ## Boundary
 
@@ -21,7 +19,7 @@ Directed Development may define:
 Directed Development must not define:
 
 - artifact locations
-- Superpowers skill invocation rules
+- optional skill invocation rules
 - project document paths
 - project lane names
 - runtime truth
@@ -33,7 +31,7 @@ not replace the project router.
 
 BDD-style scenarios are allowed only as acceptance language for a DD Block. They
 do not turn Directed Development into a default BDD ceremony and do not replace
-Superpowers TDD, debugging, or verification workflows.
+project-specific testing, debugging, or verification.
 
 ## Trigger