Created capabilities (commands): gsd-discuss-phase, gsd-plan-phase, gsd-execute-phase, gsd-verify-work, gsd-ship
Created capabilities (sub-agents): gsd-phase-researcher, gsd-planner, gsd-plan-checker, gsd-executor, gsd-verifier
Created sdlc-stage projections: stage-discuss, stage-plan, stage-execute, stage-verify, stage-ship
Created artifacts: artifact-context-md, artifact-plan-md, artifact-research-md, artifact-uat-md, artifact-atomic-commit, artifact-pull-request
Created patterns: pattern-spec-driven-development, pattern-fresh-context-subagents, pattern-wave-parallelism, pattern-plan-verification-loop
Conflict recorded: docs homepage “Research→…” vs README/detailed pages “Discuss→…” (canonical: Discuss) — noted in gsd.md and stage-discuss.md
Scope note: documented the 5 workflow commands + 5 core sub-agents; remaining 60+ commands and 29 sub-agents catalogued in gsd.md for future ingest
[2026-06-27] edit | bullet-list formatting for capability enumerations
CONVENTIONS.md: added “Formatting conventions” — enumerate commands/sub-agents as one-per-line bullets ([[link]] — role note), grouped under sub-headings for long rosters
gsd.md: converted Commands, namespaces, Sub-agents (documented + not-yet-documented, now grouped by function), Artifacts, Patterns from inline ·/prose runs to bullet lists
Pattern pages: expanded “Applied by” single-bullet runs into per-capability bullets
Artifact pages: expanded “Produced by” runs into per-capability bullets
[2026-06-28] ingest | Matt Pocock — Skills for Real Engineers (mattpocock/skills)
Conflict recorded: CONTEXT.md filename means different artifacts in GSD (locked decisions) vs MP (domain glossary) — annotated in both artifact-context-md and artifact-domain-model
Cascade: updated all implements: edges, prose, See Also, and index paths across ~25 pages; added aka: to all 5 stage pages; bumped stage updated: to 2026-07-01
Note: historical log entries above retain the old stage names (they record what the stages were called at the time)
[2026-07-01] edit | capture split candidates on stage-plan
stage-plan.md: added ”## Split candidates” section tracking stage-specify (spec/PRD authoring) and stage-design (deep-module design); each with distinction, evidence tally (1 strong vote each — MP splits, GSD folds in), and decisive trigger (spec-first framework e.g. SpecKit/OpenSpec → stage-specify; third design-distinct framework → stage-design)
CONVENTIONS.md: added “Park pending splits on the stage page” rule — split candidates live under a ## Split candidates heading as the per-ingest review queue
No renames/new stages yet — evidence still below the ≥2-framework threshold
STAGE RE-DERIVATION (third framework in evidence):
PROMOTED stage-specify (author the spec/PRD, distinct from task decomposition): Addy’s spec-driven-development became the 2nd framework (with MP’s to-prd) to treat spec authoring as its own step → cleared the ≥2-framework bar. Split out of stage-plan; moved mp-to-prd’s implements stage-plan → stage-specify; wired addy-spec-driven-development. aka: { matt-pocock-skills: to-prd, addy-agent-skills: spec-driven-development }
PARKED stage-review (quality gate: is it good?) as the strongest split candidate on stage-validate: Addy cleanly separates Verify (does it work) from Review (is it good), but is the only framework treating them as distinct phases (MP contributes only review-side, GSD only functional-side) — below the ≥2 bar. Decisive trigger noted: a second framework separating quality review as its own phase (likely Superpowers).
stage-design candidate refreshed: Addy adds a dedicated design skill (addy-api-design) but folds it into Build → design is now a dedicated capability in 2 frameworks but a distinct phase in only 1 (MP); still parked.
stage-release parked a watch-item (operate/maintain) for Addy’s observability + deprecation folded into Ship.
Scope: documented all 24 skills + 4 personas as capability pages (full coverage). The 8 slash commands are thin skill-invokers, catalogued as a phase↔command↔skill↔stage table on the framework page rather than given separate pages; 7 reference checklists + hooks catalogued on the framework page.
Noted for a future ingest: Superpowers (obra) — referenced in Addy’s docs/comparison.md; likely trigger for promoting stage-review.
[2026-07-04] ingest | OpenSpec — spec-driven development (Fission-AI/OpenSpec)
added reciprocal equivalent_to edges on all 10 counterpart capability pages + a reciprocal See Also bullet on each
STAGE RE-DERIVATION (fourth framework in evidence — no renames/splits/merges/adds this ingest):
stage-specify reinforced to three frameworks: openspec-propose centers on authoring the spec (as spec deltas) before code, joining MP + Addy. Stage now beyond doubt.
stage-align now four-framework: added openspec-explore. Noted a second flavor — codebase-investigation (OpenSpec/Addy idea-refine) alongside human-interrogation (grilling cluster). One framework only for explicit codebase-explore → no split.
stage-plan: OpenSpec folds plan into propose (design.md + tasks.md); its implements edge points at stage-specify. stage-design split candidate refreshed — OpenSpec adds a dedicated design.md artifact as a discrete step in proposal→specs→design→tasks, so design is now a dedicated capability/artifact in 3 frameworks but a distinct phase in only 1 (MP); still parked.
stage-validate: openspec-verify added on the functional/spec-conformance side only (OpenSpec ships no quality review) → does NOT advance the parked stage-review split (still Addy-only as distinct phases).
stage-release: added openspec-sync + openspec-archive. Recorded two flavors of release — ship-to-prod (GSD/Addy) vs spec-maintenance (OpenSpec: merge delta into living spec, no deploy/CI/observability). Addy’s ops capabilities still unique.
Cascade (updated + dates 2026-07-04): pattern-spec-driven-development (OpenSpec applied-by + living-spec note); artifact-plan-md (OpenSpec tasks.md producer); artifact-adr (design-md See Also); all 6 stage pages (backlinks, aka, equivalents, split-candidate refresh); 10 counterpart capabilities (reciprocal equivalent_to + See Also); framework See Also cross-links on gsd, addy-agent-skills, matt-pocock-skills
Scope: paged the 6 core workflow commands (explore/propose/apply/verify/sync/archive). Expanded-profile commands (new, continue, ff, bulk-archive, onboard) are thin artifact-generation/batch/tutorial wrappers → catalogued as a table on the framework page (per full-coverage-but-catalogue-thin-wrappers convention). Terminal CLI (init/update/config/validate/list/show/diff/archive) catalogued as a tooling table, not lifecycle capabilities. Legacy /openspec: commands noted as deprecated.
[2026-07-04] ingest | Spec Kit — spec-driven development (github/spec-kit)
Created framework: speckit (fifth framework; GitHub’s reference implementation of SDD — Spec→Plan→Tasks→Implement; largest community, 106K★)
Created capabilities (commands, 10 — full per-command coverage per user preference): speckit-constitution, speckit-specify, speckit-clarify, speckit-plan, speckit-tasks, speckit-analyze, speckit-implement, speckit-checklist, speckit-converge, speckit-taskstoissues
Created artifacts (2): artifact-constitution (signature — immutable project-wide governing principles in numbered articles, .specify/memory/constitution.md), artifact-checklist (“unit tests for your English” — requirements quality gate). Reused artifact-spec-md (spec.md), artifact-design-md (plan.md/data-model.md/contracts), artifact-research-md (research.md), artifact-plan-md (tasks.md), artifact-issue (taskstoissues).
Created patterns (1): pattern-project-constitution (externalize immutable principles into one governing doc + gate every artifact against it — SpecKit’s distinctive contribution)
added reciprocal equivalent_to edges + See Also bullets on all counterpart capability pages
Pattern promotions from single- to two-framework: pattern-contract-first (Addy + SpecKit contracts/), pattern-plan-verification-loop (GSD + SpecKit). pattern-spec-driven-development, pattern-test-driven-development, pattern-grilling extended with SpecKit.
STAGE RE-DERIVATION (fifth framework in evidence — no renames/merges this ingest):
stage-specify reinforced to four frameworks: speckit-specify is the literal /specify step. SpecKit adds a distinctive spec-quality gate (speckit-checklist → artifact-checklist).
stage-align now five-framework: added speckit-clarify (grilling, spec-first ordering variant). PARKED stage-govern split candidate: speckit-constitution establishes project-wide governing principles gated across artifacts — a genuine governance activity, but SpecKit is the only framework with it (others embed principles inside skills; OpenSpec has none). Below the ≥2 bar. Decisive trigger: a second framework with a set-the-project-principles capability.
stage-plan: added speckit-plan + speckit-tasks + speckit-analyze + speckit-taskstoissues. Plan-verification cluster promoted to two-framework (gsd-plan-checker ↔ speckit-analyze). stage-design candidate refreshed — SpecKit emits dedicated design artifacts (data-model.md + contracts/) within plan → design now a dedicated capability/artifact in 4 frameworks but a distinct phase in only 1 (MP); still parked.
stage-implement: added speckit-implement (strictest test-first — TDD mandated by the constitution).
stage-validate: added speckit-converge on the functional/spec-conformance side (action-oriented — re-plans the gap into new tasks rather than only reporting). SpecKit ships no quality-gate review → does NOT advance the parked stage-review split (still Addy-only as distinct phases).
stage-release: SpecKit adds NO backlink — it stops at the validate loop; no deploy/PR/launch/observability command. Noted on the stage page.
Scope: paged all 10 slash commands (5 core + 5 optional) for full per-command coverage. The Specify CLI (init/self/integration/extension/preset/bundle) catalogued as a tooling table on the framework page, not lifecycle capabilities. Noted source discrepancy on speckit-checklist (current docs = requirements-quality; older spec-driven.md = code-vs-spec) — followed current docs.
Housekeeping: removed stray </content> tags left in pattern-contract-first.md and artifact-spec-md.md while editing them.
Created framework: bmad (sixth framework; the most role-oriented & lifecycle-complete — six named personas over Analysis→Planning→Solutioning→Implementation, scale-adaptive, context-engineered)
Created capabilities — sub-agent personas (6): bmad-analyst (Mary), bmad-tech-writer (Paige), bmad-pm (John), bmad-ux-designer (Sally), bmad-architect (Winston), bmad-dev (Amelia)
Created patterns (2): pattern-persona-agents (signature — named expert persona per role + Party Mode), pattern-scale-adaptive-planning (signature — size ceremony to work; Levels 0-4 / Quick-Method-Enterprise tracks; JIT design)
Cross-framework synthesis (six-framework payoff):
specify cluster → FIVE-framework: bmad-prd ↔ mp-to-prd / addy-spec-driven-development / openspec-propose / speckit-specify (reciprocal equivalent_to + See Also on all four)
STAGE RE-DERIVATION (sixth framework — no renames/splits/merges/adds; all candidates refreshed):
stage-align → six-framework. BMAD is the first to populate all three align flavors at once (grilling via facilitator personas, codebase-investigation via document-project, ideation via brainstorming) + adds an adversarial pressure-testing sub-flavor (forge-idea, prfaq). stage-govern NOT advanced — BMAD’s project-context.md/customize.toml are dev rules, not an immutable charter; still SpecKit-only.
stage-specify → five-framework (bmad-prd); BMAD reinforces structurally by giving specify its own Planning phase between Analysis and Solutioning.
stage-plan: added bmad-architect/architecture/create-epics-and-stories/check-implementation-readiness/sprint-planning/create-story/correct-course. stage-design candidate refreshed — BMAD has a dedicated architecture capability + a named Solutioning phase, but Solutioning bundles design+decomposition, so it does NOT isolate design from decomposition as a distinct phase; design now a dedicated capability in FIVE frameworks, distinct phase in only one (MP). Still parked.
stage-implement → six-framework execute cluster (bmad-dev-story + bmad-quick-dev); create-story noted as the plan→implement bridge.
stage-validate: added bmad-code-review (adversarial). stage-review split NOT advanced — BMAD ships a genuine quality-gate (code-review + optional TEA module) cleanly separated from functional testing, but inside the Implementation loop, not as a distinct phase; review now a dedicated capability in ~3 frameworks but a distinct phase in only one (Addy).
stage-release: added bmad-retrospective — a THIRD flavor of release (“learning close-out”), alongside ship-to-prod (GSD/Addy) and spec-maintenance (OpenSpec). BMAD core, like SpecKit, ships no deploy step — but unlike SpecKit it DOES add a close-out backlink. Cluster left as non-equivalent (terminal acts differ too much).
Scope: paged the 6 BMM personas + 19 lifecycle workflow skills (full per-capability coverage per user preference). Cross-phase utility skills (party-mode, advanced-elicitation, review layers, checkpoint-preview, sprint-status, generate-project-context, qa-generate-e2e-tests, dev-auto, shard-doc, help/customize/index-docs) catalogued as a table on the framework page. Optional modules (BMB, CIS, TEA, GDS, WDS, BMad Loop) catalogued as a table, not paged (like GSD’s Pi/Browser and OpenSpec’s expanded profile) — TEA’s Murat noted as BMAD’s quality-reviewer, clustering with stage-validate.
Conflict recorded (version drift): v4/v5 shipped separate Scrum Master (Bob) / Product Owner (Sarah) / BMad Master / BMad Orchestrator agents; v6 folds SM+QA into the Developer (Amelia), epic breakdown into the PM (John), orchestration into the party-mode skill. Some secondary sources (DeepWiki) still list a sm/”Bob” agent; v6 docs canonical at “six named agents.” Annotated on bmad.md.
Version note: v6 migrated to a Claude-Code Agent-Skills architecture (SKILL.md) and replaced the classic numeric Levels 0-4 with stakes-calibrated tracks (Quick Flow / BMad Method / Enterprise); both representations documented on pattern-scale-adaptive-planning.
Housekeeping: removed stray </content> tags found in pattern-parallel-persona-review.md, pattern-adversarial-review.md, pattern-context-engineering.md, artifact-review-report.md, and framework/addy-agent-skills.md while cascading.
Raw: raw/compound-engineering/2026-07-04-compound-engineering-every.md (every.to essay, Shipper & Klaassen, 2025-12-11) + 2026-07-04-compound-engineering-plugin.md (GitHub README + docs/skills + repo tree via gh api)
Created framework: compound-engineering (seventh framework; the only self-feeding loop — Brainstorm→Plan→Work→Simplify→Review→Compound + autonomous /lfg; 80/20 planning-review split; knowledge compounding to docs/solutions/)
NEW CANONICAL STAGE — stage-learn (the headline). User asked whether the “compound” step is a new SDLC stage. Answer per the re-derivation rules: yes. Learning-capture was already latent as the “learning close-out” flavor of stage-release (bmad-retrospective, single-framework, parked). CE’s ce-compound (+ ce-compound-refresh, ce-explain) gives it a second framework, clearing the ≥2-framework bar — same mechanism that promoted stage-specify out of stage-plan.
STAGE SPLIT (stage-release → stage-learn): moved bmad-retrospective implements: stage-release → stage-learn (+ applies pattern-knowledge-compounding); rewrote bmad-retrospective body + See Also. Created sdlc-stage/stage-learn.md (definition, why-distinct-not-a-flavor, two flavors: agent-grounding corpus vs team retrospective, spec-flavored cousin = openspec-sync). Edited stage-release: aka (dropped bmad, added compound-engineering), “three flavors”→“two flavors” note + promotion note, added CE ship-to-prod backlinks (ce-commit/commit-push-pr/resolve-pr-feedback/promote/product-pulse), rewrote cross-framework equivalents + See Also. This is the wiki’s 7th canonical stage and arguably the first genuinely new stage the agent era adds (machine-consumable learnings, not a rename of a classic phase).
learn cluster (new): ce-compound ↔ bmad-retrospective (left non-equivalent — differing terminal acts, like the release cluster)
added reciprocal equivalent_to edges on all counterpart capability pages (30 edits)
STAGE RE-DERIVATION (seventh framework):
stage-learn PROMOTED (see above).
stage-align → seven-framework (ce-brainstorm/ideate/pov/strategy/sweep); added CE ideation + a new evaluate-external-inputs sub-flavor (ce-pov). stage-govern NOT advanced — CE’s STRATEGY.md is a product-strategy context anchor, not an immutable gated charter; still SpecKit-only.
stage-plan → seven-framework; plan-verification promoted to FOUR frameworks (ce-doc-review, persona-fan-out variant). design candidate unchanged.
stage-validate: stage-review split strengthened but NOT promoted — CE makes Simplify (4) + Review (5) explicit distinct loop phases (closer to Addy than BMAD), so review-as-a-distinct-phase now appears in TWO frameworks (Addy, CE); but CE lacks a co-equal functional-validation phase (testing skills are on-demand), so the clean Verify∥Review partition is still cleanest in Addy alone. Not promoted — also avoids two stage-splits in one ingest (minimize rule). Decisive trigger refreshed.
stage-release: two flavors now (learning close-out moved out).
Scope: paged all 26 lifecycle skills + lfg (full per-capability coverage per user preference). The 26 shared sub-agents (research/grounding, review specialists, design/planning) + ~23 review-persona lenses are catalogued grouped-by-function on the framework page rather than individually paged (per the catalogue-thin-helpers convention, as with GSD’s sub-agent roster) — noted here for a future ingest if per-sub-agent pages are wanted. Infra/product-specific skills ce-setup, ce-proof (Proof editor), ce-riffrec-feedback-analysis (Riffrec) catalogued on the framework page, not paged.
User directed full per-sub-agent coverage (reinforces the standing full-coverage memory, which already covers sub-agents). Reversed the prior “catalogue-only” scoping for the 26 CE sub-agents.
Created 26 sub-agent capability pages (subtype: sub-agent, ce--prefixed per the framework-prefixed unique-basename convention), each filed by intrinsic activity:
Note: the compound-council reviewers (security/performance/pattern/data-integrity) are filed by intrinsic activity (validate) with their ce-compound learning role noted, since that’s where their cross-framework counterparts live; the pure researchers/historians file under learn.
Descriptions sourced from the actual agent definitions (gh api on skills//references/agents/.md).
New cross-framework equivalent_to (reciprocal both ways): ce-security-sentinel ↔ addy-security-auditor; ce-performance-oracle ↔ addy-web-performance-auditor.
Wiring: delegates_to populated on 11 dispatching skills (ce-brainstorm/ideate/pov/plan/work/optimize/sweep/resolve-pr-feedback/compound/explain/code-review) → their sub-agents; framework page sub-agent roster rewritten from code-name catalogue to grouped wikilink list (“each paged”); produced-by backlinks added on artifact-security-audit (+ce-security-sentinel), artifact-perf-audit (+ce-performance-oracle), artifact-launch-checklist (+ce-deployment-verification-agent), artifact-explainer (+ce-work-recap-scout), artifact-solution-doc (+7-member council); applied-by bullets added on patterns fresh-context-subagents, source-grounding, knowledge-compounding, adversarial-review, measure-first, plan-verification-loop, context-engineering, deep-modules; index.md +26 sub-agent rows; framework updated → 2026-07-05.
Retained catalogue-only (non-lifecycle): ~23 review-persona lenses inside ce-code-review/ce-doc-review (bundled reference lenses, not standalone agents), and infra/product skills ce-setup/ce-proof/ce-riffrec-feedback-analysis.
[2026-07-05] ingest | gstack (Garry Tan / YC) — eighth framework, largest here
Framework page framework/gstack.md created. Sprint: Think→Plan→Build→Review→Test→Ship→Reflect. The largest framework in the wiki (~54 skills). Ethos: Boil the Ocean / Search Before Building / User Sovereignty.
CAPABILITIES: 54 pages created (full per-capability coverage per standing memory) — all 53 SKILL.md skills + the root router (gstack-router; equivalent_to addy-using-agent-skills). All subtype: command (gstack ships slash-command skills; role personas rather than separately-paged sub-agents). Filed by sprint stage:
stage-learn → THREE frameworks (beyond doubt). gstack ships BOTH flavors — team retrospective (gstack-retro → artifact-retrospective) + agent-grounding corpus (gstack-learn → artifact-solution-doc) + capability-compounding (gstack-skillify). First framework to populate both flavors at once.
stage-validate: stage-review split BAR NOW CLEARED (⚑ not yet executed). gstack is the SECOND framework (after Addy) with a clean Review phase ∥ Test phase partition — the exact decisive trigger. Marked cleared on the stage page + index with a recommendation to promote (stage-validate functional + stage-review quality gate) as a focused next pass — deferred because it’s a ~17-capability re-pointing cascade across the existing wiki that merits its own verifiable ingest, not bundling into gstack’s (already large) one.
stage-release: stage-operate candidate strengthened to capability-level in THREE frameworks (Addy + CE + gstack). gstack is the first with a genuine deploy command (land-and-deploy) separate from ship + a post-deploy monitor (canary), but still nests them under release rather than a standalone Operate phase — so strengthened, not promoted.
Executed the follow-up flagged above. Promoted stage-review as the 8th canonical stage, splitting the (previously widest) stage-validate into its two long-parked halves once gstack became the 2nd framework (after Addy) with a clean Verify (functional) ∥ Review (quality) phase partition — clearing the ≥2-framework bar (same mechanism as stage-specify ← stage-plan and stage-learn ← stage-release).
Frameworks: MP, Addy, BMAD, CE, gstack (5). GSD, OpenSpec, and Spec Kit ship no review capability (functional validators only) — the clean absence that made the split correct.
Classification rule (framework-neutral, by activity): run it and observe → validate; read it and judge quality → review. equivalent_to clusters kept intact within one stage (code-review, security, performance, simplification, browser-testing, iOS-test). Judgment calls: gstack-benchmark → review (performance cluster, not “Test” despite gstack’s label); addy-test-engineer → review (Addy’s Review-phase /ship persona); gsd-verifier → validate (goal-backward = functional).
New page: sdlc-stage/stage-review.md (full projection: promoted-note, why-distinct, backlinks by framework, clusters, See Also). Rewrote sdlc-stage/stage-validate.md to functional-only (removed the review backlinks, narrowed the definition/aka, replaced the split-candidate section with a “resolved” note).
Stage count now 8: align · specify · plan · implement · validate · review · release · learn.
Dangling-wikilink check: to be confirmed clean post-cascade.
[2026-07-09] ingest (update) | Matt Pocock — Skills for Real Engineers v1.1
Re-ingest of github.com/mattpocock/skills at v1.1 (was 2026-06-28). New raw: raw/matt-pocock-skills/2026-07-09-skills-v1.1-update.md (README + full SKILL.md catalogue across engineering/productivity/misc/deprecated/in-progress/personal + CHANGELOG v1.1 highlights). Old raw retained (immutable).
RENAMES (page + full wikilink cascade across 20 files; log.md history left intact):
to-prd → mp-to-spec — “spec” is now the through-line term; produces artifact-spec-md, no longer artifact-prd (still opens “you may know this as a PRD”).
to-issues + to-plan → mp-to-tickets (to-issues deleted) — tracer-bullet tickets with blocking edges; local tickets.md vs native tracker links; wide-refactor expand–contract.
Source: github.com/buildermethods/bm-skills (Brian Casel). A Claude Code plugin marketplace of small, independent builder utilities — not a full-SDLC framework; ingested primarily to capture the PRD Creator. Raw: raw/bm-skills/2026-07-09-bm-skills.md (README + CLAUDE + 3 SKILL.md + PRD step catalogue).
Framework page framework/bm-skills.md (noted explicitly as a light utility collection, not a lifecycle engine).
Source: github.com/tao-hpu/nano-spec (Tao An, MIT, 46★) + intro article “The Sweet Spot Between Chaos and Over-Engineering in AI-Assisted Development” (Generative AI / Medium, 2025-12-01). Raw: raw/nano-spec/2025-12-01-nano-spec.md (README + SKILL.md verbatim + article digest). A deliberately minimal, tool-agnostic spec methodology — “Spec-driven thinking, nano-sized docs”; not a full-SDLC framework (like bm-skills).
Framework page framework/nano-spec.md carries the requested source_url (repo) and docs_url (article) frontmatter properties in addition to the standard sources:/raw:.
CAPABILITIES (3 paged, full coverage per the one-page-per-action convention; one /nano-spec skill, $ACTION = create/status/update, re-published as system-prompt configs for 9 other agents): nano-spec-create (focus — specify; generates the 4-doc pack), nano-spec-status (no stage — read-only progress report; session-handoff), nano-spec-update (no stage — living-doc maintenance; session-handoff).
NEW artifact artifact-nano-spec-pack (nano-spec’s signature: tasks/{name}/ README+todo+doc+log). Component mappings also wired to existing artifacts: artifact-plan-md (+nano-spec todo.md), artifact-adr (+nano-spec doc.md Key Decisions).
PATTERNS: pattern-spec-driven-development (+nano-spec, minimalist instance; also back-filled missing bm-prd-creator backlink), pattern-scale-adaptive-planning (+nano-spec — a fixed middle tier on the no-spec→nano→full-spec spectrum, the pattern applied at the methodology level; now 3-framework), pattern-session-handoff (+nano-spec — the always-current 4-file pack is the handoff; now 4-framework).
STAGE re-derivation: no new stage / split / merge / retire (small, single-stage ingest); no parked split candidate cleared. stage-specify (+nano-spec-create → 8-framework; aka +nano-spec; date 2026-07-13). nano-spec ships no stage-plan/stage-implement/stage-validate/stage-review/stage-release/stage-learn capability (its log.md is within-task journaling, not cross-iteration knowledge-compounding).
[2026-07-17] ingest | Superpowers (Jesse Vincent / Prime Radiant) — 14-skill methodology
Source: github.com/obra/superpowers @ v6.1.1 (Jesse Vincent, Prime Radiant; MIT; release announcement blog.fsck.com 2025-10-09). Raw: raw/superpowers/2026-07-17-superpowers.md (README + plugin.json + all 14 skills/*/SKILL.md verbatim; supporting files noted, not reproduced). A complete methodology from a small library — 14 skills, no personas, no commands, no deploy — made whole by a bootstrap (sp-using-superpowers) that forces skill invocation before any action; cross-harness (Claude Code/Codex/Cursor/Kimi/OpenCode/Pi/…).
Framework page framework/superpowers.md: the mandatory-skill bootstrap, the gated pipeline (brainstorm→worktree→plan→subagent-driven→TDD→review→finish), 4 philosophy pillars, capabilities by function, artifacts, patterns, See Also.
STAGE re-derivation: no new stage / split / merge / rename — Superpowers fits the existing 8 stages, touching 7 (no stage-specify: design folds into brainstorming→writing-plans, like GSD). Notable reinforcement: it is the 3rd framework (after Addy, gstack) with a clean functional-validate ∥ quality-review partition (verification-before-completion ∥ code-review), and the 4th framework in stage-learn (capability-compounding flavor). Split candidates unchanged: stage-govern (no constitution), stage-design (folds design in), stage-operate (no deploy). aka + dates → 2026-07-17 on stage-align/plan/implement/validate/review/release/learn.
[2026-07-19] docs | artifact index — visual map of the 34 artifacts
Not an ingest: no new source, no ontology/edge changes. Added a reader-facing index for the artifact/ namespace (the namespace had none; only sdlc-stage/ did).
NEW wiki/artifact/index.md: a whole-lifecycle flow overview Mermaid diagram of all 34 artifacts grouped by producing stage (solid leads-to/feeds/gates edges + dotted grounds-next-loop back-edges), then a stage-by-stage detail section — one Mermaid per SDLC stage, each in the layout that fits its artifacts (Align two-cluster · Specify hub-around-spec · Plan pipeline · Implement converge · Validate repair-loop · Review fan-in · Release converge/diverge · Learn hub + loop-back). Boundary artifacts from adjacent stages shown as dashed rounded nodes for context. Closes with a stage-ordered table of all 34 (Obsidian wikilinks) + See Also.
Each of the 8 stage-detail section headings links to its stage page (../sdlc-stage/stage-<x>.md); all 8 targets verified.
Not an ingest: no new source. Resolved a slug asymmetry around the cross-framework CONTEXT.md clash. GSD’s phase-context artifact was slugged by filename (artifact-context-md) while MP’s was slugged by meaning (artifact-domain-model), implying the GSD page “owned” the canonical name when neither does.
Renamed wiki/artifact/artifact-context-md.md → artifact-phase-context.md (git mv); H1 retitled CONTEXT.md (phase context) → Phase context (CONTEXT.md) to mirror Domain model (CONTEXT.md) (meaning-first). Both CONTEXT.md artifacts are now filed by what they are; the colliding filename belongs to neither slug.
Reciprocal naming-conflict callouts and the Align-stage same filename, different artifact dotted edge left intact. Historical log entries above retain the old slug as-written.
Not an ingest: no new source, no ontology/edge changes. Added a visual summary of the schema itself at the top of CONVENTIONS.md (before the Node types table), since the diagram depicts the meta-model the conventions define — not the concrete articles the index.md files list.
NEW ## The ontology at a glance section: a Mermaid flowchart showing the 5 node types (framework/capability/sdlc-stage/artifact/pattern) and 6 stored edges (belongs_to/implements/produces/applies/delegates_to/equivalent_to), all originating from capability as the hub; plus a dashed derived-projection edge (sdlc-stage synthesized from implements-backlinks). Distinct node shapes per type; solid = stored frontmatter edge, dashed = derived. Cross-links to the Node types + Relationship vocabulary tables.
Diagram validated via @mermaid-js/mermaid-cli (renders clean).
Not an ingest: no new source. Corrected one capability’s implements: edge. mp-wayfinder maps an oversized effort as a tracker of investigation tickets that resolve decisions (“Plan, don’t do — tickets resolve decisions, not deliverables”) and hands its output to mp-to-spec / mp-to-tickets. Since mp-to-spec IS stage-specify, wayfinder must sit upstream of the spec — i.e. it shapes what to build (stage-align), not decompose-the-how (stage-plan). Fits stage-align’s definition (align on what to build and why; capture/lock decisions) as a large-scale decision-mapping flavor.
capability/mp-wayfinder.md: implements stage-plan → stage-align; See Also stage link + rationale; updated date.
sdlc-stage/stage-plan.md: removed the mp-wayfinder backlink; dropped wayfinder from the matt-pocock-skills aka; updated date.
sdlc-stage/stage-align.md: added mp-wayfinder backlink (decision-mapping flavor) under Matt Pocock; added wayfinder to the matt-pocock-skills aka; updated date.
framework/matt-pocock-skills.md: moved mp-wayfinder from the “Skills — plan” group to “Skills — align / elicitation & intake”.
index.md: mp-wayfinder row now reads “(align)”; updated date. Framework-count on both stages unchanged (MP already counted on each). No stage added/removed/renamed. artifact-issue.md left as-is (stage-neutral; wayfinder still produces tracker issues).
[2026-07-20] docs | SDLC index — framework × stage support matrix
Not an ingest: no new source, no ontology/edge changes. Added a second table to sdlc-stage/index.md: 11 frameworks (rows) × 8 canonical stages (columns), each cell an emoji support level. Derived mechanically from the implements: edges of every capability (framework = belongs_to, stage = implements), then graded.
Legend: 🟢 native (dedicated step / several capabilities) · 🟡 partial (1–2 caps, not a distinct phase) · 🔗 folded into an adjacent stage · ➖ none. Rows ordered by lifecycle coverage (gstack/CE/Superpowers full-8 at top → nano-spec point-tool at bottom).
Footnote captures nuance the emoji can’t: OpenSpec Release = spec-merge not deploy (gstack the only real deploy); folded cases (GSD/Superpowers/CE fold specify into Align/Plan; OpenSpec folds plan into propose); BM Skills + nano-spec are deliberate point tools. Consistent with the existing Note that GSD/OpenSpec/Spec Kit ship no Review and Spec Kit no Release.
Extended the framework × stage support matrix with a 9th Off-stage column: a count (not a support level — kept visually distinct from the 🟢/🟡/🔗/➖ stage cells) of each framework’s capabilities that map to no lifecycle stage. Counts: gstack 5, Matt Pocock 2, nano-spec 2, Addy 1, Superpowers 1, BM Skills 1; GSD/OpenSpec/Spec Kit/BMAD/Compound Engineering 0.
NEW ### Off-stage capabilities subsection: the 12 no-stage capabilities grouped by kind — routing/dispatch & bootstrap (the near-universal cluster: addy-using-agent-skills ↔ mp-ask-matt ↔ gstack-router ↔ sp-using-superpowers), session/context continuity (mp-handoff), spec-pack state ops (nano-spec-status/update), publishing & diagrams (gstack-diagram/make-pdf), tooling & self-maintenance (gstack-benchmark-models/upgrade, bm-favicon-creator).
Insight recorded: process-owning frameworks (GSD/OpenSpec/Spec Kit/BMAD/CE) keep everything on-lifecycle (zero off-stage); toolkit/marketplace-style ones ship standalone utilities around the pipeline. All 15 wikilinks verified.
[2026-07-26] ingest | Sandcastle + Warren — NEW runtime node type (execution layer)
Ontology extension (6th node type). Added runtime — the agent execution/orchestration substrate (sandbox isolation, parallelism, AFK autonomy, steering, persistence): where and how an agent runs, vs the process layer’s what. Motivated by the observation (confirmed with the user) that Sandcastle and Warren are a genuinely different entity type from the process frameworks: they ship no SDLC capabilities and would contribute nothing to stage synthesis if force-fit as frameworks. Rather than dilute framework or pollute the framework×stage matrix, they get their own layer.
The seam is pattern, not sdlc-stage. A runtime carries no belongs_to/implements/equivalent_to; it stores exactly one new edge — enables: (runtime → pattern[]) — the infra-side realization of patterns that capabilities apply at the process level. pattern pages now collect two backlink rosters: Applied by (capabilities) + Enabled by (infrastructure) (runtimes).
CONVENTIONS.md: opening scope para (added the execution layer); “ontology at a glance” now “Six node types, seven relationship edges”; Mermaid diagram gains RT{{runtime}} + RT -->|enables| PAT; node-types table + runtime subtypes (library|platform) + runtime frontmatter example + enables row in the relationship vocabulary + derived-edges note + naming-convention row; NEW ## The execution layer (runtimes) section (orthogonal layer, synthesis-as-matrix-not-nodes with a parked graduation trigger, runtime ingest workflow).
NEW raw/runtime/ with verbatim README captures: 2026-07-26-sandcastle.md, 2026-07-26-warren.md.
NEW wiki/runtime/:
sandcastle.md (subtype library) — Matt Pocock’s TS SDK; enables: worktree-isolation + autonomous-loop + wave-parallelism + session-handoff. The library pole.
warren.md (subtype platform) — Jaymin West’s self-hosted control plane (os-eco, v0.9.10); enables: autonomous-loop + worktree-isolation + knowledge-compounding + session-handoff. The platform pole.
index.md — layer overview + orchestration-concern comparison matrix (the runtime analogue of the stage synthesis) + broader-category note (Conductor, Container-use, Sculptor, os-eco siblings).
Deliberately not linked: pattern-fresh-context-subagents (these runtimes isolate the filesystem/process, not the agent’s context window — that’s worktree-isolation’s territory; the harness owns context).
index.md: intro now names six namespaces; NEW ## runtime section (2 rows + matrix pointer); 5 pattern rows annotated with their infra-side + dates bumped to 2026-07-26.
No stage added/renamed/retired (runtimes implement no stage). Stage set unchanged at 8.
Verification: dangling-wikilink check across wiki/ — clean; every [[sandcastle]]/[[warren]] and enables: target resolves.
[2026-07-31] ingest | Claude Code — NEW harness node type (agent-program layer) — SCHEMA + PROOF PAGE
Ontology extension (7th node type). Added harness — the agent program itself (Claude Code, pi, OpenCode, …): the loop that loads a framework’s skills/commands and drives the model’s tool-call cycle. Motivated (confirmed with the user) by the observation that the two existing layers were already defined against it — frameworks were described as “cross-harness” and runtimes as “harness-agnostic” — yet it had no node. It is the middle/pivot layer: not a framework (ships execution primitives, not an SDLC methodology) and not a runtime (it is the thing runtimes spawn/wrap, one layer up).
Two new stored edges + a second enables domain.framework --runs_on--> harness[] (the first forward edge a framework page stores — turns “cross-harness” prose into structure) and runtime --runs--> harness[] (turns “harness-agnostic” prose into structure). harness --enables--> pattern[] reuses the enables edge (now domain = runtime or harness), so pattern pages gain a third backlink roster: Provided by (harness) alongside Applied by (capabilities) and Enabled by (infrastructure) (runtimes). “Ontology at a glance” now reads “Seven node types, nine relationship edges.”
CONVENTIONS.md: opening scope para (two substrate layers, harness as pivot); “ontology at a glance” para + Mermaid (HAR{{harness}} + FW -->|runs_on| HAR, RT -->|runs| HAR, HAR -->|enables| PAT); node-types table + harness subtypes (terminal|ide) + harness frontmatter example + framework-now-carries-runs_on note + runs_on/runs/broadened-enables rows in the relationship vocabulary + derived-edges note (harness is both target and source, like capability) + naming-convention row; NEW ## The harness layer section (framework/runtime boundary test, synthesis-as-matrix-not-nodes with parked graduation trigger, harness ingest workflow).
NEW raw/harness/2026-07-31-claude-code.md — source capture from Anthropic Claude Code docs + Agent SDK.
index.md: intro now names seven namespaces; NEW ## harness section (claude-code row + matrix pointer); ## runtime blurb now also points through the harnesses it runs:.
No stage added/renamed/retired (a harness implements no stage). Stage set unchanged at 8.
STAGED — remaining work (the “rest”, pending user review of the shape):
Ingest pi and OpenCode as full pages (turns the one-column matrix into a real cross-harness comparison).
Fleet-wide runs_on: wiring across the other 9 frameworks (GSD/CE/Addy/BMAD/SpecKit/OpenSpec/BM/nano-spec/matt-pocock) + bump their updated:/index rows.
Extend runs: on sandcastle/warren to the full provider lists (needs Codex/Cursor/OpenCode/Copilot/pi pages or stubs so nothing dangles — currently only [[claude-code]] wired to keep the dangling-link check clean).
Verification: dangling-wikilink check across wiki/ — clean; every [[claude-code]] reference resolves. Not-yet-paged harnesses (pi, opencode, codex, cursor, copilot) are named in bold plain text (runtime “broader category” precedent), never as wikilinks, so nothing dangles.
[2026-07-31] ingest | pi + OpenCode harnesses; fleet-wide runs_on:; “officially supported” rule — completes the harness layer
Completes the STAGED work from the proof slice above, after user review of the shape. User decision recorded: runs_on: / runs: link only to officially supported/documented harnesses, not any a framework could theoretically run on.
Convention (CONVENTIONS.md):runs_on/runs vocab rows now say “officially supports/documents”; NEW Support scope paragraph — an edge = documented support; a supported harness with no page yet is recorded in prose (not a dangling edge) and wired when ingested, so stored edges trail documented support until every referenced harness has a page.
Two new harness pages (both subtype: terminal, MIT, model-agnostic), from web-researched raw captures raw/harness/2026-07-31-{opencode,pi}.md:
opencode.md — Anomaly (ex-SST); batteries-included + model-agnostic; enables: all four patterns (fresh-context-subagents, edit-guardrails, session-handoff, context-engineering). The open/model-agnostic pole.
pi.md — Zechner/Earendil; minimal core (4 tools; sub-agents/MCP/permissions/plan-mode excluded → extensions); enables:only session-handoff + context-engineering. The minimalist pole and the harness-layer counterpart to nano-spec.
The layer’s sharpest finding, now encoded:pattern-fresh-context-subagents and pattern-edit-guardrails are harness primitives in claude-code + opencode but absent from pi’s core — a pattern that is a primitive in some harnesses and not others. Both pattern pages’ harness rosters now carry an explicit Not pi bullet.
Fleet-wide runs_on: wired on all 11 framework pages (paged subset only — claude-code/opencode/pi), from cited official-support evidence per framework: claude-code+opencode+pi → compound-engineering, superpowers; claude-code+opencode → gsd, addy-agent-skills, gstack, nano-spec; claude-code-only → matt-pocock-skills, openspec, speckit, bmad, bm-skills.
runs: extended:sandcastle → claude-code+opencode+pi; warren → claude-code+pi (paged subset of their documented provider lists).
Cascade: the 4 enabled patterns’ Provided by (harness) rosters + sources/updated refreshed (opencode on all 4; pi on session-handoff + context-engineering). harness/index.md — 3-member table, 3-column capability matrix, NEW Framework support (runs_on: inverse) matrix (the central home for full documented-support lists incl. unpaged harnesses in plain text), updated patterns-supplied + broader-category. wiki/index.md — 3 harness rows; claude-code.md backlinks now list all 11 frameworks.
Unpaged-but-officially-supported harnesses (Codex, Cursor, Copilot, Gemini CLI, Kimi, Windsurf, Qwen, Antigravity, Factory Droid, sapling, …) recorded as plain text in the framework-support matrix + harness/index.md ingest queue, per the Support-scope rule — candidates for future ingest.
No stage change (harnesses implement no stage). Stage set unchanged at 8. Harness layer now: 3 pages.
Verification: dangling-wikilink check across wiki/ — clean (see below); every runs_on:/runs:/enables: edge target resolves to a page.
[2026-08-02] ingest | Factory Droid harness — the fourth terminal harness, the model-routing pole
New harness pagewiki/harness/factory-droid.md (subtype: terminal, proprietary), enables: all four patterns — fresh-context-subagents (Custom Droids: fresh context + own session + per-droid model, Task tool + run_in_background), edit-guardrails (autonomy levels off/low/medium/high via --auto + read-only review + hooks + approval workflows), session-handoff (own-session subagents + Sessions API + headless droid exec), context-engineering (AGENTS.md standard + skills + 40+ MCP servers + plugins).
The distinctive axis: model routing. Where claude-code is Anthropic-only and opencode/pi are “model-agnostic,” Droid makes routing between models first-class — Anthropic/OpenAI/Google/open-weight, mid-session swap, complexity-tiered per-subagent, BYOK, plus a free open-weight Droid Core tier. Second signature: Missions (harness-native multi-agent orchestration; noted runtime-adjacent per the boundary test). Primitive set is otherwise Claude-Code-shaped (Custom Droids/Skills/Hooks/Plugins ≈ 1:1).
runs_on: wired on the three individual-author cross-harness frameworks that officially name Factory Droid — compound-engineering, gstack, superpowers (moved from prose-only to stored edges; updated: bumped on all three).
Cascade: the 4 enabled patterns’ Provided by (harness) rosters + See-Also harness lines now include factory-droid. harness/index.md — 4-member table, 4-column capability matrix, model-access spectrum prose rewritten, framework-support matrix bolds factory-droid for CE/gstack/superpowers, patterns-supplied bullets + broader-category + ingest-queue updated (Factory Droid removed from queue; count 3→4). wiki/index.md — new factory-droid harness row.
No stage added/renamed/retired (a harness implements no stage). Stage set unchanged at 8. Harness layer now: 4 pages.
Verification: dangling-wikilink check across wiki/ — clean; every [[factory-droid]] reference resolves to the new page. Remaining unpaged-but-supported harnesses (Codex, Cursor, Copilot, Gemini CLI, Kimi, Windsurf, Qwen, Antigravity, sapling) still recorded as bold plain text per the Support-scope rule.
[2026-08-05] schema | NEW topic overlay layer + first topic (Fowler’s Harness Engineering)
Motivation: a recurring user question — how to make agents follow project conventions and refine that over time (rules files, standards docs, ADRs, verifiers, solution corpora, CLAUDE.md). Concluded it is not a new ontology node but a cross-cutting family already decomposed across artifact + pattern + harness; what was missing was (a) connective tissue and (b) a page-type for authored, top-down reference hubs (a “pattern that links patterns” would be a category error, since patterns are minted bottom-up from capability backlinks).
CONVENTIONS.md: added the topic layer — an eighth namespacetopic/ that is explicitly not one of the seven ontology node types but a curated overlay (Map of Content) sitting above the graph. New section “The topic layer (curated overlays)”: the four-way distinction (index / sdlc-stage / pattern / topic), the overlay rule (topics store no edges, are never evidence, and must not add authored “referenced-by” rosters to targets — Obsidian’s auto-backlink panel is fine), lean frontmatter (type: topic), the discipline (≥3 namespaces, few, hand-maintained), and an authoring note (no stage re-derivation, no backlink cascade). Added a naming-table row (topic-<name>) and an overlay note under the node-types table.
New:raw/reference/2026-08-05-fowler-harness-engineering.md (immutable capture of martinfowler.com/articles/harness-engineering.html) + wiki/topic/topic-harness-engineering.md. The topic adopts Fowler’s vocabulary — guides (feedforward) / sensors (feedback) closed by a steering loop; computational vs inferential controls; keep quality left — and threads it through existing wiki pages, while explicitly reconciling Fowler’s broad “harness” ≠ this wiki’s harness node. Flags two concepts the wiki lacks (harnessability / ambient affordances) as a candidate future pattern, and folds in the “as models improve, the authored guide layer thins to the non-derivable kernel” analysis.
Light vocab edits (cross-links, not new rosters):pattern-shift-left (“keep quality left”), pattern-plan-verification-loop + pattern-adversarial-review + pattern-evidence-before-claims (framed as sensors; computational-vs-inferential), each with a See-Also to the topic. pattern-context-engineering + pattern-knowledge-compounding See-Also to the topic (guide-delivery / steering-loop).
index.md: new ## topic section + intro note. No stage change (a topic implements none).
[2026-08-05] ingest | Agent OS (Builder Methods) — v3 standards/guide-layer framework; 9th specify-cluster member
Source → raw/agent-os/2026-08-05-agent-os.md (web-researched capture: buildermethods.com/agent-os sub-pages + github.com/buildermethods/agent-os README/CHANGELOG/git-tree/raw command files). Captured v3.0.0 (released 2026-01-20) — a major refocus: v3 retired v2’s implementation/orchestration commands (create-spec/create-tasks/execute-tasks) and all sub-agents, keeping only the standards + spec-shaping layer. A live example of the “delete the derivable, keep the non-derivable” thesis on topic-harness-engineering.
New frameworkwiki/framework/agent-os.md (runs_on: [[claude-code]]; Cursor/Windsurf/Codex/Antigravity in prose per support-scope). Brian Casel / Builder Methods (also ships bm-skills), MIT, ~5.2K★. Identity: a deliberately non-full-SDLC framework (with bm-skills + nano-spec) whose primary value is the persistent guide layer.
5 capability pages (all subtype: command, no sub-agents in v3): agent-os-discover-standards, agent-os-index-standards, agent-os-inject-standards (the three cross-cutting guide-layer commands — no canonical stage, implements: []); agent-os-plan-product (→ stage-align, product-direction flavor; equivalent_toce-strategy); agent-os-shape-spec (→ stage-specify, 9th specify-cluster member).
2 new artifacts:artifact-standards (the signature — declarative conventions + index.yml matcher; the advisory/mined counterpart to SpecKit’s gatedartifact-constitution) and artifact-product-docs (mission/roadmap/tech-stack; counterpart to CE’s STRATEGY.md).
equivalent_to cascade: added [[agent-os-shape-spec]] to all 8 existing specify-cluster members (addy-spec-driven-development, bm-prd-creator, bmad-prd, gstack-spec, mp-to-spec, openspec-propose, speckit-specify, nano-spec-create) + [[agent-os-plan-product]] to ce-strategy (reciprocal).
Pattern rosters: Agent OS added to pattern-context-engineering (flagship — inject/index/discover-standards), pattern-knowledge-compounding (standards-compounding via sync-to-profile), pattern-grilling (AskUserQuestion-only interaction), pattern-scale-adaptive-planning, pattern-spec-driven-development. artifact-spec-md gains shape-spec.
Stage re-derivation: no add/rename/split/merge/retire — stage set unchanged at 8. stage-align now 10 frameworks (plan-product, product-direction flavor); stage-specify now 9 (shape-spec, uniquely standards-binding). The stage-govern split candidate updated: Agent OS sharpens but does not advance it — its standards are externalized-but-advisory (injected, not gated), landing with CE on the “read as context” side; the gated bar stays at one framework (Spec Kit). Noted the real second cluster is likely “advisory externalized standards” (→ the guide layer).
Verification: dangling-wikilink check across wiki/ — see below.
[2026-08-07] topic | Agent readiness — the second overlay; scoring the substrate the agent works in
Motivation: a user question — could the wiki capture checklist-style actions for improving a repository for agents? Two public rubrics were named: Factory’s Agent Readiness and VirtusLab’s Visdom maturity matrix. Both turn out to run the wiki’s usual arrow backwards: every existing namespace models what the agent does; a readiness rubric scores the substrate the agent acts on, treating agent performance as the dependent variable (“The agent is not broken. The environment is.”).
New raw sources:raw/reference/2026-08-07-factory-agent-readiness.md (marketing + announcement + docs overview/report/dashboard; levels, pillars, run/fix flow, binary scoring, the 7%→0.6% determinism result; kodustech/agent-readiness + agent-ready.org noted as third-party implementations) and raw/reference/2026-08-07-visdom-maturity-matrix.md (the complete 16-capability × 5-level Must/Should criteria set from the four perspective pages, plus the thesis blog, the practice-guide template, and the 60 Development guide slugs; 240 guides total enumerated from sitemap.xml).
New topic pagewiki/topic/topic-agent-readiness.md — the second member of the overlay layer. Frames the inversion; compares the two rubrics (repo-scoped/mechanical/binary/CI-runnable vs org-scoped/facilitated/Must-Should/workshop); names the shared 5-level ad-hoc→autonomous ladder and its gated, not additive property (Factory’s 80%-per-level unlock; Visdom’s L3 break-even / L4 realistic ceiling); then maps the criteria onto the wiki pages that already implement them across eight pillar groupings.
Closes a flagged gap.topic-harness-engineering ended by naming harnessability and ambient affordances as Fowler concepts with no home here. The rubrics are exactly that, operationalized and scored — recorded as a “Partly closed (2026-08-07)” note on that page, with the two topics framed as a pair (controls built vs substrate required). pattern-ambient-affordances remains unminted; the rubrics are now its evidence base.
Six gaps recorded (criteria both rubrics treat as load-bearing with no counterpart in any of the 12 frameworks): test-suite trustworthiness as a measured property (mutation testing, TORS, flaky quarantine, incremental selection); feedback latency as a budget (CI <2 min, sandbox CI absorbing 50+ agent iterations); agent economics (ITS, CPI, auto-approve rate, cost-per-feature); provenance/audit of AI-generated code (model version, session ID, AI-vs-human in VCS, EU AI Act); auto-merge on classification (Green/Yellow/Red — every review capability here reports to a human); org design (Context Engineer role, span of control). Candidate future pattern pages.
Counter-observation recorded: neither rubric has any criterion for stage-align / stage-specify / stage-plan — a repo can score L4 on every mechanical signal and still build the wrong thing fluently. The wiki’s 9-framework specify cluster is the counterweight; the two bodies of knowledge are near-disjoint.
No new namespace. Considered and parked per the CONVENTIONS anti-premature-abstraction discipline: a rubric performs no stage and ships no capability, and every criterion already has a home in pattern/artifact/capability. Graduation trigger written into the page: (1) a 3rd/4th structurally different rubric (near-clones like kodustech don’t count); (2) two or more frameworks shipping a repo-assessment capability — which would evidence a cross-framework cluster and a likely stage-assess split candidate on stage-align; (3) the comparison table ceasing to scale. Noted that Factory’s /readiness-report + /readiness-fix are real factory-droid commands and are the nearest ingest candidate.
Cascade: per the overlay rule, no stored edges, no backlink rosters, no stage re-derivation. Touched only: the new topic page, one cross-link paragraph on topic-harness-engineering, and the ## topic row in index.md. Stage set unchanged at 8. Topic layer now: 2 pages.
Verification: dangling-wikilink check across wiki/ — clean (one [[capability]] generic-namespace link caught and demoted to plain text).
[2026-08-11] docs | index.md rewritten as a public landing page
Motivation:wiki/ is published to GitHub Pages via Quartz (.github/workflows/deploy.yml, baseUrl pmackay.github.io/sdlc-wiki), which makes wiki/index.md the site’s front door. It opened straight into the mechanical namespace catalogue — correct as an index, unreadable as a landing page.
Added above the catalogue: a plain-language framing (what the wiki is, why comparing these frameworks is hard, what the cross-linking produces that reading the sources individually does not), current coverage counts, a How it is organised section explaining the three layers + the derived/authored page-type distinction, a Ways to use it section (7 entry paths: choose a framework · borrow one capability · find the multi-framework consensus · design your own skill library · improve the repo first · pick harness/runtime · get oriented), and a Provenance note including the explicit non-claim that nothing here is a benchmark.
H1 retitled Knowledge Base Index → SDLC Agent-Skill Wiki (matches the workflow’s PAGE_TITLE). Catalogue preserved verbatim under a new ## The catalogue divider; namespace headings left at ## so every existing anchor still resolves.
Publication fix: the two [capture](../../raw/…) links on the topic pages pointed outside the published wiki/ content root and would have 404’d on the site; repointed to github.com/pmackay/sdlc-wiki/blob/main/raw/…, which resolves both in Obsidian and on the web. Note for future ingests: raw/ is not published — cite captures by GitHub URL, not relative path.
Verification: all 14 relative links and all 8 section anchors in index.md resolve; no dangling wikilinks introduced. No content, edge, or stage changes.
[2026-08-11] docs | catalogue split out of index.md into its own page
Motivation: follow-on from the landing-page rewrite. index.md was carrying two jobs — an authored introduction and the ~370-line exhaustive namespace catalogue — so a visitor scrolled a long way past the useful part, and every ingest re-touched the front page.
New pagewiki/catalogue.md — all eight namespace sections moved verbatim (framework · capability · sdlc-stage · artifact · pattern · harness · runtime · topic), under a short header that names the layer structure and points newcomers back to the introduction. Row content, ordering, and per-row links unchanged; the sections’ relative links (framework/gsd.md, …) still resolve because catalogue.md sits at the same wiki/ root.
index.md is now purely the authored landing page (49 lines): intro → How it is organised → Ways to use it → Provenance → a closing pointer to the catalogue with per-namespace deep links. Its eight in-page anchors were repointed from #framework-style to catalogue.md#framework-style.
CONVENTIONS.md updated so future ingests write to the right file — the six references to the root index.md as the catalogue now read catalogue.md (harness ingest, runtime ingest + matrix, topic authoring, stage-rename cascade step 4, ingest-workflow step 6). The four-aggregations table row is now catalogue.md, annotated that index.md is the authored introduction pointing into it. The two wiki/harness/index.md references (a different file — the harness-layer matrix) were correctly left alone.
Historical log.md entries still say “index.md” for catalogue edits; left as written since the log is an immutable record of what was true at the time.
Verification: every relative link in both files resolves; all eight anchors match headings in catalogue.md; no bare in-page anchors left in index.md. No content, edge, or stage changes.
[2026-08-11] fix | title: frontmatter on the two landing pages
Verified the published site after the split and found Quartz renders <h1 class="article-title"> from frontmatter, falling back to the filename — so the landing page showed a literal “index” heading (and browser tab) above the real title, and the new page showed “catalogue”.
Added title: SDLC Agent-Skill Wiki to index.md and title: Catalogue to catalogue.md, removing the now-duplicate body # heading from each (Quartz renders the frontmatter title as the page heading; Obsidian titles a note by filename regardless, so nothing is lost there).
Known, not fixed:every other page has the same issue — no page carries title:, so all ~305 render their slug as the heading and tab title (gsd, stage-align, topic-agent-readiness, …) above their own # heading. Fixing it means adding title: to every page (derivable from each file’s existing # line) or configuring Quartz to prefer the first heading. Deferred as a separate decision rather than a 305-file sweep.
[2026-08-11] build | page titles derived from H1 at build time
Finding: the intended fix for the site-wide title problem — configure Quartz to prefer the first heading — is not available. Quartz v5’s plugin schema exposes no title-source option, there is no @quartz-community/frontmatter package, and Head.tsx reads fileData.frontmatter?.title with the filename fallback baked into core. Verified against a clone of jackyzha0/quartz@v5.
Chosen instead (same intent, no content churn): a build step that injects titles into the copied content tree, so the vault stays pure Markdown per the workflow’s own B-lean design note. New .github/scripts/inject-titles.py, run between “Use wiki/ as Quartz content” and “Configure Quartz”.
What it does: for each .md with no title:, promotes the leading # heading into frontmatter (creating the block if absent) and removes that heading from the body — Quartz renders the frontmatter title as the page heading, so leaving it would render twice. Strips markdown from the heading ([[a|b]]→b, links, bold/italic, code) and double-quotes with escaping. Conservative: skips any file that already has a title, has no H1, or whose H1 is not the first non-blank body line.
Verified on a copy of wiki/: 331 injected, 2 skipped (index.md + catalogue.md, which now carry explicit titles); all 333 files parse with title as the first frontmatter key; no duplicate titles; longest title 99 chars.
Consequence for authors: a page’s # heading is now also its site title and browser-tab text — worth writing as a real title rather than a slug. Pages may still set title: explicitly to override; the two landing pages do.
Known state after deploy (verified live): the mechanism works everywhere, but 201 of 333 pages carry a slug-style # heading (no spaces) and so now show that slug as their title — 190 capability, 5 framework, 4 harness, 2 runtime. For capability pages this is often intentional (# /gsd-execute-phaseis the command name); for others it is just a lowercase stand-in for a proper name (# claude-code → “Claude Code”, # warren → “Warren”). The remaining 132 pages render proper prose titles (Stage: Align, GSD — Git. Ship. Done., Artifact: Atomic commit). Deliberately not mass-rewritten — H1s are content, and the identifier-vs-name call differs per namespace. Open question for a future pass.
[2026-08-11] docs | concise titles + deks on the four namespace index pages
Follow-on from the H1→title build step: the layer/index pages carried their explanatory clause inside the heading, so the site title and browser tab read as a full sentence.
Split each into a short heading plus an italic dek on the line below (the dek becomes the first body line once the build promotes the H1):
Artifacts — Index (lifecycle flow + counterpart map) → Artifacts · Index — lifecycle flow + counterpart map.
SDLC Stages — Index (execution order) → SDLC Stages · Index — the eight canonical stages, in execution order.
Harness — the agent-program layer → Harness · The agent-program layer — the loop that loads a framework’s skills and drives the model’s tool calls.
Runtime — the execution layer → Runtime · The execution layer — the harness-agnostic substrate deciding where and how agents run.
Verified by running the build transform on a copy: all four yield the concise title:, and the blank line between dek and first paragraph survives (so the dek stays its own paragraph rather than merging). No links changed — every reference to these pages is path-based, not title-based.
[2026-08-28] docs | new topic overlay — the compounding loop
Motivation: an analysis pass over the wiki for “what can assess the state of previous AI sessions, and what turns that into improvement” found the material was there but scattered across six namespaces — stage-learn, two patterns, four artifacts, ~20 capabilities, plus the runtime/harness substrate — with no page a reader could start from. The theme spans ≥3 namespaces and could not be assembled from any existing page, so it clears the topic-layer bar.
New pagewiki/topic/topic-compounding-loop.md (type: topic, no ontology edges, per CONVENTIONS §The topic layer). Structure: the four moves (harvest → externalise → re-inject → maintain, with a mermaid circuit); three tiers of evidence a tool can actually read (agent transcripts · repo artefacts left behind · persisted working context) as a coverage table; where the durable form lives (process artifacts + warren.mulch/ / gbrain / claude-code primitives); four things that compound (lessons · capabilities · standards · preferences); relation to the sibling topics; six gaps; a practice section.
Framing choice: positioned as the third of an actionable trio — topic-agent-readiness (the substrate) → topic-harness-engineering (the controls) → this page (the loop that refines the controls). It is the evidence-side reading of Fowler’s steering loop, where harness-engineering is the frame-side reading; the two pages deliberately cross-reference rather than duplicate.
Gaps recorded (candidates, not mints): (1) session mining has no pattern and no artifact — ce-session-historian is the only page in the wiki that reads agent transcripts, and it excludes the discovery/extraction half; a pattern-session-mining has 1 clear framework + a partial second (gstack-retro--global), so it is parked for the next ingest rather than minted. (2) Nothing measures whether compounding works. (3) Learn outputs are all guides, never sensors — no capability turns a harvested lesson into a test/lint rule/hook, despite harness-engineering’s own “prefer a computational control.” (4) Failed approaches are stored by gstack-context-save but harvested by nobody. (5) The human-retrospective and agent-corpus flavours never feed each other. (6) gstack-skillify’s quarantine → active after 3 uses → cross-project is the wiki’s only quantitative trust ladder and is buried in a browser-automation page.
Cascade: row added to the ## topic section of catalogue.md; the “Improving the repo the agent works in” paragraph in index.md now names three actionable topics instead of two. No stage re-derivation, no backlink cascade, no target-page edits — per the overlay rule a topic touches nothing but itself and the catalogue.
Verification: all 30 distinct [[wikilinks]] on the new page resolve to existing files; both in-page anchors match headings; H1 is the first body line with an italic dek below it, so the build-time title injection yields title: The compounding loop.
[2026-08-31] schema | disambiguate the runtime node name
Prompted by the question of whether orchestrator would be a better name for the node type. Decided no, and recorded the reasoning where the next reader will hit it rather than leaving it as a settled-in-conversation call.
Why not orchestrator: orchestration is only ~3 of the 9 dimensions the layer synthesises (isolation and persistence are not orchestration at all — warren’s .mulch/ memory least of all); a library-subtype runtime (sandcastle) is a toolkit you script orchestration with rather than an orchestrator itself, so the subtype split stops cohering; and orchestration also happens at the process layer (pattern-wave-parallelism) and in the harness (sub-agent spawning), so naming this node for it implies a monopoly the evidence does not support. Every other node type is a noun for what a thing is; orchestrator names a role three layers share.
The real smell it exposed: the section is headed The execution layer while the node is runtime — layer and node carry different names. Kept as-is (a rename would touch 216 occurrences across 29 files, 3 type: declarations, 3 runs: edge sets, 7 Enabled by (infrastructure) rosters, and the catalogue matrix, for modest gain), but the mismatch is now stated rather than latent.
Changes: a disambiguating clause on the runtime/ row of the node-types table (not a language, container, or model runtime); a new A note on the word paragraph in §The execution layer carrying the reasoning above; the same clause added to the wiki/runtime/index.md intro. No edges, no page renames, no stage re-derivation.
[2026-08-31] ingest | bernstein (runtime #3)
Source: https://bernstein.readthedocs.io/en/latest/ → raw/runtime/2026-08-31-bernstein.md. Captured from the published docs’ search index (349 pages) rather than the nav, which lists ~20 — the site is far larger than its front page suggests. Apache-2.0; PyPI bernstein 3.18.2 at capture, docs release notes through v3.6.0.
Classification check before writing: confirmed it is a runtime, not a framework or harness. It ships no SDLC methodology (its opinions are about isolation, scheduling, verification, and merge), and it is not a single agent loop — it spawns loops through 40+ CLI adapters. subtype: platform (task server + REST/OpenAPI + dashboard + TUI + CLI), the same pole as warren.
New page wiki/runtime/bernstein.md. runs: → claude-code · opencode · pi · factory-droid — the four adapters in its documented set that have pages here. Per the support-scope rule the rest of the 40+ (codex, gemini, qwen, ollama, aider, cursor, copilot, amp, goose, continue, cline, plandex, openhands, …) stay as prose until those harnesses are ingested. First paged runtime to list Droid as a provider — factory-droid’s runtime roster was previously “none documented yet”.
Three patterns gained their first-ever Enabled by (infrastructure) section, and this is the ingest’s real finding: pattern-evidence-before-claims, pattern-cross-model-review, and pattern-fresh-context-subagents existed here only as process-layer instruction — skills an agent is told to follow and can rationalize away. Bernstein makes each an enforced property of the substrate: the janitor verifies declarative completion signals and a lint/type/test/PII gate over the real diff and “does not trust agent claims—verifies them”; the review gate raises EvalGateConfigError when DifferentModelRequired cannot be satisfied and FreshContextViolation when the implementer’s transcript is threaded into the reviewer’s session. That is the same “execution layer absorbs a process-layer concern” move warren’s .mulch/ made for pattern-knowledge-compounding, but aimed at stage-validate instead of learn.
Also new to the layer: coordination as auditable code. Bernstein’s thesis is that scheduling is not a reasoning task — a pure-Python priority queue over a task DAG, “zero LLM tokens on coordination” — argued from invented dependencies, non-reproducibility, and $0.05–0.15/run of coordination tokens. Recorded with the docs’ own caveat that no controlled benchmark is published yet. This reframes pattern-wave-parallelism at the infra level: waves are declared in the plan ([P] markers, -> T### arrows) and batched topologically, not reasoned out by a planning agent.
Cascade: 8 pattern pages (new/extended infra rosters, See Also, sources:, updated:); 4 harness pages (Runs / spawned by rosters + See Also); runtime/index.md (members table, matrix widened to three columns with two new rows — Coordination logic and Verification, both dimensions the two-instance matrix could not see — plus a new weight axis note); catalogue.md## runtime; index.md count 2 → 3 runtimes.
No stage re-derivation (a runtime implements no stage). The matrix stays a matrix: three instances is still well short of warranting derived orchestration-concern nodes, though the two rows Bernstein forced open are the first sign the axis set was under-determined by two.
[2026-08-31] mint | pattern-deterministic-gates (the computational half of the sensor split)
Prompted by the question of whether the wiki had a pattern for running deterministic code checks and tests. It did not — but it had already named the idea and left it homeless.
The gap, precisely:topic-harness-engineering draws Fowler’s control split — computational (deterministic, ms–s: tests, linters, type checkers) vs inferential (LLM-as-judge). The inferential half had three minted nodes (pattern-adversarial-review 10 backlinks, pattern-cross-model-review 4, pattern-parallel-persona-review); the computational half had zero. The concept lived only as prose in a topic, which by this wiki’s own overlay rule carries no stored edges and is never evidence. That asymmetry, not the raw backlink count, is what justified the mint.
Evidence (4 frameworks + both substrate layers):gstack-health (type/lint/tests/dead-code dashboard — the purest instance), addy-ci-cd (un-skippable sequential gate pipeline, “if lint fails you fix lint, you don’t disable the rule”), lfg (watch CI until green as the loop’s terminal condition), mp-implement (continuous typecheck + tests while building), sp-verification-before-completion (its gate function is an exit-code read). Infra-side: bernstein’s named gate pipeline and sandcastle’s exec()-gating.
Name.pattern-deterministic-gates over pattern-computational-gates: plain and self-describing, consistent with pattern-edit-guardrails / pattern-evidence-before-claims, and not borrowing one author’s branding for a node the whole wiki uses. Fowler’s vocabulary stays where it belongs, on the topic page.
Boundaries drawn on the page (the three neighbours it could have been folded into, and was not):
pattern-shift-left answers when (early), this answers what kind (program-decided) — orthogonal axes; a deterministic gate can run late and an inferential one early. Shift-left keeps its single backlink; its claim is narrow, not weak.
pattern-evidence-before-claims is an honesty discipline, this is a gate. They co-occur but fail differently: the first violated yields a false statement, the second a blocked merge.
pattern-test-driven-development is one instance of a deterministic gate at the earliest point, plus a red-green ordering rule this pattern does not require.
Cascade: new pattern page; applies: on 5 capabilities (+ their See Also); enables: on bernstein and sandcastle with an Enabled by (infrastructure) roster; See Also on 6 neighbouring patterns; the computational-controls bullet in topic-harness-engineering now points at the node; runtime/index.md roster; catalogue.md; index.md 31 → 32 patterns. No stage re-derivation (a pattern mints no stage).
Deliberately not done — open question for a later pass. The harness layer also supplies this pattern: hooks run shell commands on tool events, which is exactly a program-decided check. Adding enables: [[pattern-deterministic-gates]] to the harness pages would give the page a third Provided by (harness) roster. Left unwired because the topic page files hooks under pattern-edit-guardrails as a preventive control (blocks an action up front) rather than a detective one (fails the work afterwards), and deciding whether a pre-tool hook running tsc is one, the other, or both deserves its own review rather than being settled in passing.
Near-misses excluded to keep the roster crisp: ce-work (“ship through quality gates” — too generic to evidence the mechanism), gstack-codex and the code-review cluster (inferential by construction).
Source: https://github.com/jayminwest/seeds → raw/seeds/2026-08-31-seeds.md (README + AGENTS.md + PLAN_SPEC.md + SPEC.md + the repo-local SKILL.md, verbatim). MIT; npm @os-eco/seeds-cli v0.5.15, CLI binary sd; CHANGELOG latest [0.5.15] 2026-07-17. Same author as warren, and part of the same os-eco ecosystem — the wiki’s first case of ingesting two layers of one author’s stack.
Classification was the hard call, and it is recorded on the page rather than settled quietly. Not a runtime: seeds spawns no agent and decides nothing about where one runs — warren consumes seeds, so the “a runtime spawns loops” test in CONVENTIONS holds cleanly. Not a harness: no agent loop. Filed as framework because it ships agent-invocable entrypoints that perform lifecycle work, is portable across harnesses, and carries an opinionated methodology it injects (seeds-prime) and persists (seeds-onboard). The stretch, stated plainly in a dedicated section of the page: every other framework here is a bundle of prompts; seeds is a program.
The finding this ingest actually produces. Where a prompt-based framework instructs an agent to plan before implementing, seeds withholds the work — a child seed marked requires_plan: true is excluded from seeds-ready until its sub-plan is approved — and its plan gate is an AJV schema generated from a project-declared template, not a model asked to be rigorous. That makes it the process-layer twin of bernstein: two consecutive ingests of deterministic code absorbing a concern the frameworks used to write as instruction, bernstein for stage-validate and seeds for stage-plan. pattern-plan-verification-loop went from five gates, all of them LLMs, to six with the first that cannot be argued out of its verdict — and, symmetrically, the first that is blind to everything except shape.
37 capability pages (13 issue · 13 plan · 3 template · 2 health/config · 2 agent-integration · 3 utility · 1 skill), per the full-coverage convention. Command families with no independent meaning were kept as one page each (label add|remove|list|list-all → seeds-label; block|unblock|blocked → seeds-block; config schema|show|set|unset → seeds-config). Excluded: the four .claude/commands/ in the repo (prioritize, issue-reviews, pr-reviews, release) — maintainer workflow for the seeds repo itself, not shipped in the published package (files: ["src"]).
New artifact artifact-plan-record — minted, not folded into artifact-plan-md, because the whole design argument is that they are different kinds of object: “Structured data, not prose … no markdown plan documents anywhere in the artifact path.” Three consequences the prose form cannot offer, all on the page: the plan and the work queue are one object graph (a step’s blocks index becomes a real blockedBy edge); another layer consumes it directly (warren’s plan-run walks plan.children verbatim, seq = index + 1, which is why seeds-plan-reorder exists at all); and it is re-checkable against a later template (seeds-plan-validate).
Stage coverage is the ingest’s other honest result: 🟢 Plan, 🟡 Learn, and ➖ everywhere else, with 23 of 37 capabilities off-stage — more than the other eleven frameworks’ twelve combined. Not a gap in the ingest; an issue tracker runs around the lifecycle. sdlc-stage/index.md gained the row plus a paragraph explaining why seeds is enumerated separately from the twelve utility-shaped off-stage capabilities. Read the other way, the skew is the measure of the classification: seeds is a substrate wearing a framework’s clothes, filed under framework only because one instance does not justify minting a node type. Parked: if a second work-tracking substrate arrives (beads, the tool seeds replaces, is the obvious one), revisit that with this row as the evidence.
Stage re-derivation (step 5): no change to the eight-stage set. No name here is framework-specific; nothing merges; nothing new clears the ≥2-framework bar. Two considerations were run and declined: a stage-track (list/ready/update/stats) — declined, tracking is off-stage by the wiki’s own definition and only bmad-sprint-planning comes close as a second instance; and a stage-schedule, which is now parked as a split candidate on stage-plan with its tally — seeds separates ordering from decomposition into distinct commands (seeds-plan-create / seeds-plan-adopt / seeds-plan-reorder), but the only corroborating evidence is in the execution layer (warren, bernstein), which implements no stage, so it stands at one framework. aka: updated on stage-plan and stage-learn.
No new pattern minted, deliberately. One candidate was considered and left unminted: plan-as-validated-data (a machine-checkable, mechanically-traversable plan rather than a document) — evidence is seeds plus bernstein’s [P]/-> T### plan markers, i.e. one framework and one runtime. Well short of the bar pattern-deterministic-gates cleared (4 frameworks + both substrate layers). Recorded here as the review queue entry; the idea currently lives as artifact-plan-record, which is the right home for it while it is a property of one artifact rather than a technique many capabilities apply.
runs_on: → claude-code · factory-droid · pi. Seeds names no supported-agents list — it is a CLI, so what it supports is a memory-file convention. The three edges are evidenced by integration directories the repo actually ships (.claude/commands/, .factory/skills/, .pi/). Per the support-scope rule, sd onboard writing AGENTS.md is recorded as prose on opencode rather than as a stored edge: seeds names the convention, not the harness.
[2026-08-31] schema | new node type store — the state layer (4th layer)
Prompted by the beads ingest below, and by the explicit question of whether “issue tracker” is a distinct category for long-running agent work. Answer: yes, and wider than issue tracking — the category is durable agent state, of which a work graph is one shape and a memory corpus another.
The argument, in one line: framework, harness, and runtime are all compute — instructions, the loop, and where the loop runs, each transient per run. A store is state: the only layer that survives the run. That is the sentence the layer was missing, and the reason .mulch/ had been filed as a warrenfeature rather than as an instance of anything.
The sources drew the boundary, not the wiki.beads’ engdocs/PROJECT_CHARTER.md names the layer above it and refuses to encode it — “systems such as schedulers, swarms, release coordinators […] may use beads, but beads should not encode their concepts in core. The orchestration layer owns orchestration policy: agent routing, task assignment strategy, model choice, retry plans, scheduling, workflow semantics” — which is a description of this wiki’s runtime written by someone who had never seen this wiki. The same charter scopes beads to “issue tracking primitives”, ruling out framework. It hosts no agent loop, ruling out harness. Two independent tools, both programs, both harness- and framework-agnostic, both performing no stage while holding the state that lets work outlive a session.
Why store and not tracker. Naming it for issue tracking would have needed widening on the next ingest: beads ships bd remember / bd recall / bd kv (memories injected into every session by bd prime) and semantic compaction; warren bundles mulch (expertise) and canopy (prompts). Those are the same kind of thing — durable state an agent reads back — differing in what they hold, which is what subtype: work | memory records. Both paged instances are work; memory is declared and unpaged.
Edges. A store mirrors a runtime: two forward edges, integrates_with: → harness[] (new) and enables: → pattern[] (domain widened). It is also a target, unlike a runtime — it ships a command surface, so belongs_to:’s range widened to framework | store. pattern now carries four backlink rosters: Applied by (capabilities) · Enabled by (infrastructure) (runtimes) · Provided by (harness) · Persisted by (store). Ontology is now eight node types, eleven edges.
Why integrates_with: rather than reusing runs_on:. The relationship is genuinely different. A framework runs_on: a harness because its skills are written in that harness’s format; a store integrates because it must get itself mentioned — an agent that does not know the tracker exists writes a markdown TODO list instead, which is the failure both stores were built against. What a store ships is an installer that writes into the harness’s memory file and hooks. The support-scope rule carries over unchanged.
CONVENTIONS.md rewritten accordingly: intro (three layers → four, plus the compute/state line), the ontology-at-a-glance prose and mermaid, the node-types table, a store subtypes block, a store frontmatter example, three rows of the relationship vocabulary, the derived-edges list, the naming table, a new §The state layer (stores) with the classification tests and the ingest procedure, and a new step 0 on the ingest checklist — decide the layer first — citing seeds’ same-day re-file as the cautionary case.
Deliberately not done: no derived-node namespace for the state concerns. Two instances is far short; the 24 shared dimensions live as a matrix in store/index.md, the same discipline parked for the runtime and harness dimensions. Also not done: minting memory-subtype pages for mulch or canopy — they are named as candidates, not ingested.
[2026-08-31] refile | seeds: framework → store
Predicted and triggered exactly as the earlier seeds entry said it would be: “if a second work-tracking substrate arrives (beads, the tool seeds replaces, is the obvious one), revisit that with this row as the evidence.” Beads arrived the same day.
All 37 capability pages survived unchanged — belongs_to: "[[seeds]]" still resolves, and the range widening is what made that free. That was the deciding factor in choosing this option over collapsing them into prose.
Page rewrites: the framework-justification section became §Why this page moved (recording the original reasoning and what changed), and “Why almost everything is off-stage” became §Stage coverage — the 23/37 skew is now the expected shape for the layer rather than an anomaly to explain away. What remains notable is inverted: seeds is the store that reaches up into the process layer, which beads’ charter explicitly forbids. That contrast is now the interesting fact rather than an awkward one.
Cascade: sdlc-stage/index.md lost the seeds framework row and gained a §Stores on the stage map addendum (with the rule that store evidence is weaker evidence for a stage than a framework’s, and that a candidate stage evidenced only by stores has not cleared the bar); the Seeds: groups on stage-plan / stage-learn are relabelled as store evidence; four harness pages moved seeds from their runs_on: roster to a new Stores that integrates_with: it bullet (Claude Code back to all twelve frameworks); harness/index.md lost the seeds row from the framework-support matrix and gained a §Store support matrix; catalogue.md lost the seeds framework row and gained a ## store section; index.md 13 → 12 frameworks.
[2026-08-31] ingest | beads (store #1, and the reason the layer exists)
Source: https://github.com/gastownhall/beads → raw/beads/2026-08-31-beads.md (13k lines: README, the full docs/core-concepts · docs/workflows · docs/multi-agent · docs/architecture sets, engdocs/PROJECT_CHARTER.md, and the complete 6,884-line docs/CLI_REFERENCE.md). Origin author Steve Yegge (steveyegge/beads, still the Go module path), now published under gastownhall. MIT, Go 1.26+, Cobra, ~109 top-level commands. Homebrew · npm @beads/bd · PyPI beads-mcp · AUR · winget. Repo-development docs (AGENT_INSTRUCTIONS.md, engdocs/TESTING.md, PR/release policy) deliberately omitted as internal to maintaining beads rather than using it.
Granularity: 51 capability pages grouped by command family, covering all ~109 commands — bd mol’s thirteen subcommands as one page, bd dolt’s twelve as another. Per-command coverage would have produced ~109 pages, a meaningful fraction of them about database plumbing (bd dolt killall, bd metrics off, bd completion).
One on-stage capability out of 51, and that is the charter working as intended: beads-mol implements stage-plan because pouring a formula produces dependency-ordered work, and even that is template instantiation rather than reasoning. Everything else is off-stage store surface.
The three ideas worth stealing (all new to the wiki):
Coordination as work items.beads-gate turns an async wait — a human sign-off, a timer, a gh:run, a gh:pr — into a bead that blocks its waiters, so the step leaves the ready frontier and “agents never need to poll or spin.”beads-merge-slot does mutual exclusion the same way. A passive store coordinates active agents without becoming an orchestrator, which is the charter drawn in one mechanism. Compare warren (the runtime holds the loop open) and lfg (the agent burns turns watching CI).
Ephemerality as a data property. The formula → proto → molecule / wisp pipeline distinguishes work worth keeping from work worth forgetting at the storage level — wisps are excluded from federation, purged in bulk, promotable by bd mol squash, irreversibly droppable by bd mol burn. Every other tool’s store grows forever. With semantic compaction (beads-compact) this is the only tool here that treats “a store that never forgets eventually costs more context than it saves” as a first-class problem.
An audit log that doubles as a training set.beads-audit appends llm_call / tool_call entries with prompts, responses, exit codes, and issue ids, labelled good/bad, for “auditing”and“dataset generation (SFT/RL fine-tuning)”. Nothing else in the wiki aims pattern-knowledge-compounding at model weights rather than at context.
Runner-up: beads-human makes “this needs a person” a durable, answerable, countable bead (bd human stats is a queue depth on the human bottleneck) instead of a question that scrolls past with the session. Asynchronous HITL, versus warren’s real-time steer.
The storage disagreement is recorded on both pages and adjudicated on neither.seeds’ README argues against beads by name — the binary DB that “can’t diff/merge”, “286 export-state tracking files”, lock contention, a “dual source of truth”. Beads’ current docs answer parts of it on their own terms (.beads/issues.jsonl is explicitly demoted to “a passive export […] not the database, not the sync protocol, and not a backup”) and its charter argues the Dolt dependency is the point. Two honest caveats written onto the pages: the critique may predate what it criticizes (same-dated captures, not contemporaneous arguments), and the disagreement is nonetheless real on its merits — a versioned SQL engine buys typed queries, cell-level merge, and branchable work data (beads-vc) at the cost of schema migrations, a version guard, a designated-clone upgrade protocol, and server-process ops (beads-migrate, beads-dolt) that JSONL does not have.
integrates_with: → claude-code · factory-droid · opencode — three of the thirteen bd setup recipes that have pages here; the rest (cursor, copilot, gemini, aider, mux, junie, windsurf, cody, kilocode, codex) stay prose. pi is the one paged harness beads does not name, which is the inverse of seeds’ gap at opencode.
No stage re-derivation change. The eight-stage set is untouched. The parked stage-schedule candidate on stage-plan was re-read against beads and strengthened but still not cleared: beads expresses scheduling constraints as data (gates, merge slots) as seeds expresses ordering as data (adopt-only plans, reorder), but both are stores, and store evidence is weaker evidence for a stage — the decisive trigger is now explicitly a framework that orders work it did not decompose. The tally and the reasoning are on the stage page.
No new artifact and no new pattern minted. A bead maps to artifact-issue (with a note that in this layer the issue is the atom rather than a plan’s output) and bd setup to artifact-standards. Beads’ formula/proto/molecule pipeline was considered for its own artifact page and left as prose on the store page: it is a generalization of artifact-plan-record (a reusable template rather than one validated plan), and one instance does not warrant a node — noted as the review-queue entry if a second templated-workflow store appears.
Cascade: 11 pattern pages (Applied by groups) of which 7 also gained Persisted by (store); artifact-issue and artifact-standards; stage-plan (a Beads group + the equivalence sentence + the split candidate) and stage-learn; sdlc-stage/index.md; 4 harness pages + harness/index.md’s new store matrix; warren (mulch and canopy re-read as stores), runtime/index.md, bernstein (its own .sdd/ as the instructive counter-example — an orchestrator that owns its state gets integration but a store nothing else can read); topic-harness-engineering (beads-rules as the one mechanical guide-layer maintainer in the wiki); catalogue.md (51 capability rows + the ## store section); index.md (four layers, counts 267 → 318 capabilities, +2 stores).
[2026-08-31] ingest | sssf — Super Simple Software Factory (runtime #4, the minimal pole)
Source: https://github.com/disler/super-simple-software-factory @ de31374 (2026-08-02, MIT, IndyDevDan) → raw/runtime/2026-08-31-super-simple-software-factory.md (7.3k lines: the README plus the entire .claude/skills/sssf/ product — SKILL.md, all 9 cookbooks, all 3 references, the 3 generator scripts, the config/justfile/env templates, all 12 ADW scripts, all 16 adw_modules/, all 10 role prompts, both pi extensions). Omitted as inessential to what the system is: the Vue/Vite visualizer app source (~30 UI files), the images/ SVGs, lockfiles, and the example branch (the same skill already stamped into a demo repo).
Layer call: runtime, subtype: library — the closest call in the namespace so far, and the reasoning is on the page under §Why this is a runtime and not a framework. Three things point at framework: a five-agent roster (planner · builder · scout · reviewer · documenter), a set of role prompts, and an adw_simple_sdlc chain that walks plan → build → test → review → document. Three tests overrule them: it hosts no agent loop and spawns the one that does (agent_pi.py launches pi as a subprocess and tails its stdout); the process content is declared disposable by the author while the control plane is not (“The tests it ships are not your tests. The prompts it ships describe a demo app… All of that is supposed to be replaced”); and the pitch is a relocation of the execution layer’s own concerns — “moving the control plane out of the prompt and into Python.” Step 0’s tell agrees from the other side: the stamped surface is run.phase() / ph.call() / gates.* / permissions.*, none of which perform a lifecycle step.
runs: → pi only, and this is the layer’s first non-agnostic member. coding_agent: claude_code is schema-valid and agent_cc.py raises NotImplementedError until v2, so a second edge would be an over-claim. runtime/index.md gained a paragraph recording the tension with the layer’s harness-agnostic definition rather than smoothing it: agnosticism here is a property of the interface (one agent_*.py per harness behind one call site) and total at the model layer (any provider/model-id, chosen per phase, in one run).
The inverse-of-an-edge worth recording: sssf is a runtime delivered as a Claude Code skill. /sssf install stamps it, and claude-code then plays operator — launch an ADW, read the trace db, retune the roster — while pi is the harness the runtime actually spawns. So Claude Code sits above this runtime rather than being spawned by it, and gets a prose bullet on its page explicitly marked as not a runs: edge. First case in the wiki of a harness hosting a runtime’s operator rather than its worker.
enables: → 7 patterns, two of them the execution layer’s first supply of that pattern:
pattern-contract-first (new to the layer) — a typed Pydantic envelope is the interface at every seam, re-prompted until it validates; the contract is a synced triad (type ↔ ## Report example ↔ call site) that must change as one edit. Contract-first applied to agent-to-agent handoff rather than to an API.
pattern-edit-guardrails (new to the layer) — and a genuinely different shape of the pattern: detect-and-revert rather than prevent. The argument is that a tool allowlist can never be a boundary while bash can run git checkout, so writes:/protected_files: are enforced by fingerprinting the working tree before and after each call. Change-set comparison over write-watching is deliberate — “a reversion is a modification” — and pre-existing dirty paths are left alone so an operator’s uncommitted work is never discarded. It exists because pi ships no permission surface, which is the cleanest example in the wiki of a harness gap being closed one layer up.
The trace as the thing the design is derived from. The phase exists to be the unit of the trace; description is mandatory and rejected when blank or tautological because it is the only intent the trace shows; a code step is never nested in an agent step so the trace can distinguish them; the whole transport is one rowid-cursor query so live and historical views cannot diverge. The sharpest artifact is the run.finish() docstring, which records that a succeededproperty with side effects had been writing the session green in the db, the terminal, and the UI while the process exited 1 — “Anyone reading the trace saw success; only a CI job checking $? saw the truth.”warren gives a live view and bernstein a signed audit chain; this is the first runtime whose design is back-derived from what the trace must be able to say.
Correction, not restart. A failed envelope parse or gate violation re-prompts the same live session with a correction naming what was wrong, bounded by JSON_FIX_ATTEMPTS and the phase’s retries. Free because pi’s --session-id is create-or-continue, so running an agent and continuing it are one call. “A cold restart throws away everything the agent learned. A correction costs one message.”
A budget line between agent work and code work.“A known command is code, not an agent” as a hard rule, with no tester agent in the roster as its structural consequence, and as_envelope() adapters so a deterministic result reaches the next agent through the agent-shaped door — one repair loop for both. Recorded on topic-harness-engineering as the wiki’s clearest independent statement of Fowler’s prefer-a-computational-control rule, reached from the bill rather than from control theory.
No new pattern minted, and one candidate declined: acceptance-separate-from-completion (run.finish(accepted=…) asking “did every phase pass” and “is the run acceptable” as two questions, because “a test phase that ran a red suite did its job perfectly”). Evidence is one runtime; it lives as prose on the page and in pattern-autonomous-loop’s infra roster, which is the right home while it is a property of one loop shape rather than a technique many capabilities apply. Review-queue entry if a second runtime separates the two.
No new artifact and no stage re-derivation. The eight-stage set is untouched — a runtime implements no stage. The parked stage-schedule candidate on stage-plan was re-read against sssf and is unmoved: an ADW script orders work, but it is an execution substrate, and the decisive trigger stays a framework that orders work it did not decompose.
pattern-cross-model-review deliberately not claimed, though the starter roster puts the reviewer on OpenAI while the builder runs Gemini. That is a property of one roster, not an enforced precondition, and there is one reviewer rather than two verdicts to compare — bernstein’s DifferentModelRequired is what enforcement looks like. Recorded as prose on both the sssf page and in the roster section.
The honest edges are the author’s own, and are quoted rather than discovered: no sandbox, no branch per run, no merge step, no PR flow, no HITL approval phase, no parallelism, no cross-run memory, pi-only — and the shipped quality blocks are placeholder echos that exit 0, “a wrong-but-plausible command that silently passes is worse than one that says so out loud.” sssf is therefore the layer’s clearest evidence that these concerns are separable: the only matrix row filled by all four runtimes is verification.
Cascade: 7 pattern pages gained sssf entries (2 of them a brand-new Enabled by (infrastructure) section: pattern-contract-first, pattern-edit-guardrails; pattern-context-engineering gained its first infra section too); pi (a runs: backlink plus a paragraph on the three pi properties sssf leans on — create-or-continue sessions, tailable JSONL stdout, per-agent -e extensions — and the one place a minimal harness costs it); claude-code (the not-an-edge operator note); runtime/index.md (members row, a 5th matrix column, the membership caveat, three rewritten axis paragraphs — the library pole now has two occupants dividing sandbox-vs-workflow — and 5 pattern-roster lines); topic-harness-engineering (the computational-control rule, the preventive-vs-detective caveat on guardrails, 2 map rows); catalogue.md (runtime row); index.md 3 → 4 execution runtimes.
New topic page wiki/topic/topic-software-factory.md, grounded in two raw sources: the existing sssf capture (raw/runtime/2026-08-31-super-simple-software-factory.md, whose README supplies the generic definition — “a system of agents plus code that runs without you”) and a new reference capture, raw/reference/2026-09-01-awesome-loop-engineering.md (ChaoYue’s Awesome Loop Engineering: working definition, Loop Contract, design checklist, 0–6 maturity model, full TAXONOMY.md verbatim; the 989-resource link atlas deliberately not mirrored — curation, not vocabulary).
Topic gate check: spans runtime + pattern + harness + store + topic namespaces, and no existing page could carry it — runtime/index.md is bound by the anti-premature-abstraction rule to stay navigational-plus-matrix, so the cross-layer synthesis (anatomy, axes, profiles, glossary) needed the overlay. “Software factory” was minted as the page’s frame despite currently being one tool’s proper name, on the strength of the author’s own generic definition; the page opens by making that generalization explicit rather than smuggling it.
The model: four axes, not a ladder. Control-plane location (prompt vs code) · trigger model (manual/scheduled/event/goal — values adopted from the loop-engineering taxonomy) · isolation substrate (inline/worktree/sandbox/fleet) · autonomy scope (bounded task/queue/scan/reactive — intake values likewise adopted). A morphological grid (markdown table — mermaid can’t draw one worth reading) marks three runtime-anchored profiles as the recommended progressive configurations: 🎫 ticket runner (sssf) → 🖥️ monitored service (warren) → 🏭 fleet factory (bernstein), with the explicit caveat that the axes move independently and the progression is a common path, not an ordering claim. sandcastle deliberately holds no profile — the embeddable substrate is a distribution fact, not a shape. The grid’s honest hole is recorded: the reactive autonomy cell has no ingested anchor (gh-aw is the external instance).
Two mermaid diagrams: the four-layer stack with the single pattern seam, and the factory anatomy (trigger → control plane → worker-in-isolation → gates → merge, store beside, human dotted in via steering/escalation) — each component wired to the pattern page that names it. The index links to these rather than copying them.
The glossary the layer lacked. Seventeen entries, including the canonical control plane definition (“owns sequencing, retries, and acceptance; its defining question is location — prompt or code”) — a term previously used on 4+ pages and defined on none. warren, bernstein, and sssf now link their first load-bearing “control plane” mention to it (an inline definitional pointer, not a “referenced by topic” roster). ADW is glossed as sssf’s term for the generic workflow-script concept; loop contract, intake, exit condition, budget, escalation, maker/checker enter via the new capture.
Three level-shaped frames, deliberately not merged: agent-readiness scores the repo, the loop maturity model scores one recurring workflow’s controls, the profiles describe the factory’s execution shape. One paragraph relates them; topic-agent-readiness is untouched (its ladder is externally grounded and grafting wiki-native profiles onto it would blur provenance).
runtime/index.md restructured to match: new §The concepts pointer up top, Members and pattern roster promoted, the 11-concern matrix demoted to §Reference (retitled, analytic prose kept with it), §The broader category updated — Vibe-Kanban marked sunset (Bloop shut down 2026-04), and two ingest-queued candidates added with their quadrants: GitHub Agentic Workflows (gh-aw) (event-driven, control plane compiled into CI — the grid’s empty cell) and the OpenHands software-agent SDK (open-source remote-fleet). Grove considered as a level-1 example and excluded — internal tool, no public references, and the provenance rule bars un-ingestable anchors.
Cascade (topic-standard, minimal): catalogue.md gained the topic row and a ## runtime index row (fixing an inconsistency — ## store listed its index, ## runtime didn’t); index.md §Picking the substrate now routes to the topic page before the matrix. No ontology edges, no stage re-derivation, no pattern-page changes — the overlay touches nothing but itself, the catalogue, and three definitional inline links.
Source: github/gh-aw (MIT, v0.87.10 2026-08-31, technical preview per the 2026-02-13 GitHub blog announcement by Don Syme & Peli de Halleux) → raw/runtime/2026-09-01-gh-aw.md (13 pages mirrored: README, announcement, overview, architecture/security model, engines, triggers, frontmatter reference, tools/MCP, safe outputs, concurrency, cache-memory, CLI surface, llms.txt index noted). Deliberately omitted: the workflow gallery, workshop content, per-toolset MCP listings, and the ~73-page agent-prompt corpus. Ingested on the software-factory synthesis’s queue — the candidate that filled the grid’s one empty cell; OpenHands, the other queued candidate, deprioritized by the operator as closer to the hosted IDE-agent systems.
Layer call: runtime, subtype: platform — with a recorded caveat instead of a clean fit. It spawns agent loops (five engines auto-installed on Actions runners) and performs no lifecycle stage, so the layer is unambiguous. The subtype is not: there is no server — the product is a gh CLI extension whose compiler emits hardened .lock.yml Actions workflows, and the platform doing the running is GitHub Actions itself. Filed platform because the operator experience is platform-shaped (gh aw deploy org rollout, health dashboards, nothing to import), noted on the page as “a compiler onto someone else’s platform.”
runs: → claude-code + pi — two of the five official engines (copilot default · claude · codex · gemini · pi) have pages; the other three stay prose per the support-scope corollary. The repo’s OpenCode/Aider/Cursor samples are “not officially supported” — no edge for opencode despite its page existing.
enables: → 5 patterns, one of them a new shape:
pattern-edit-guardrails — the third shape in the wiki after the harness’s preventive hooks and sssf’s detect-and-revert: structural prevention. “The agent never requires write permissions because all write operations are performed by separate, validated jobs with minimal scoped permissions” — the boundary is the compiled job topology, so there is nothing to intercept and nothing to revert. The pattern page now names the three shapes and their non-interchangeability (structural is the strongest claim, narrowest scope — it governs writes to GitHub, not the runner’s filesystem).
pattern-deterministic-gates — gates at two unusual timeline points: compile time (gh aw compile refuses an unsafe lock file — actionlint/zizmor/poutine, SHA pinning, expression allowlisting) and post-agent/pre-write (an isolated threat-detection verdict blocks every safe-output job). Honest scope note recorded on both pages: these gate safety, not work quality — correctness is delegated to the PR’s own CI, which makes gh-aw the boundary case of the layer’s “verification is the most-agreed claim” finding (claim kept, nuance added).
pattern-autonomous-loop — the event-driven end of the infra roster: triggers are the repo’s own event stream plus cron and fuzzy schedules (“daily around 14:00”, deliberately scattered), bounds declared as frontmatter data (max-turns 500, AI-credit budgets per-run and daily, cooldown, user-rate-limit, stop-after: "+7d" — a loop that disables its own trigger).
pattern-worktree-isolation — ephemeral Actions runner hardened by the Agent Workflow Firewall (Squid-proxy domain allowlist, gVisor/KVM-microVM options); the distinctive addition is egress isolation — others bound what the agent may write, the firewall bounds what it may reach.
pattern-knowledge-compounding — cache-memory (Actions cache, 10GB, ~7d) and repo-memory (git branches, versioned), with integrity-scoped keys: a merged-trust run never restores memory written under unapproved content — the first runtime to treat accumulated memory as a prompt-injection surface.
The ideas worth stealing: (1) the control plane compiled, not run — governance enforced by artifacts reviewable before any trigger fires, the wiki’s clearest instance of moving left of execution entirely; (2) write authority as job topology — least privilege expressed structurally rather than checked procedurally; (3) globally one agent job per engine across all workflows, queued not dropped — fleet throttling as a concurrency group; (4) integrity filtering — content access tiered by author trust (merged/approved/unapproved/none), flowing through to cache keys.
topic-software-factory updated as its own caveat demanded: the reactive cell gained its marker — a fourth profile, 📡 repo reactor, explicitly beside the 🎫→🖥️→🏭 adoption path rather than on it (it automates a different kind of work — the announcement’s six “continuous” categories — and runs alongside whichever profile does feature work). Glossary gained safe outputs; the control-plane entry gained the compiled-into-CI clause; the anatomy’s unanimity claim widened to five with the safety-vs-quality nuance.
Prose-only mentions, no edges: the AWF firewall and MCP Gateway companion projects; the security-retired version range (GHSA-8h78-hpm7-29gg) left in the raw capture; pull_request_target fork trust and stacked-PR max-stack left to the capture.
Cascade: 5 pattern pages gained gh-aw infra entries (pattern-edit-guardrails rewrote its shape note to a three-way split); claude-code + pi backlink rosters; runtime/index.md (members row, 5th matrix column, the responsibility paragraph gained “gh-aw owns authorization”, the separability paragraph widened to five, broader-category rewritten — gh-aw removed from the queue, OpenHands kept prose-only and deprioritized); topic-software-factory (grid, profile, glossary, diagrams’ member list, See Also); catalogue.md (runtime row + index-row and topic-row refreshes); index.md 4 → 5 execution runtimes. No stage re-derivation (a runtime implements no stage); no new pattern minted — the structural-guardrail shape strengthens an existing page rather than warranting a node, and the orchestration-concern matrix still scales at five columns.
Source: Louis Claxton (Anthropic Applied AI), The AI-Native SDLC playbook, claude.com blog, published 2026-08-21 → raw/reference/2026-08-21-ai-native-sdlc-playbook.md (full article: thesis, six-stage shift table, all plays with prerequisites/steps/governance/metrics, the intent.md / plan.md / CLAUDE.md / SKILL.md / REVIEW.md / bands.yaml / managed-settings examples, resources list). WebFetch’s summarizer balked at full-text extraction; captured via direct HTML pull instead.
Layer call: topic overlay, not a framework — the CONVENTIONS §0 test: it ships prose and templates, not an installable capability set, and its mechanisms (plan mode, hooks, skills, subagents, managed settings) are already paged as claude-code harness primitives. The page records the re-ingest trigger: if the plays ship as an installable plugin, that’s a framework ingest with runs_on: [[claude-code]].
Topic gate check: spans sdlc-stage + pattern + artifact + harness + topic namespaces, and no existing page could carry it — the org-level governance frame (artifact chain as audit trail, source-of-truth rule for legacy coexistence, separation-of-duties at every gate) has no other home.
The genuinely new instrument: continuous evals of the agent’s configuration — 20–50 real tasks re-run in CI on any change to CLAUDE.md/skills/hooks, pass-rate enforced as a merge check. No community framework in the wiki ships this; flagged on the page as the QA gate rebuilt for what now varies.
The artifact chain (intent.md → spec.md → plan.md → diff → PR → incident → next intent.md) mapped to existing artifact pages (artifact-product-brief/artifact-prd ≈ intent.md, artifact-spec-md, artifact-plan-md, artifact-pull-request, artifact-review-report ≈ REVIEW.md findings). No artifact node minted — intent.md is one org’s name for the proto-spec the brief/PRD pages already cover; review-queue it if a second source names intent-as-artifact distinctly.
Stage 6 read against topic-software-factory: the bands.yaml tiered-autonomy config (log at 1σ / diagnose read-only at 2σ / act-via-PR-gate at 3σ, detection deterministic, no model in the loop) is the factory anatomy — trigger, code-owned control plane, sandboxed stateless worker, gates, escalation — arrived at from the compliance side; the between-stage confidence gates are the glossary’s maker/checker rule applied between lifecycle stages.
Cascade (topic-standard, minimal per the overlay rule): catalogue.md topic row; index.md gained a §Rolling this out across an organization pointer. No ontology edges, no stage re-derivation, no pattern-page changes.
[2026-09-11] ingest | pstack — the anti-spec pole, and rigor as the precondition for parallelism
Source: Lauren Tan (poteto — React core team, Cursor), pstack v0.15.2, github.com/cursor/plugins/tree/main/pstack, MIT → raw/pstack/2026-09-11-pstack-plugin.md (plugin.json manifest, full README, the poteto-mode SKILL.md verbatim, generated frontmatter catalogue of all 48 skills and agents including the benny pack, benny README, full file tree). Fetched by sparse-checkout of the cursor/plugins monorepo.
Layer call: framework — CONVENTIONS §0. It ships an opinionated methodology across the lifecycle (align → learn) as an installable capability set, not an agent loop, not something that spawns loops, not durable state. Stage coverage confirms it: six of eight stages carry real capabilities.
52 capability pages, full coverage per the standing preference: 25 skills, 23 principle skills (pstack-principle-*), 2 subagents, 3 benny automation skills. The 23 playbooks are documented on pstack-poteto-mode rather than paged individually — they are steps copied into a todo list, not invocable units, so they fail the “unit of work a framework exposes” test.
Three new patterns minted.pattern-candidate-grafting (run N attempts at one artifact, pick a base, then harvest the losers — the variant of pattern-throwaway-prototype that does not discard, and distinct from pattern-cross-model-review in that each model produces a whole artifact); pattern-tooling-leverage (build the lever, and specifically the tool is the artifact a reviewer can rerun — the constructive complement of pattern-evidence-before-claims); pattern-idempotent-operations (ordinary ops discipline that earns a node here because agent runs are interrupted constantly, making it the precondition for pattern-autonomous-loop and pattern-session-handoff). Each is single-framework for now, which the pattern layer allows — the ≥2-framework bar governs stages, not patterns — and each is cross-linked from the neighbours it is easily confused with.
One new artifact: artifact-decision-log. The append-only TSV trail from pstack-show-me-your-work. Minted because its reader is new: every other durable artifact here is read by the next agent (artifact-handoff-doc, the store layer) or by future work (artifact-retrospective, artifact-solution-doc); this one is read by a human who was not watching, so they can locate the point where trust should stop. Evidence is a pointer never prose, rows are append-only, and the trail is committed only when it has a reader.
The framework’s distinctive contribution is a position, not a mechanism: it is the anti-spec pole.“why are there no planning skills? … i don’t believe in planning. the best spec is code.” It ships no stage-specify capability and no spec artifact — the first framework here to omit the stage on stated principle rather than by omission — and no stage-release beyond opening a PR. All of its rigor sits downstream: graded evidence, multi-model review, generated verification harnesses. index.md gained a §Deciding how much process you actually want framing this as the wiki’s sharpest live disagreement (Spec Kit / OpenSpec vs pstack on where in the lifecycle rigor belongs).
Second position worth recording: model diversity instead of persona diversity.pstack-interrogate states it outright — “the adversarial signal comes from model diversity, not assigned personas” — a direct rejection of pattern-parallel-persona-review as practiced by gstack, bmad, and addy-agent-skills. It makes pstack the purest pattern-cross-model-review instance (the whole panel is cross-vendor by construction, where gstack-codex gets one second opinion), and the framework is multi-model by construction: pstack-setup-pstack exists solely to map roles to models, and panel list length sets subagent count. pattern-persona-agents gained a note recording the counter-position, since pstack uses a costume exactly once (pstack-comment-sicko).
The router inversion.pstack-poteto-mode is a sticky mode (mode: true + a re-injected reminder) and every leaf skill is disable-model-invocation: true — the exact inverse of superpowers, which makes every leaf auto-trigger from a bootstrap. Two router designs solving the same problem (keeping discipline on across turns) from opposite ends; recorded on both framework pages.
Ideas worth stealing, flagged on their pages: (1) the five-rung evidence ladder with a mandatory “say where it stopped” and unproven below rung 4 (pstack-blast-radius) — the most operational form of pattern-evidence-before-claims here; (2) structural enforcement as a growth gate — pstack-reflect demotes any accepted learning a lint rule would enforce better, a built-in brake on the prose accretion every skill library drifts into; (3) the organizational record as a research corpus — pstack-why discovers MCPs at run time and fans one investigator across seven evidence categories with a null-result-is-a-finding rule; (4) suspension paged as its own procedure (Pause safely as the complement of Session pickup) — a first here; (5) a comment treated as a bug report against the code, with MUST KILL on the guilty symbol and an encoding offer before deletion (pstack-comment-sicko → pstack-no-comments); (6) autonomy decoupled from authority — benny is fully unattended and still ends at a bounded draft PR.
⚠ Harness gap: Cursor has no page, so runs_on: is empty. pstack is the wiki’s first Cursor-native rather than cross-harness framework and the first framework with an empty runs_on:. Per the support-scope corollary the edge is not pointed at a non-existent target; the support is recorded in prose in a §Harness gap section on pstack, which also inventories the harness evidence the source carries for a future cursor ingest (plugin manifests, mode:/paths:/disable-model-invocation skill frontmatter, .mdc always-applied rules, the Task surface with per-call model/readonly/environment: cloud/cloud_base_branch, MCP discovery, webhook routines, plan mode, /loop, on-disk transcripts). This is the open item from this ingest: ingesting cursor as a harness (subtype ide) would close it and let the edge be wired. Two sibling Cursor plugins are named prose-only and not ingested: cursor-team-kit (/deslop, control-cli, control-ui) and Cursor’s built-in /create-skill and /babysit.
Stage re-derivation: no changes. All six stages pstack touches were already well-evidenced, and it adds no activity an existing stage fails to cover. Checked against the parked split candidates and none moved: pstack has no stage-specify evidence at all (so the design/specify candidates are untouched), no deploy or operate step (so stage-operate gains nothing), and no governing-principles gate (its 23 principles bind by a citation requirement rather than by blocking, so the stage-govern candidate on stage-align is unaffected — noted on pattern-project-constitution instead). aka: updated on all six.
Cascade: 6 stage pages gained pstack rosters (aka: + sources: + backlinks); 22 pattern pages gained Applied by entries and 8 gained See Also links to the new patterns; 11 artifact pages gained Produced by entries; 5 framework pages gained See Also cross-refs (superpowers the structural cousin, gstack the persona counterpole, matt-pocock-skills the shared Ousterhout vocabulary, compound-engineering the loop counterpart, speckit the spec counterpole); catalogue.md (1 framework + 52 capability + 1 artifact + 3 pattern rows, and 23 touched rows re-dated and annotated); index.md counts 12→13 frameworks / 318→370 capabilities / 37→38 artifacts / 32→35 patterns, plus the new §Deciding how much process you actually want. Zero dangling wikilinks after the pass.
[2026-09-12] schema | New node type: registry — the supply layer
The wiki’s first new ontology node since store (2026-08-31), and its ninth namespace. Minted on one paged instance because the category is unambiguous even where coverage is not: JFrog (the canonical package-registry incumbent, private/signed/scanned, claiming the AgentSkills format and the OpenClaw registry protocol), Google Cloud Skill Registry (a hyperscaler, inside Gemini Enterprise), ClawHub (community, vector search — the index pole), and Agensi (marketplace with a creator revenue split) are all unpaged and queued on registry/index.md. An incumbent plus a hyperscaler plus an emerging open format is what separates a category from a product; store was minted on two instances, so one plus a documented queue clears the historical bar.
The layer test. A registry fails all eight existing types. It ships no methodology (not framework), is not an agent loop (not harness), does not spawn loops (not runtime). The near-miss is store, and how it misses is the definition: a store holds state about work the agent did and is read back after a run; a registry holds capabilities and provisions the agent before one. Opposite sides of the session. Recorded on both index pages as the pair that completes the wiki’s account of what persists between runs — the work, and the tools.
Why it earns a node rather than staying a matrix row: the concern was already homeless in three places. Distribution is a dimension on both the harness and runtime matrices; every framework page carries a free-text install line; and speckit’s page flagged its packaging ecosystem as “a distribution/customization layer no other framework here ships” with nowhere to put the observation. The new distributes: edge is designed to absorb those install lines — it is empty on this ingest and fills in when a paged framework turns out to be published to a paged registry, exactly as runs_on: trails documented support.
Schema surgery (CONVENTIONS.md): node count 8 → 9, edges 11 → 12. New node registry with subtype: index | platform (how much of the supply chain it owns — public-vs-private is a matrix dimension, not a subtype, since the platforms are generally both at once, the same move the store layer made with storage substrate). One new edge, distributes: → framework | capability, the only substrate edge pointing back into the process layer. Two widenings: belongs_to: gains a third range (framework | store | registry) and integrates_with: gains a second domain (store or registry). enables: gains a fourth domain, so pattern pages now carry five backlink rosters — Applied by / Enabled by (infrastructure) / Provided by (harness) / Persisted by (store) / Supplied by (registry). Mermaid diagram, node table, frontmatter examples, derived-edge list, naming table, and ingest §0 all updated; a new The supply layer (registries) section carries the boundary test, the artifact-type corollary, the synthesis axis, the instance queue, and the ingest procedure.
The boundary test, which is the rule that keeps the layer from sprawling:an independent product, not a vendor’s shelf. A marketplace shipped by a harness vendor for its own harness (Anthropic’s, cursor/plugins, opencode’s registry, Droid’s plugin bundles) is a harness feature and stays a matrix row. A registry distributes capabilities across harnesses it does not own. Corollary on artifact type: this layer distributes capabilities consumed by a harness; Smithery distributes MCP servers, which is an adjacent and different artifact, so it is recorded rather than filed.
⚠ Reversal of a call made in conversation: bm-skills stays a framework. It was floated as the obvious re-filing candidate (a Claude Code plugin marketplace whose own page says it is “deliberately not a full-SDLC framework”), and on the evidence it fails the test in both directions — single-harness, and a GitHub repo of three of its own skills rather than a product distributing anyone else’s work. It is best read as a framework whose bundle is unusually loose, which is a known strain on the framework node rather than a misfiling. The reasoning is recorded on registry/index.md so it is not re-litigated; re-file only if it starts carrying third-party skills.
[2026-09-12] ingest | tessl — the supply layer’s anchor instance
Source: Tessl (docs.tessl.io, CLI v0.108.0) → raw/tessl/2026-09-12-tessl-platform.md (2,339 lines). The docs publish every page as Markdown at <url>.md and index them at llms.txt, so the capture is the primary pages verbatim — overview, core concepts, glossary, supported platforms, the creating/improving/distributing/governing guides, the inventory and agent pages — plus the complete 101-command CLI index (the reference page is 122KB of per-flag detail, reproduced as its heading structure rather than in full). GitBook’s trailing agent-instructions boilerplate stripped; nothing else altered. Company facts (London, 2024, Guy Podjarny of Snyk, $125M, 3,000+ skills) are from public reporting and are fenced off in the capture as not-from-the-docs.
The pivot is itself evidence for the layer. In 2025 Tessl paused Framework development and removed Framework functionality from its rebuilt CLI to concentrate on the registry and agent integrations. A company that set out to build a framework and became a registry instead is the cleanest possible argument that these are different things.
21 capability pages, full coverage by command family per the store precedent. Mostly off-stage as the layer predicts, with three genuine stage-review capabilities recorded as sideways growth rather than as stage coverage: tessl-code-review (PR review with versioned, pinnable lenses), tessl-change-risk (exit non-zero when a human is required), tessl-change-verify (LLM-judge verifiers over changed files). stage-review gained a “note on the registry entries” section warning against reading them as a framework’s coverage, and naming the real difference: framework review optimizes one engineer’s rigor, registry review optimizes an organization’s throughput.
The finding of the ingest: Tessl independently reproduces this wiki’s stage-review ∥ stage-validate split, for the skill corpus. It ships a review (structural, cheap, automatic on publish, scored on validation/description/content) and a scenario eval (run the agent on real tasks with and without the context, score the difference) and states the distinction itself — “a review tells you whether a skill is well written; an eval tells you whether it works.” That is is it good? ∥ does it work? arrived at from the supply side by a company that has never read this wiki. Convergence of that kind is the main thing the wiki produces, and finding it in a brand-new layer on the first ingest is the strongest signal the layer is real.
Two new patterns.pattern-capability-evals — prove a capability works by A/B-ing the agent with and without it and keeping the scenarios as a regression suite; the first pattern here whose subject is a capability rather than software, and the answer to “you can’t tell whether a skill improves output, so no one risks changing it.”pattern-supply-chain-scanning — scan a capability before install for prompt injection buried in instructions, secrets, suspicious URLs, and hidden or obfuscated text; the wiki’s guardrail patterns all bounded what the agent may write (pattern-edit-guardrails) or reach (gh-aw’s egress firewall), and this is the first that bounds what it may read. Hidden-text detection is the clause with no analogue in ordinary dependency scanning, and it exists because the consumer is a model reading prose.
Two new artifacts.artifact-capability-bundle — the versioned plugin (skills + rules + MCP servers + hooks), which matters because through hooks and MCP a registry install extends the harness’s own primitives, not just the prompt; the first case of an external product shipping into the hook surface. artifact-eval-suite — scenarios plus weighted rubrics versioned with the capability; a regression suite for prose.
It closes an instrument topic-ai-native-sdlc recorded as unshipped. That page called continuous evals of the agent’s own configuration“the one instrument nobody else ships”. Tessl sells exactly it. The claim is not retracted — it said no framework ships it, and none does — but the page now carries a dated update recording that config evals turned out to belong to the commercial layer that distributes and governs capabilities rather than the layer that authors them, alongside the RBAC, scanning, and audit trail that page also calls for.
The honest boundary note, recorded in four places. Tessl also ships tessl-launch (run a capability locally or in a cloud sandbox) and tessl-schedule (run a registry plugin on a cron), which is scheduled-trigger autonomy by the execution layer’s own taxonomy, and its tagline is “from scaling skills to building your software factory”. Filed as registry under the harness/runtime boundary rule applied one layer over — page the centre of gravity, record the second act as prose — because the unit executed is a registry plugin, the execution serves the index, and there is no coordination surface: no fan-out, no queue, no steering. Flagged as a re-ingest trigger on registry/tessl.md, registry/index.md, runtime/index.md, and the tessl-schedule page itself, so the call is re-checked rather than rediscovered.
Second-order finding: nothing in the process layer manages the sprawl it creates. Four frameworks make skill-creation a first-class stage-learn step (gstack-skillify, sp-writing-skills, pstack-reflect, ce-compound) and none of them has anything to say about the hundredth skill. tessl-inventory (“govern what you can see”) and tessl-observability (where skills activate, not where they are installed) are the layer’s answer; beads-rules was the nearest existing thing and works one repo at a time. Recorded on pattern-knowledge-compounding’s new Supplied by (registry) roster as the half the process layer never had.
Third: cursor is now the wiki’s most-referenced unpaged harness, named independently by pstack (built natively on it), tessl (auto-configured by tessl init), and beads’ setup recipes. Flagged on harness/index.md. Ingesting it would also let pstack’s empty runs_on: be wired — the open item from the 2026-09-11 ingest.
Cascade: 16 pattern pages gained Tessl Applied by entries and 4 gained new Supplied by (registry) rosters (pattern-deterministic-gates, pattern-knowledge-compounding, pattern-evidence-before-claims, pattern-context-engineering); 4 artifact pages gained Produced by entries; claude-code and opencode gained Registries that integrates_with: it backlinks and harness/index.md gained a Registry support section with its own matrix; stage-review gained a roster plus the weighting note; store/index.md and runtime/index.md gained boundary notes; catalogue.md gained a ## registry section, 21 capability rows, 2 artifact rows, and 2 pattern rows; index.md moved from four layers to five (391 capabilities / 40 artifacts / 37 patterns / 1 registry) and gained a §Managing skills at organizational scale. No stage re-derivation — a registry implements no stage as a layer, and the three review capabilities land in an existing well-evidenced stage. Zero dangling wikilinks.
[2026-09-26] ingest | builder-skills — the Factory, a software factory made of instructions
Source: Builder.io — BuilderIO/skills (MIT), shallow clone of main at a74a3a0 (2026-09-25) → raw/builder-skills/2026-09-26-builder-skills.md (3,395 lines): plugin manifests, README, the Factory guide and configuration reference verbatim, all nine Factory SKILL.md files verbatim, ten other SKILL.md files verbatim, the five long host-integration skills (visual-plan, visual-recap, visual-edit, turn-into-app, webmcp) as frontmatter plus opening sections marked truncated, commands/an.md, the agents/openai.yaml stubs, and the file tree.
Layer call: framework, not runtime. This was the ingest’s main decision. The Factory calls itself a software factory and fills every socket of the factory anatomy, but it “install[s] agent instructions … not integrations, credentials, scheduled jobs, or permission grants.” The scheduler, connectors, worktrees, and credentials all come from the host, so it spawns no loops and fails “a runtime spawns loops”. Stage coverage agrees: 12 of 24 capabilities are on-stage. Recorded on the framework page, as a boundary note plus a re-ingest trigger on runtime/index.md (re-check if Builder ships something that runs jobs itself), and as the new 🧩 marker on the topic grid.
24 capability pages, full coverage: 9 Factory skills and 15 others. commands/an.md is documented on builder-an rather than paged separately, because it is a thin wrapper that invokes that skill. Naming prefix builder-.
The main finding: it fills the empty cell in topic-software-factory’s grid. The “in the prompt — the agent sequences itself” control-plane column had no documented anchor and existed only as what sssf defines itself against. The topic page gained a dated section, A factory with no runtime: the skill-pack pole, and a fifth grid marker 🧩. The section argues that the Factory’s contribution to the design space is a new axis, how authority is decomposed, and that gh-aw’s safe outputs are the other end of the same axis (prose policy the agent is trusted to obey, versus structural channels it cannot bypass).
One new artifact: artifact-autonomy-policy (.agent-factory/config.yaml). It is minted because what it governs is new. artifact-constitution governs design principles and artifact-standards governs conventions; this governs authority. It is also explicitly “an agent-readable convention, not a validated schema”, which is why the Factory reads back every automation it asks the host to create.
Ideas worth taking, flagged on their pages: (1) unavailable ≠ truncated ≠ empty as a rule for the agent’s inputs, so a broken connector cannot report all clear (builder-factory-collect); (2) evidence expires with the head, plus a soak that “missing history does not satisfy” (builder-factory-babysit-pr); (3) “a merge is not live proof”, with deploy verification as a separate proof point (builder-factory-ship); (4) the human as a read-only queue rather than an interrupt (builder-factory-human-digest); (5) DONT_NOTIFY as an explicit outcome for a scheduled monitor (builder-factory-watchdog); (6) investigate independently, then diff, and relay to a mid-run agent only in ranked batches (builder-agent-watchdog); (7) plan quality separated from executor choice (builder-plan-arbiter); (8) “decide the hard-to-reverse bets first” (builder-visual-plan).
Stage re-derivation: no renames, splits, or merges; two notes recorded. (a) stage-learn gained a third flavor, production-signal learning (builder-factory-lookback), recorded as a flavor rather than a split because only one framework evidences it. The section heading changed from “Two flavors” to “Flavors” (no inbound anchors). (b) The stage-operate split candidate on stage-release gained builder-skills as a fourth framework at the capability level. Deploy verification is separate from merge, and production telemetry and errors feed intake. It still names no standalone Operate phase, so the bar is not cleared, but the evidence now covers both halves of the arc (deploy→verify in gstack, production signal→fix here). aka: updated on six stages. The Factory ships no stage-specify and no stage-validate capability; validation is folded into ship and collect as “run the configured checks”.
Harness support:runs_on: wired to claude-code, pi, opencode. Codex, Cursor, GitHub Copilot / VS Code, and Claude Cowork are recorded in prose. harness/index.md’s Cursor-gap note moves from three independent sources to four. claude-code’s “all twelve frameworks” line was corrected to “thirteen of the fourteen”, with pstack (Cursor-native) named as the exception. The pstack ingest had not updated that line.
Cascade: 6 stage pages (rosters, aka:, sources:); sdlc-stage/index.md matrix row (12 on-stage / 12 off-stage) and an off-stage note describing the Factory’s supervision layer as a new kind of off-stage capability; 17 pattern pages gained Applied by entries and 3 gained See Also links to the new patterns; 7 artifact pages gained Produced by entries; gh-aw and factory-droid gained enables: edges and roster bullets; claude-code, pi, opencode, and harness/index.md gained support rows; runtime/index.md gained the boundary note; pstack and gh-aw gained See Also cross-refs; topic-software-factory gained the 🧩 section; catalogue.md gained 1 framework, 24 capability, 1 artifact, and 2 pattern rows, with 87 touched rows re-dated; index.md counts 13→14 frameworks / 391→415 capabilities / 40→41 artifacts / 37→39 patterns, plus a new §Letting agents act without a human in the loop.
Lint observation, not fixed (out of scope): the framework × stage matrix in sdlc-stage/index.md has no rows for agent-os or pstack, although both were ingested after the matrix was built. Worth a pass.
[2026-10-11] ingest (update) | Matt Pocock — Skills for Real Engineers v1.3.1
Re-ingest of github.com/mattpocock/skills at the latest release, tag v1.3.1 (2026-10-04); was v1.1.0 (2026-07-09). Covers v1.2.0 (2026-08-05), v1.2.2, v1.2.3, v1.3.0 and v1.3.1. New raw: raw/matt-pocock-skills/2026-10-04-skills-v1.3.1-update.md (1,096 lines): README verbatim, a SKILL.md frontmatter catalogue at the tag (bucket, invocation mode, description), the CHANGELOG 1.2.0→1.3.1 verbatim, and the full SKILL.md of ask-matt plus each newly promoted skill. Older raws retained (immutable). Pinned to the tag on purpose: 46 commits on main after v1.3.1 (e.g. wayfinder tracker hygiene, ask-matt reading SKILL.md first) are unreleased and were left out.
7 new capability pages (full coverage of everything promoted since v1.1): mp-implement-spec (parallel whole-spec execute: task graph, ready frontier, worktree implementers, one integration branch), mp-pr (PR-body shape; Summary visual / Evidence / Merge Danger), mp-retro (environment retrospective), mp-to-questionnaire (grill the send), mp-wizard (bash wizard for human-only steps), mp-wait-what (three-line re-pitch), mp-writing-for-agents (renamed from writing-great-skills). in-progress/ (incl. new setup-ts-deep-modules) stays catalogued, not paged.
One removal:mp-resolving-merge-conflicts was deleted upstream in v1.3.0 (“nothing replaces it”). The page is kept as a historical record with a removal banner so links resolve; struck through on the framework page and stage-implement. Also deleted upstream and recorded on the framework page: the four v1.1 deprecations (ubiquitous-language, design-an-interface, qa, request-refactor-plan) and the personal/ bucket.
The main finding: MP’s line became a loop. v1.3.0 extends the main flow past code-review with mp-pr → mp-retro. MP gains its first stage-learn capability (gap listed since 2026-06-28) and a partial stage-release one. Matrix row: Release ➖→🟡, Learn ➖→🟡, Off-stage 2→5; the row moved above BMAD (7 of 8 stages, no Validate).
New learn flavor recorded: environment compounding (mp-retro): lessons go into the harness (checks, standards, pointers, tooling). It is the most computational flavor yet: “a mechanical [violation] gets a deterministic check, full stop”. topic-compounding-loop gained an Environment row and dated notes on gaps 1 and 3. Gap 3 (learn outputs are never sensors) is now partly closed by pstack-reflect + mp-retro, but both still propose rather than write the check. Gap 1 (session mining) arguably now has a second full framework, so the pattern-session-mining mint is a live decision for the next ingest. Not minted here.
Naming conflict resolved upstream: MP renamed CONTEXT.md → GLOSSARY.md (v1.3.0), ending the filename clash with GSD’s artifact-phase-context. artifact-domain-model retitled; both pages, artifact/index.md and the catalogue rows were updated.
Stage re-derivation: no renames, splits, merges, adds or retires.mp-to-questionnaire adds a delegated-elicitation flavor to stage-align (single framework, recorded as a flavor). mp-pr is a body-only instance of release, recorded as 🟡. aka: updated on align (to-questionnaire), implement (implement-spec; merge-conflicts dropped), release (pr), learn (retro).
Harness: v1.2.0 ships a native Claude Code plugin (official marketplace) and Codex metadata (agents/openai.yaml per skill). runs_on: stays [[claude-code]] (no Codex harness page); Codex is recorded in prose.
Updated: matt-pocock-skills (framework page: workflow diagram, v1.3.1 summary, main flow, capability groups incl. new Release/Learn, removed + in-progress lists, artifacts, patterns, See Also)
Updated: topic-compounding-loop; catalogue.md (framework row, 13 MP rows, 7 new rows, 4 stage rows, 3 artifact rows); index.md capability count 415 → 422. Zero new dangling wikilinks.
[2026-10-11] schema | Current-version bodies, ## Version history at the bottom
New formatting convention in CONVENTIONS.md (Formatting conventions + ingest workflow step 7). On pages for versioned subjects (framework, capability, harness, runtime, store, registry), the body describes only the latest ingested version: no inline version tags, “formerly” asides, “updated to vX” callouts, or comparisons with earlier releases. Removed items leave the body lists. Per-release changes go in a ## Version history section, placed last, newest first. Stage, artifact, pattern and topic pages are syntheses and get no history section.
Applied to matt-pocock-skills (the reference example) and 19 MP capability pages. While doing it: an “investigation tickets” leftover was fixed, the pstack See Also entries were merged, pattern-trunk-based-development was dropped from the framework’s current pattern list (only the removed skill applied it), and the missing v1.3.1 raw was added to mp-to-spec’s raw: field. Other frameworks’ pages need no retrofit: a scan found no inline change notes outside the MP family.