@lifeaitools/rdc-skills 0.24.39 → 0.24.42

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.24.39",
+  "version": "0.24.42",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/README.md

@@ -200,8 +200,9 @@ Located in `guides/agents/` — plain markdown playbooks spawned as sub-agents:
 ### Deploy
 - rdc:deploy
 
-### Release
-- rdc:release
+### Release
+- rdc:release
+- Release contract: [RELEASE.md](RELEASE.md)
 
 ### Dev Loop
 - rdc:fixit, rdc:collab, rdc:co-develop, rdc:edit

package/RELEASE.md

@@ -0,0 +1,42 @@
+---
+doc_type: release-runbook
+status: active
+package: "@lifeaitools/rdc-skills"
+---
+
+# Release rdc-skills
+
+`@lifeaitools/rdc-skills` is released to npm and then installed into the active
+LifeAI skill profile. This runbook is the required release contract for every
+version.
+
+## Release checklist
+
+1. Reconcile the release branch with its remote and confirm the intended diff.
+2. Run `npm run validate`, focused deterministic tests, and an independent RDC
+   review for the candidate changes.
+3. Bump the package with `npm version patch --no-git-tag-version` (or the
+   approved minor or major equivalent).
+4. Commit the version files with the associated RDC work-item trailer and push
+   the release branch.
+5. Create and push `v<version>`; the publish workflow publishes the tagged
+   package to npm.
+6. Wait for the publish workflow to complete, then verify it with
+   `npm view @lifeaitools/rdc-skills version` and
+   `npm view @lifeaitools/rdc-skills@<version> version`.
+7. Inspect the registry artifact with
+   `npm pack @lifeaitools/rdc-skills@<version>` and verify the changed skill
+   files are present in the tarball.
+8. Install the published package with
+   `npm install -g @lifeaitools/rdc-skills@<version>`.
+9. Reinstall the active profile with `rdc-skills-install --profile core`; on a
+   workstation intentionally configured for the LIFEAI project layout and
+   services, use `rdc-skills-install --profile lifeai`.
+10. Verify the global package version, the active profile copy, and the skill
+    smoke check before closing the release work item.
+
+## Deployment boundary
+
+The LifeAI profile installation is the development delivery for this library.
+Application production promotion remains separately approval-gated through
+`rdc:deploy promote`; this package runbook never promotes an application.

package/git-sha.json

@@ -1,3 +1,3 @@
 {
-  "sha": "53c79709138b1fc115a31d82670fcb15fc80a205"
+  "sha": "3bc908e850bac783d6c90ab040d081e4c763274a"
 }

package/guides/lessons-learned-spec.md

@@ -62,8 +62,8 @@ id: <YYYY-MM-DD>-<skill>-<short-slug>
 date: "<YYYY-MM-DD>"
 skill: build | deploy | overnight | fixit | plan | preplan | review | release | collab
 session: <session-id or short ref>
-scope: simple | architectural          # triage routing — see § Scope gate
-status: open | triaged | applied | wont-fix
+scope: simple | architectural          # triage routing — see § Scope gate
+lesson_status: open | triaged | applied | wont-fix
 area: infra | skill | guide | rule | schema | ui | content | other
 links:
   commits: []                          # SHAs that relate to the lesson
@@ -78,20 +78,31 @@ links:
 <one paragraph — the evidenced cause, not a guess>
 
 ## The fix / rule
-<what should change so this never recurs: a rule edit, skill-doc line, code change,
-or a check. If already applied in the same run, say so and link the commit.>
+<what should change so this never recurs: a rule edit, skill-doc line, code change,
+or a check. Cite a same-run related commit as context when useful, but keep
+lesson_status: open until the weekly triage audit records the final outcome.>
 ```
 
-`scope` is the single most important field — it routes triage:
+`scope` is the single most important field — it routes triage:
 
 - **`simple`** — a doc line, a one-file fix, a config tweak, a clarifying sentence in a
-  skill, a missing grep guard. Housekeeping applies these directly.
+  skill, a missing grep guard. Housekeeping routes these through `rdc:fixit` or
+  `rdc:plan` -> `rdc:build`; it never applies them outside an RDC work item.
 - **`architectural`** — anything matching `.claude/rules/architectural-change-approval.md`
   (rule/CLAUDE.md/ARCHITECTURE.md edits, cross-cutting refactors, schema reshape, public
   API/MCP changes, skill-contract changes affecting multiple skills). Housekeeping does
   NOT apply these; it surfaces them via `AskUserQuestion` for explicit approval first.
 
-When unsure, mark `architectural`.
+When unsure, mark `architectural`.
+
+### Legacy status migration
+
+Older lesson files may use `status` instead of `lesson_status`. During weekly
+intake, before filtering or clustering, normalize every lesson that has
+`status` and no `lesson_status` by moving the unchanged value to
+`lesson_status` and removing the legacy key. Record each migration in the
+weekly report. Do not reinterpret a legacy value or create a work item merely
+because it was migrated.
 
 ---
 
@@ -116,30 +127,25 @@ in a rule/guide. If a durable user preference or correction was involved, also w
 At the end of a long skill run, before the final verdict line:
 
 1. Decide if anything qualifies (§ When to capture). If not, write nothing and move on.
-2. For each lesson, write `.rdc/lessons/<date>-<skill>-<slug>.md` using the schema above.
-   Set `status: open` (or `applied` if you already shipped the fix in this same run, with
-   the commit linked).
+2. For each lesson, write `.rdc/lessons/<date>-<skill>-<slug>.md` using the schema above.
+   Set `lesson_status: open`; a captured lesson is never self-marked as applied.
 3. Set `scope` honestly (`simple` vs `architectural`).
 4. Commit the lesson file(s) on `develop` alongside the run's other commits.
 5. Mention in the verdict/summary that N lessons were captured.
 
 ---
 
-## Triage procedure (rdc:housekeeping, weekly)
-
-`rdc:housekeeping` adds a **Lessons triage** phase:
-
-1. Read all `.rdc/lessons/*.md` with `status: open`.
-2. Cluster by `area` + root-cause similarity (dedupe repeats into one fix).
-3. For each cluster:
-   - `scope: simple` → apply the fix directly (rule line, skill-doc edit, config, guard),
-     commit it, set the lesson(s) `status: applied` and link the commit.
-   - `scope: architectural` → do NOT edit. Present the issue + options via
-     `AskUserQuestion` (per `architectural-change-approval.md`). On approval, apply via the
-     correct lifecycle (rdc-skills tag/push for skills; cited commit for rules) and set
-     `status: applied`. If deferred, set `status: triaged` and spawn a `work_item`.
-   - Not worth fixing → `status: wont-fix` with a one-line reason.
-4. Summarize in the housekeeping report: captured / applied / escalated / deferred counts.
+## Triage procedure (rdc:housekeeping, weekly)
+
+`rdc:housekeeping` uses this strict order. It prevents duplicate plans and fixits, gathers every architectural answer before changes, and keeps each executable change inside an RDC work item.
+
+1. Normalize legacy `status` fields as described above, then read all `.rdc/lessons/*.md` with `lesson_status: open` and cluster by `area` + root-cause similarity.
+2. **Resolution audit before routing:** for every cluster, inspect the relevant code, rules, skills, guides, tests, recent commits, linked work items, and existing mitigations. Record what was inspected, the evidence, and one result: `already-fixed`, `sufficiently-mitigated`, or `still-open`. Do not create an `rdc:fixit`, `rdc:plan`, or `rdc:build` item before this audit.
+3. Resolve no-work clusters from the audit: link the prior commit and set `lesson_status: applied` for `already-fixed`; set `lesson_status: wont-fix` for a sufficient mitigation with its remaining-risk reason. Leave partially mitigated clusters open.
+4. **Architectural report and interview:** before any file changes, report every still-open architectural decision with options, tradeoffs, recommendation, risks, and audit evidence. Create the complete interview list, ask each required question in attended mode, and record every question, answer, decision, rationale, and affected cluster. Gather all answers before the first fix. In unattended mode, create deduplicated `human_items` decision records and defer unresolved choices.
+5. **RDC routing:** route each approved still-open cluster through a complete work item and either `rdc:fixit` (only under its scope limit; it creates the sole work item) or `rdc:plan` -> `rdc:build`. Include cluster and lesson ids in the fixit description or planned task. No direct edits are allowed. Complete the required checklist, implementation report, review, validator closure, commit, and push. Deploy deployable targets to dev through RDC and record the evidence; record `not applicable` for non-deployable work.
+6. Run `rdc:review` across each completed action batch. Mark lessons `lesson_status: applied` only after review passes and the linked commit is pushed; mark deferred and declined clusters `triaged` or `wont-fix` with their linked evidence.
+7. Write the full weekly lessons report with cluster audit, architectural report, interview Q&A, RDC action register, deployment evidence, and counts for open, deduped, already fixed, mitigated, applied, triaged, wont-fix, deferred, fixits, builds, review passes, and dev deployments.
 
 Lessons are never silently deleted — `applied` and `wont-fix` files stay as the audit trail.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.24.39",
+  "version": "0.24.42",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -43,6 +43,7 @@
     "test:curl-surface:remote": "node tests/curl-surface.test.mjs --remote",
     "test:channel-formatter": "node tests/channel-formatter.contract.test.mjs",
     "test:channel-formatter:remote": "node tests/channel-formatter.contract.test.mjs --remote",
+    "test:brochure": "node tests/rdc-brochure.test.mjs",
     "mcp": "node bin/rdc-skills-mcp.mjs",
     "rebuild-mcp": "node scripts/rebuild-mcp.mjs",
     "prepack": "node scripts/prepack.mjs"

package/scripts/rdc-brochure.mjs

@@ -126,6 +126,7 @@ async function loadPuppeteer() {
 // If the lib cannot be resolved or installed, fall back to a platform-native
 // extractor: `unzip` on POSIX, PowerShell `Expand-Archive` on win32.
 function loadAdmZip() {
+  if (process.env.RDC_BROCHURE_DISABLE_ADM_ZIP === '1') return null;
   try { return createRequire(import.meta.url)('adm-zip'); } catch {}
   // Reuse the puppeteer on-demand cache dir for an isolated local install.
   const cacheDir = join(homedir(), '.cache', 'rdc-brochure');
@@ -275,6 +276,16 @@ function listTemplates() {
     .sort();
 }
 
+function stripLeadingYamlFrontMatter(md) {
+  const text = md.replace(/\r\n/g, '\n');
+  if (!text.startsWith('---\n')) return text;
+  const lines = text.split('\n');
+  for (let i = 1; i < lines.length; i++) {
+    if (/^---\s*$/.test(lines[i])) return lines.slice(i + 1).join('\n');
+  }
+  return text;
+}
+
 async function composeFromFolder(root, file) {
   const tpl = join(TEMPLATES_DIR, `brochure-${opts.template}.html`);
   if (!existsSync(tpl)) {
@@ -298,12 +309,13 @@ async function composeFromFolder(root, file) {
 
   const sections = mdFiles.map((p) => {
     const md = readFileSync(p, 'utf8');
+    const bodyMd = stripLeadingYamlFrontMatter(md);
     // Only prepend the filename heading when the markdown has no leading ATX heading
     // of its own. Avoids a redundant <h2>filename</h2> stacked above a "# Title".
-    const firstNonEmpty = md.replace(/\r\n/g, '\n').split('\n').find((l) => l.trim() !== '') || '';
+    const firstNonEmpty = bodyMd.replace(/\r\n/g, '\n').split('\n').find((l) => l.trim() !== '') || '';
     const hasLeadingHeading = /^#{1,6}\s+\S/.test(firstNonEmpty.trim());
     const heading = hasLeadingHeading ? '' : `<h2>${escapeHtml(basename(p, extname(p)))}</h2>`;
-    return `<section class="brochure-section">${heading}${mdToHtml(md, dirname(p))}</section>`;
+    return `<section class="brochure-section">${heading}${mdToHtml(bodyMd, dirname(p))}</section>`;
   }).join('\n');
 
   html = html.replace(/\{\{TITLE\}\}/g, escapeHtml(title)).replace(/\{\{SECTIONS\}\}/g, sections);
@@ -447,6 +459,12 @@ function defaultOutPath() {
     }
   }
 
+  if (process.env.RDC_BROCHURE_COMPOSE_ONLY === '1') {
+    console.log(`HTML:   ${htmlSource}`);
+    console.log(`Source: ${input} → ${htmlSource.startsWith('http') ? htmlSource : relative(process.cwd(), htmlSource)}`);
+    return;
+  }
+
   const outPath = await render(htmlSource);
   const size = statSync(outPath).size;
   let pages = '?';

package/skills/build/SKILL.md

@@ -560,4 +560,4 @@ NEVER run pnpm build or pnpm turbo. Use npx vitest run only.
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-build-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-build-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/collab/SKILL.md

@@ -236,4 +236,4 @@ If Dave types in this terminal during a turn:
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-collab-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-collab-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/deploy/SKILL.md

@@ -522,7 +522,7 @@ When diagnosing a broken deploy in Mode 3: query `coolify_events` FIRST before r
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-deploy-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-deploy-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
 
 ## References
 

package/skills/fixit/SKILL.md

@@ -162,4 +162,4 @@ Report: what was fixed, file(s) changed, commit hash. One sentence.
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-fixit-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-fixit-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/housekeeping/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rdc:housekeeping
-description: "Usage `rdc:housekeeping [--fix]` — Weekly maintenance audit: directory structure verification, PUBLISH.md URL validation, CLAUDE.md freshness, orphan detection, places compliance, and stale version scan. Produces `.rdc/reports/YYYY-MM-DD-housekeeping.md`. With `--fix`, auto-remediate safe issues."
+description: "Usage `rdc:housekeeping [--fix|--lessons]` — Weekly maintenance audit and lessons-only triage with a prior-fix audit, architectural interview gate, RDC work routing, and a complete report. Produces `.rdc/reports/YYYY-MM-DD-housekeeping.md`."
 ---
 
 > **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
@@ -21,13 +21,16 @@ description: "Usage `rdc:housekeeping [--fix]` — Weekly maintenance audit: dir
 - When disoriented about repo health
 - Called by `rdc:overnight` as a pre-flight if `--housekeeping` flag set
 
-## Arguments
-- `rdc:housekeeping` — audit only, report issues
-- `rdc:housekeeping --fix` — auto-remediate safe issues (scaffold missing CLAUDE.md, fix PUBLISH.md URLs, create missing tracker dirs)
+## Arguments
+- `rdc:housekeeping` — audit only, report issues
+- `rdc:housekeeping --fix` — auto-remediate safe issues (scaffold missing CLAUDE.md, fix PUBLISH.md URLs, create missing tracker dirs)
+- `rdc:housekeeping --lessons` — process only the weekly lessons triage workflow, including its audit, decision interview, routed work, and report
 
-## Procedure
-
-### 1. Directory Structure Verification
+## Procedure
+
+When invoked with `--lessons`, skip every non-lessons maintenance section below (including Directory Structure Verification) and begin directly at **Lessons triage (weekly)**. Produce the lessons report only.
+
+### 1. Directory Structure Verification
 
 Scan every deployable target for required files:
 
@@ -158,28 +161,84 @@ Write to `.rdc/reports/YYYY-MM-DD-housekeeping.md`:
 ## Verdict: CLEAN / HAS_ISSUES
 ```
 
-## Lessons triage (weekly)
-
-Read all `.rdc/lessons/*.md` with `status: open` (schema + procedure: `.rdc/guides/lessons-learned-spec.md` § Triage procedure). Cluster by `area` + root-cause similarity (dedupe repeats into one fix).
-
-### Attended mode (default — a human is present)
-
-For each cluster:
-
-- `scope: simple` → apply the fix directly (rule line, skill-doc edit, config, guard), commit it, set the lesson(s) `status: applied` with the commit linked.
-- `scope: architectural` → do NOT edit. Present the issue + options via `AskUserQuestion` (per `.claude/rules/architectural-change-approval.md`). On approval, apply via the correct lifecycle (rdc-skills tag/push for skills; cited commit for rules) and set `status: applied`. If deferred, set `status: triaged` and spawn a `work_item`.
-- Not worth fixing → `status: wont-fix` with a one-line reason.
+## Lessons triage (weekly)
+
+Before filtering or clustering, read every candidate lesson **in full**. Normalize every
+legacy lesson that has `status` but no `lesson_status` by moving its existing value to
+`lesson_status` and record the migration in the report. Validate that each candidate has
+exactly one frontmatter block, canonical `lesson_status`, and the required routing fields
+(`id`, `date`, `skill`, `runtime`, `scope`, `area`, `needs_claude`, `links`); a malformed
+record is itself a triage finding, never an invisible parser omission.
+
+Before asking Dave a single question or routing any fix, write four synthesis artifacts in
+the weekly report: (1) a correlation table accounting for **every** candidate lesson with its
+remediation train, shared root cause, systemic fix, owner/lifecycle, and closure evidence;
+(2) a remediation model that collapses recurring symptoms into the smallest control set and
+execution order; (3) a resolution audit; and (4) one compact architectural-decision table
+with options and a recommendation for each genuine trade-off. Do not make Dave reconstruct
+the model from serial lesson prompts. This phase is a controlled weekly workflow: synthesize
+first, then collect the complete architectural interview, then route approved work through
+RDC. It must never create a duplicate plan or fixit for a lesson that is already fixed or
+sufficiently mitigated.
+
+### 1. Cluster
+
+Cluster by `area` + root-cause similarity and dedupe repeats into one proposed outcome. Give every cluster a stable identifier and list its lesson ids, area, evidenced root cause, proposed change, scope, and linked commits/work items.
+
+### 2. Resolution audit (mandatory before routing work)
+
+For every cluster, inspect the relevant code, rules, skills, guides, tests, recent commits, linked work items, and existing mitigations before creating any `rdc:fixit`, `rdc:plan`, or `rdc:build` work.
+
+Record auditable evidence and classify the cluster as exactly one of:
+
+- `already-fixed` — the needed behavior is present and backed by a cited source location, test, or shipped commit; do not create new work.
+- `sufficiently-mitigated` — an existing guard, process, or documentation reduces the risk enough that no additional change is justified; do not create new work and record the remaining risk.
+- `still-open` — the evidence does not fully address the root cause; only this result may enter the routing phase.
+
+The audit must name what was inspected, the evidence found or missing, the conclusion, and the reason no duplicate work was created. Mark an already-fixed lesson `lesson_status: applied` only when its prior commit is linked; mark a sufficiently-mitigated lesson `lesson_status: wont-fix` with the mitigation and remaining-risk reason. Keep partially mitigated clusters open for routing.
+
+### 3. Architectural report and interview gate
+
+After the synthesis artifacts are complete, write the full architectural report for every `still-open` architectural cluster. For each one include the decision to make, affected systems, options and tradeoffs, recommendation, unresolved risks, and the result of the resolution audit. This produces the complete decision table and is the required gate before every routed fix.
+
+Create a complete interview list from that report before changing any file. In attended mode, ask every required architectural question via `AskUserQuestion`, one question at a time, and record the question, answer, decision, rationale, and affected cluster. Do not start simple or architectural fixes until all interview questions have answers or the corresponding cluster is explicitly deferred. Silence is not approval.
+
+If there are no architectural decisions, record `Architectural interview: none required` in the report before continuing. In unattended mode, do not guess: create the equivalent `human_items` decision records for every unresolved architectural question, link a work item, and defer those clusters.
+
+### 4. Route only still-open, approved work through RDC
+
+After the resolution audit and the complete architectural interview, route every approved executable cluster through an RDC lifecycle with a complete work item, required checklist evidence, implementation report, review status, validator closure, commit, and push. Direct edits outside an RDC work item are forbidden.
+
+- `scope: simple` — invoke `rdc:fixit` when the change is genuinely under five files and thirty minutes; `rdc:fixit` creates and completes the sole work item. Include the cluster and lesson ids in its description and action-register entry. Otherwise use `rdc:plan` followed by `rdc:build`.
+- `scope: architectural` — use `rdc:plan` followed by `rdc:build` unless the approved change is genuinely within the `rdc:fixit` threshold. The plan must contain the approved interview decision and acceptance checks.
+- Deferred or declined clusters — set `lesson_status: triaged` or `lesson_status: wont-fix`, link the work item or reason, and do not make an unapproved change.
+
+Each routed wave must run the review gate: `rdc:fixit` performs its mandatory review and every batch also completes `rdc:review` before lessons are marked applied. Deploy a changed deployable target to dev through its normal RDC lifecycle and record the deployment evidence; document `not applicable` for documentation-only, rule-only, or skill-only work.
+
+### 5. Complete weekly lessons report
+
+Add a `## Weekly Lessons Triage` section to `.rdc/reports/YYYY-MM-DD-housekeeping.md` with:
+
+1. `### Cluster and resolution audit` — cluster ids, lessons, area/cause, inspected evidence, `already-fixed` / `sufficiently-mitigated` / `still-open` result, and duplicate-work decision.
+2. `### Architectural report` — each decision, options, tradeoffs, recommendation, risks, and audit result.
+3. `### Architectural interview` — the complete question-and-answer list, decisions, deferrals, and clusters affected; explicitly state when none was required.
+4. `### RDC action register` — work item, selected lifecycle (`rdc:fixit` or `rdc:plan` -> `rdc:build`), test/review evidence, commit/push, dev deployment or `not applicable`, and final lesson status.
+5. `### Outcome counts` — open, deduped, already fixed, sufficiently mitigated, applied, triaged, wont-fix, deferred, fixits, builds, review passes, and dev deployments.
+
+### Attended mode (default — a human is present)
+
+The attended run follows sections 1 through 5 in order. The full interview list and all answers are collected before the first routed fix starts; then batch approved fixes by lifecycle and target. Set `lesson_status: applied` only after the routed work item has passed review, the commit is pushed, required dev deployment evidence is recorded, and the commit is linked.
 
 ### Unattended mode (no human — overnight / cron / `rdc:overnight`)
 
-When the weekly triage runs unattended, follow `.rdc/guides/lessons-learned-spec.md` § **Triage procedure — UNATTENDED weekly mode** — do not run `AskUserQuestion`. In brief (the spec is authoritative):
+When the weekly triage runs unattended, perform the same cluster and resolution audit before any routing, then follow `.rdc/guides/lessons-learned-spec.md` § **Triage procedure — UNATTENDED weekly mode** — do not run `AskUserQuestion`. In brief (the spec is authoritative):
 
 - **Per-difficulty model routing** (reuses the `rdc:build` table): the run is led by `claude-opus-4-8` for clustering + scope/difficulty triage; mechanical apply → `claude-sonnet-4-6`; harder multi-file/migration fix → `claude-opus-4-6`; design/architectural fix → `claude-opus-4-8`.
-- `scope: simple` → apply directly or via `rdc:fixit`, commit, `status: applied`.
-- `scope: architectural` with a single clear correct fix (records an already-learned lesson — e.g. "document X", "add a gate", update a guide) → route through `rdc:plan` → `rdc:build` (or `rdc:fixit` if genuinely <5 files), update the documentation, set `status: applied`/`triaged`.
-- `scope: architectural` **and genuinely ambiguous** (multiple valid approaches, real tradeoffs) → write a `human_items` row (`item_type='decision'`, with options in `suggested_agent_prompt`, `source_type='lesson'`, `source_fingerprint` for dedupe), set `status: triaged`, spawn + link a `work_item`. Decided in the morning. This is the asynchronous equivalent of the attended interview and honors `.claude/rules/architectural-change-approval.md`.
-
-Never delete lesson files — `applied` and `wont-fix` stay as the audit trail. Report captured / applied / escalated / deferred counts in the housekeeping report.
+- `scope: simple` → create a complete work item and route via `rdc:fixit` or `rdc:plan` -> `rdc:build`; never apply directly.
+- `scope: architectural` with a single clear correct fix (records an already-learned lesson — e.g. "document X", "add a gate", update a guide) → route through `rdc:plan` → `rdc:build` (or `rdc:fixit` if genuinely <5 files), update the documentation, set `lesson_status: applied`/`triaged`.
+- `scope: architectural` **and genuinely ambiguous** (multiple valid approaches, real tradeoffs) → write a `human_items` row (`item_type='decision'`, with options in `suggested_agent_prompt`, `source_type='lesson'`, `source_fingerprint` for dedupe), set `lesson_status: triaged`, spawn + link a `work_item`. Decided in the morning. This is the asynchronous equivalent of the attended interview and honors `.claude/rules/architectural-change-approval.md`.
+
+Never delete lesson files — `applied` and `wont-fix` stay as the audit trail.
 
 ## Rules
 - Never run `pnpm build` — not needed for this audit

package/skills/overnight/SKILL.md

@@ -248,4 +248,4 @@ Provide the advisor with:
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-overnight-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-overnight-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/plan/SKILL.md

@@ -342,4 +342,4 @@ designing topology. Do not reach for the REMOTE rule by default.
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-plan-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-plan-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/preplan/SKILL.md

@@ -87,4 +87,4 @@ direction if given. If advisor cannot resolve, log and skip to next step.
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-preplan-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-preplan-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/release/SKILL.md

@@ -137,4 +137,4 @@ Use `--profile lifeai` only on a workstation that intentionally has the LIFEAI p
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-release-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-release-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/review/SKILL.md

@@ -149,4 +149,4 @@ description: "Usage `rdc:review [--unattended]` — Post-build quality gate: tsc
 
 ## Capture lessons (exit step)
 
-Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-review-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `status` (`open`, or `applied` if you shipped the fix in this same run, with the commit linked). Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.
+Before the final verdict line, follow `.rdc/guides/lessons-learned-spec.md` § Capture procedure. If this run taught something non-obvious — a first root-cause theory that turned out wrong, the documented/standard path not working, a missing gate or check that cost a round, or a surprising tool/infra behavior — write one `.rdc/lessons/<YYYY-MM-DD>-review-<short-slug>.md` per lesson using the schema in that spec. Set `scope` (`simple` | `architectural`) and `lesson_status: open`; weekly triage alone records a final lesson outcome. Commit the lesson file(s) on `develop` alongside the run's other commits, and note "N lessons captured" in your verdict/summary. A run that taught nothing writes nothing — absence is the default.

package/skills/tests/rdc-housekeeping.test.json

@@ -15,10 +15,14 @@
   "acceptance": {
     "output_contains": [
       "Housekeeping",
-      "PUBLISH.md",
-      "CLAUDE.md",
-      "orphan",
-      ".rdc/reports"
+      "PUBLISH.md",
+      "CLAUDE.md",
+      "orphan",
+      ".rdc/reports",
+      "resolution audit",
+      "architectural report",
+      "interview",
+      "RDC action register"
     ],
     "output_not_contains": [
       "auto-remediate",

package/tests/housekeeping-lessons-triage.test.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const skill = readFileSync(join(root, 'skills', 'housekeeping', 'SKILL.md'), 'utf8');
+const guide = readFileSync(join(root, 'guides', 'lessons-learned-spec.md'), 'utf8');
+
+function mustAppearInOrder(text, fragments, name) {
+  let previous = -1;
+  for (const fragment of fragments) {
+    const index = text.indexOf(fragment);
+    assert.notEqual(index, -1, `${name} is missing: ${fragment}`);
+    assert.ok(index > previous, `${name} orders ${fragment} before its required predecessor`);
+    previous = index;
+  }
+}
+
+assert.match(skill, /canonical `lesson_status`/, 'housekeeping must normalize to the current lesson status field');
+assert.doesNotMatch(skill, /(?:set|mark) `status: (?:open|triaged|applied|wont-fix)/, 'housekeeping must use lesson_status for triage outcomes');
+assert.match(skill, /do not create new work/i, 'the audit must prevent duplicate work');
+assert.doesNotMatch(skill, /scope: simple.*apply the fix directly/s, 'simple lessons cannot bypass RDC routing');
+mustAppearInOrder(skill, [
+  '### 1. Cluster',
+  '### 2. Resolution audit',
+  '### 3. Architectural report and interview gate',
+  '### 4. Route only still-open, approved work through RDC',
+  '### 5. Complete weekly lessons report',
+], 'housekeeping workflow');
+assert.match(skill, /complete work item/, 'routed work must have a complete work item');
+assert.match(skill, /rdc:fixit/, 'housekeeping must route small work through fixit');
+assert.match(skill, /rdc:fixit` creates and completes the sole work item/, 'fixit must own its single work item');
+assert.match(skill, /rdc:plan` followed by `rdc:build/, 'housekeeping must route larger work through build');
+assert.match(skill, /rdc:review/, 'each lesson action batch must be reviewed');
+assert.match(skill, /dev deployment/, 'deployable work must record dev deployment evidence');
+assert.match(skill, /question-and-answer list/, 'the weekly report must preserve architectural interview answers');
+
+assert.match(guide, /lesson_status: open \| triaged \| applied \| wont-fix/, 'guide schema must match housekeeping');
+mustAppearInOrder(guide, [
+  'Resolution audit before routing',
+  'Architectural report and interview',
+  'RDC routing',
+  'Run `rdc:review`',
+], 'shared lessons guide');
+assert.match(guide, /Do not create an `rdc:fixit`, `rdc:plan`, or `rdc:build` item before this audit/, 'guide must block premature routing');
+
+console.log('housekeeping weekly lessons triage contract - PASS');

package/tests/lessons-pipeline-contract.test.mjs

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(fileURLToPath(new URL('..', import.meta.url)));
+const captureSkills = ['build', 'deploy', 'overnight', 'fixit', 'plan', 'preplan', 'review', 'release', 'collab'];
+
+for (const skill of captureSkills) {
+  const text = readFileSync(join(root, 'skills', skill, 'SKILL.md'), 'utf8');
+  assert.match(text, /lesson_status: open/, `${skill} must capture the canonical status key`);
+  assert.doesNotMatch(text, /and `status` \(`open`/, `${skill} must not emit the legacy status key`);
+}
+
+const guide = readFileSync(join(root, 'guides', 'lessons-learned-spec.md'), 'utf8');
+assert.match(guide, /Legacy status migration/);
+assert.match(guide, /`status` and no `lesson_status`/);
+
+const housekeeping = readFileSync(join(root, 'skills', 'housekeeping', 'SKILL.md'), 'utf8');
+assert.match(housekeeping, /When invoked with `--lessons`, skip every non-lessons maintenance section/);
+assert.match(housekeeping, /including Directory Structure Verification/);
+const legacyNormalization = housekeeping.search(/normalize every\s+legacy lesson that has `status` but no `lesson_status`/i);
+const clustering = housekeeping.search(/### 1\. Cluster/);
+assert.ok(legacyNormalization >= 0 && clustering > legacyNormalization, 'legacy lessons must be normalized before clustering');
+assert.match(housekeeping, /all answers are collected before the first routed fix starts/i);
+
+console.log('lessons pipeline contract test passed');

package/tests/rdc-brochure.test.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const SCRIPT = join(REPO_ROOT, 'scripts', 'rdc-brochure.mjs');
+
+let failures = 0;
+function assert(cond, msg) {
+  if (cond) console.log(`  ✓ ${msg}`);
+  else {
+    failures += 1;
+    console.error(`  ✗ ${msg}`);
+  }
+}
+
+function runBrochure(args, env = {}) {
+  return spawnSync(process.execPath, [SCRIPT, ...args], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      RDC_BROCHURE_COMPOSE_ONLY: '1',
+      ...env,
+    },
+  });
+}
+
+function composedHtmlPath(stdout) {
+  const m = String(stdout || '').match(/^HTML:\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+function crc32(buf) {
+  let crc = 0xffffffff;
+  for (const byte of buf) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function u16(n) {
+  const b = Buffer.alloc(2);
+  b.writeUInt16LE(n);
+  return b;
+}
+
+function u32(n) {
+  const b = Buffer.alloc(4);
+  b.writeUInt32LE(n >>> 0);
+  return b;
+}
+
+function writeStoredZip(zipPath, entryName, content) {
+  const name = Buffer.from(entryName);
+  const body = Buffer.from(content);
+  const crc = crc32(body);
+  const local = Buffer.concat([
+    u32(0x04034b50), u16(20), u16(0), u16(0), u16(0), u16(0),
+    u32(crc), u32(body.length), u32(body.length), u16(name.length), u16(0),
+    name, body,
+  ]);
+  const centralOffset = local.length;
+  const central = Buffer.concat([
+    u32(0x02014b50), u16(20), u16(20), u16(0), u16(0), u16(0), u16(0),
+    u32(crc), u32(body.length), u32(body.length), u16(name.length), u16(0),
+    u16(0), u16(0), u16(0), u32(0), u32(0), name,
+  ]);
+  const end = Buffer.concat([
+    u32(0x06054b50), u16(0), u16(0), u16(1), u16(1),
+    u32(central.length), u32(centralOffset), u16(0),
+  ]);
+  writeFileSync(zipPath, Buffer.concat([local, central, end]));
+}
+
+const root = mkdtempSync(join(tmpdir(), 'rdc-brochure-test-'));
+
+try {
+  console.log('Test 1: folder compose suppresses synthetic headings after YAML front matter');
+  const folder = join(root, 'frontmatter-folder');
+  mkdirSync(folder, { recursive: true });
+  writeFileSync(join(folder, '01-overview.md'), '---\ntitle: Overview\n---\n\n# Real Title\n\nBody.\n', 'utf8');
+  writeFileSync(join(folder, '02-h6.md'), '###### Small Heading\n\nTiny body.\n', 'utf8');
+  const composed = runBrochure([folder]);
+  assert(composed.status === 0, `compose-only folder exits 0 (got ${composed.status})`);
+  const htmlPath = composedHtmlPath(composed.stdout);
+  assert(htmlPath && existsSync(htmlPath), 'compose-only prints a readable HTML path');
+  const html = htmlPath ? readFileSync(htmlPath, 'utf8') : '';
+  assert(!html.includes('<h2>01-overview</h2>'), 'front-matter-led # heading has no duplicate filename h2');
+  assert(!html.includes('<h2>02-h6</h2>'), 'ATX h6 heading has no duplicate filename h2');
+  assert(html.includes('<h1>Real Title</h1>'), 'front-matter body still renders the real h1');
+
+  console.log('Test 2: invalid templates fail for folder and markdown compose paths');
+  const folderBad = runBrochure([folder, '--template', 'missing-template']);
+  assert(folderBad.status !== 0, 'folder compose with invalid template exits non-zero');
+  assert(/unknown template "missing-template"/.test(folderBad.stderr), 'folder compose reports unknown template');
+  assert(/Available template\(s\): studio-default/.test(folderBad.stderr), 'folder compose lists available templates');
+  const mdFile = join(root, 'single.md');
+  writeFileSync(mdFile, '# Single\n\nBody.\n', 'utf8');
+  const mdBad = runBrochure([mdFile, '--template', 'missing-template']);
+  assert(mdBad.status !== 0, 'single markdown compose with invalid template exits non-zero');
+  assert(/unknown template "missing-template"/.test(mdBad.stderr), 'single markdown compose reports unknown template');
+
+  console.log('Test 3: native unzip fallback rejects zip-slip entries before extraction');
+  const zipPath = join(root, 'zip-slip.zip');
+  writeStoredZip(zipPath, '../evil.md', '# Evil\n');
+  const badZip = runBrochure([zipPath], { RDC_BROCHURE_DISABLE_ADM_ZIP: '1' });
+  assert(badZip.status !== 0, 'zip-slip archive exits non-zero');
+  assert(/zip-slip: entry/.test(badZip.stderr), 'zip-slip error is reported');
+  assert(!existsSync(join(root, 'evil.md')), 'zip-slip member was not extracted outside the destination');
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}
+
+if (failures > 0) {
+  console.error(`\nFAILED: ${failures} assertion(s)`);
+  process.exit(1);
+}
+console.log('\nALL PASS');

package/tests/release-contract.test.mjs

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(fileURLToPath(new URL('..', import.meta.url)));
+const release = readFileSync(join(root, 'RELEASE.md'), 'utf8');
+
+assert.match(release, /npm version patch --no-git-tag-version/);
+assert.match(release, /npm view @lifeaitools\/rdc-skills@<version> version/);
+assert.match(release, /npm pack @lifeaitools\/rdc-skills@<version>/);
+assert.match(release, /npm install -g @lifeaitools\/rdc-skills@<version>/);
+assert.match(release, /rdc-skills-install --profile core/);
+assert.match(release, /rdc-skills-install --profile lifeai/);
+
+console.log('release contract test passed');