From 03bb53e05db6bf11d017c1c316e2738d0bf7a29d Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:31 +0800
Subject: [PATCH 1/8] plan: Add project-overview-html-skill plan

Plan for a new sce-project-overview-html skill that renders context/
Markdown into a single self-contained HTML document with Mermaid.js
(CDN) diagrams and inline CSS for human-readable project understanding.

Two-phase staging: T01 hand-authors the skill in the repo-root
.opencode/skills/ active runtime tree for manual OpenCode testing; T02-T07
promote the validated body into the canonical Pkl pipeline, regenerate
all three target trees, and update context discoverability.

Affected plan: project-overview-html-skill
Task IDs: T01, T02, T03, T04, T05, T06, T07 (all status:todo)

Co-authored-by: SCE <sce@crocoder.dev>
---
 context/plans/project-overview-html-skill.md | 102 +++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 context/plans/project-overview-html-skill.md

diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
new file mode 100644
index 00000000..f4f8bd6d
--- /dev/null
+++ b/context/plans/project-overview-html-skill.md
@@ -0,0 +1,102 @@
+# Plan: project-overview-html-skill
+
+## Change summary
+
+Add a new SCE skill `sce-project-overview-html` that generates a single self-contained HTML document from the project's `context/` Markdown files, helping a human reader quickly understand the project and how it works. The HTML embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes CSS styling for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored).
+
+This plan uses a two-phase staging approach:
+- **Phase 1 (T01):** Hand-author the skill directly in the repo-root `.opencode/skills/` active runtime tree so the user can manually test it with OpenCode immediately.
+- **Phase 2 (T02–T07):** Once manually validated, promote the skill into the canonical Pkl source layer, register it across all metadata/renderers, regenerate the generated config trees, update context discoverability, and validate.
+
+## Success criteria
+
+- A new skill `sce-project-overview-html` exists in the repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` and is manually testable via OpenCode (Phase 1).
+- The skill is promoted to canonical Pkl sources and generated into all three target trees (manual OpenCode, automated OpenCode, Claude) with parity verified (Phase 2).
+- The skill body instructs the agent to read `context/overview.md`, `context/architecture.md`, `context/patterns.md`, `context/glossary.md`, and `context/context-map.md`, plus any linked domain files referenced in `context-map.md`, and render them into a single self-contained HTML document.
+- The generated HTML includes:
+  - Embedded Mermaid.js (CDN `<script>`) so existing Mermaid blocks in context render in-browser.
+  - Inline CSS for readable typography, section navigation, code block styling, and responsive layout.
+  - Sectioned content (Overview, Architecture, Patterns, Glossary, Context Map) with anchor navigation.
+  - Mermaid diagram blocks preserved as `<pre class="mermaid">` so the client-side library renders them.
+- Output is written to `context/tmp/project-overview.html` (disposable, gitignored by existing `context/tmp/.gitignore`).
+- `nix run .#pkl-check-generated` passes (generated outputs match canonical Pkl sources).
+- `nix flake check` passes.
+- The skill is invocable by the Shared Context Code agent (registered in its `skill:` permission allowlist in both manual and automated OpenCode metadata).
+- `context/context-map.md` is updated with a discoverability link to the new skill's canonical description (in `context/sce/`).
+
+## Constraints and non-goals
+
+- **Source of truth is `context/` only.** The skill does not scan or analyze application code. It renders the current-state context memory into HTML.
+- **No new runtime dependencies.** Mermaid.js is loaded from CDN at view time; no vendoring, no build step, no Node tooling added to the repo.
+- **No new CLI command.** This is a skill, not a `sce` subcommand. It is invoked via the Shared Context Code agent loading the skill.
+- **Output is disposable.** `context/tmp/project-overview.html` is regenerated on demand and is not committed (covered by existing `context/tmp/.gitignore` with `*` ignore).
+- **No offline support in this plan.** Mermaid.js CDN requires internet to view diagrams. Vendoring/offline is a non-goal for this iteration.
+- **No pre-rendering to SVG.** No `mermaid-cli` or headless browser build dependency is introduced.
+- **No code scanning or enrichment beyond context/.** If context is stale, the HTML reflects stale context; the skill should note this in its instructions but not attempt to repair context (that is `sce-context-sync`'s job).
+- **No changes to the `sce` Rust CLI.** This plan touches only the repo-root `.opencode/skills/` tree (Phase 1), Pkl sources, generated config outputs, and context files (Phase 2).
+- **Phase 1 does not touch `config/.opencode/`.** The repo-root `.opencode/skills/` is the active runtime tree; `config/.opencode/skills/` is Pkl-generated and is only updated in Phase 2 via regeneration. Phase 1 and Phase 2 must not both edit the same generated path by hand.
+
+## Task stack
+
+### Phase 1 — Stage skill in active runtime tree for manual testing
+
+- [ ] T01: `Create sce-project-overview-html skill in repo-root .opencode/skills/` (status:todo)
+  - Task ID: T01
+  - Goal: Hand-author `.opencode/skills/sce-project-overview-html/SKILL.md` with OpenCode skill frontmatter (`name`, `description`, `compatibility: opencode`) and the full skill body (when to use, source files to read, HTML structure contract, Mermaid.js CDN embedding, inline CSS guidance, output path `context/tmp/project-overview.html`, disposable-output note, stale-context caveat). This makes the skill immediately loadable and testable by OpenCode in this repo.
+  - Boundaries (in/out of scope): In - new `.opencode/skills/sce-project-overview-html/SKILL.md` file only. Out - `config/.opencode/` generated tree (Phase 2), Pkl sources (Phase 2), metadata files (Phase 2), context files (Phase 2). Do not edit any other `.opencode/` files.
+  - Done when: `.opencode/skills/sce-project-overview-html/SKILL.md` exists with valid frontmatter and the complete skill body; OpenCode can discover the skill (visible in skill list / invocable).
+  - Verification notes (commands or checks): `ls .opencode/skills/sce-project-overview-html/SKILL.md`; `head -6 .opencode/skills/sce-project-overview-html/SKILL.md` shows correct frontmatter; user manually invokes the skill in OpenCode and confirms it produces `context/tmp/project-overview.html`.
+  - **Manual test gate:** Do not start T02 until the user confirms the skill works as expected in OpenCode.
+
+### Phase 2 — Promote skill to canonical Pkl pipeline
+
+- [ ] T02: `Author sce-project-overview-html skill body in shared-content-code.pkl` (status:todo)
+  - Task ID: T02
+  - Goal: Add the `sce-project-overview-html` skill `UnitSpec` (title + canonicalBody) to the `skills` Mapping in `config/pkl/base/shared-content-code.pkl`, and the mirrored entry in `config/pkl/base/shared-content-automated-code.pkl`. Use the skill body validated in T01 as the canonical source.
+  - Boundaries (in/out of scope): In - new `UnitSpec` entry in both manual and automated code Pkl modules. Out - aggregation surface changes (T03), metadata registration (T04), generated output regeneration (T05), context-map update (T06).
+  - Done when: Both `shared-content-code.pkl` and `shared-content-automated-code.pkl` contain a `["sce-project-overview-html"]` entry in their `skills` Mapping with identical `title` and `canonicalBody` (skill body is shared between profiles; only agent permission/metadata differs).
+  - Verification notes (commands or checks): `grep -n 'sce-project-overview-html' config/pkl/base/shared-content-code.pkl config/pkl/base/shared-content-automated-code.pkl` returns the new entry in both files; diff of the two `canonicalBody` strings shows identical content.
+
+- [ ] T03: `Register skill in shared-content aggregation surfaces` (status:todo)
+  - Task ID: T03
+  - Goal: Add `["sce-project-overview-html"]` entries to the `skills` Mapping in both `config/pkl/base/shared-content.pkl` (manual) and `config/pkl/base/shared-content-automated.pkl` (automated), referencing the new `UnitSpec` from `code.skills["sce-project-overview-html"]`.
+  - Boundaries (in/out of scope): In - the two aggregation surface Pkl files. Out - renderer files (T04), Pkl regeneration (T05).
+  - Done when: Both aggregation files contain a `["sce-project-overview-html"]` entry in `skills` that references `code.skills["sce-project-overview-html"]` with `id = "skill.sce-project-overview-html"`, `kind = "skill"`, `slug = "sce-project-overview-html"`, and the correct `title`/`canonicalBody` forwarding.
+  - Verification notes (commands or checks): `grep -n 'sce-project-overview-html' config/pkl/base/shared-content.pkl config/pkl/base/shared-content-automated.pkl` returns the new entry in both files.
+
+- [ ] T04: `Register skill descriptions and permissions in all four metadata files` (status:todo)
+  - Task ID: T04
+  - Goal: Add the `sce-project-overview-html` description to `skillDescriptions` in all four metadata files (`config/pkl/renderers/opencode-metadata.pkl`, `config/pkl/renderers/opencode-automated-metadata.pkl`, `config/pkl/renderers/claude-metadata.pkl`, `config/pkl/renderers/common.pkl`) and add `sce-project-overview-html` to the Shared Context Code agent `skill:` allowlist in both `opencode-metadata.pkl` and `opencode-automated-metadata.pkl` permission blocks.
+  - Boundaries (in/out of scope): In - the four metadata/renderer files plus the Shared Context Code permission allowlists. Out - skill body content (T02), aggregation (T03), regeneration (T05).
+  - Done when: All four metadata files have a `["sce-project-overview-html"]` entry in `skillDescriptions`; both OpenCode metadata files list `"sce-project-overview-html": allow` under the `shared-context-code` agent's `skill:` block; `common.pkl` `skillDescriptions` Mapping includes the new slug.
+  - Verification notes (commands or checks): `grep -n 'sce-project-overview-html' config/pkl/renderers/opencode-metadata.pkl config/pkl/renderers/opencode-automated-metadata.pkl config/pkl/renderers/claude-metadata.pkl config/pkl/renderers/common.pkl` returns entries in all four files; `grep -A2 'sce-project-overview-html' config/pkl/renderers/opencode-metadata.pkl` shows it under the `shared-context-code` permission block.
+
+- [ ] T05: `Regenerate generated config outputs and verify parity` (status:todo)
+  - Task ID: T05
+  - Goal: Run `nix develop -c pkl eval -m . config/pkl/generate.pkl` to regenerate `config/.opencode/skills/sce-project-overview-html/SKILL.md`, `config/automated/.opencode/skills/sce-project-overview-html/SKILL.md`, and `config/.claude/skills/sce-project-overview-html/SKILL.md`, then verify parity with `nix run .#pkl-check-generated`. Also sync the repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` with the regenerated `config/.opencode/` version so the active runtime tree matches the canonical generated output.
+  - Boundaries (in/out of scope): In - running Pkl regeneration, the parity check, and syncing the repo-root `.opencode/skills/` copy with the regenerated `config/.opencode/skills/` output. Out - editing generated files by hand (generated trees are build artifacts), editing Pkl sources (covered by T02-T04).
+  - Done when: `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` and exits 0; the three generated `SKILL.md` files exist with correct frontmatter (`name`, `description`, `compatibility`) and the authored body; the repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` matches `config/.opencode/skills/sce-project-overview-html/SKILL.md`.
+  - Verification notes (commands or checks): `nix run .#pkl-check-generated`; `ls config/.opencode/skills/sce-project-overview-html/SKILL.md config/automated/.opencode/skills/sce-project-overview-html/SKILL.md config/.claude/skills/sce-project-overview-html/SKILL.md`; `diff .opencode/skills/sce-project-overview-html/SKILL.md config/.opencode/skills/sce-project-overview-html/SKILL.md` shows no differences.
+
+- [ ] T06: `Update context-map.md with new skill discoverability link` (status:todo)
+  - Task ID: T06
+  - Goal: Add a `context/sce/project-overview-html-skill.md` domain file describing the new skill's current-state contract, and add a discoverability link to it in `context/context-map.md` under the SCE working-area or feature/domain section.
+  - Boundaries (in/out of scope): In - new `context/sce/project-overview-html-skill.md` file and one new bullet in `context/context-map.md`. Out - editing other context files, editing `context/overview.md` (this is a localized skill addition, verify-only for root context per `sce-context-sync` gating).
+  - Done when: `context/sce/project-overview-html-skill.md` exists with a concise current-state description of the skill (purpose, source files, output path, Mermaid.js CDN dependency, disposable-output policy); `context/context-map.md` contains a bullet linking to it.
+  - Verification notes (commands or checks): `ls context/sce/project-overview-html-skill.md`; `grep -n 'project-overview-html' context/context-map.md`.
+
+- [ ] T07: `Validation and cleanup` (status:todo)
+  - Task ID: T07
+  - Goal: Run full repo validation (`nix flake check`), confirm all success criteria are met, and verify no stray temporary artifacts were left behind.
+  - Boundaries (in/out of scope): In - `nix flake check`, success-criteria walkthrough, cleanup of any `context/tmp/` scratch files produced during planning/testing. Out - new code or context edits beyond cleanup.
+  - Done when: `nix flake check` passes; each success criterion above has concrete evidence (command output or file path); no unexpected files exist under `context/tmp/` other than `.gitignore`.
+  - Verification notes (commands or checks): `nix flake check`; `git status` shows only intended changes (repo-root `.opencode/skills/` new file, Pkl sources, generated config, new context file, updated context-map).
+
+## Open questions
+
+None. All blocking ambiguities were resolved during the clarification gate:
+- Source of truth: `context/` files only.
+- Output location: `context/tmp/project-overview.html` (disposable, gitignored).
+- Diagram rendering: Mermaid.js client-side via CDN.
+- Skill ownership: Shared Context Code agent.
+- Staging: Phase 1 in repo-root `.opencode/skills/` for manual testing, Phase 2 promotes to Pkl canonical pipeline.
\ No newline at end of file

From a04e8baa51ac546282457c9ce9fe58642a9d1cf2 Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:31 +0800
Subject: [PATCH 2/8] skills: Add sce-project-overview-html skill to repo-root
 .opencode/skills/

Stage the new sce-project-overview-html skill in the active runtime tree
for manual OpenCode testing (Phase 1). The skill reads the project's
context/ Markdown files and renders them into a single self-contained
HTML document with Mermaid.js embedded via CDN and inline CSS, writing
output to context/tmp/project-overview.html (disposable, gitignored).

Plan: project-overview-html-skill
Task: T01

Co-authored-by: SCE <sce@crocoder.dev>
---
 .../skills/sce-project-overview-html/SKILL.md | 127 ++++++++++++++++++
 context/plans/project-overview-html-skill.md  |   7 +-
 2 files changed, 133 insertions(+), 1 deletion(-)
 create mode 100644 .opencode/skills/sce-project-overview-html/SKILL.md

diff --git a/.opencode/skills/sce-project-overview-html/SKILL.md b/.opencode/skills/sce-project-overview-html/SKILL.md
new file mode 100644
index 00000000..92fbef1d
--- /dev/null
+++ b/.opencode/skills/sce-project-overview-html/SKILL.md
@@ -0,0 +1,127 @@
+---
+name: sce-project-overview-html
+description: |
+  Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document.
+compatibility: opencode
+---
+
+## What I do
+- Read the project's `context/` Markdown files.
+- Render them into a single self-contained HTML document.
+- Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
+- Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
+
+## When to use
+- Use when the user asks for a project overview as HTML, a readable summary page, or a shareable walkthrough of the project's shared context memory.
+- Trigger phrases include "generate project overview HTML", "project overview as a page", "render context to HTML", "make a project summary page", or "build a project walkthrough".
+
+## Source of truth
+- The source of truth is `context/` only. This skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is.
+
+## How to run this
+
+1. **Read the root context files** - read these five files in order:
+   - `context/overview.md`
+   - `context/architecture.md`
+   - `context/patterns.md`
+   - `context/glossary.md`
+   - `context/context-map.md`
+
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file so its content can be included in the HTML.
+
+3. **Build the HTML document** - assemble a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below.
+
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html`. Create the `context/tmp/` directory if it does not exist.
+
+5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
+
+## HTML structure contract
+
+The generated HTML must be a single self-contained document with this structure:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{project_name} — Project Overview</title>
+  <style>
+    /* Inline CSS — see CSS guidance below */
+  </style>
+</head>
+<body>
+  <nav id="toc">
+    <!-- Anchor navigation linking to each section -->
+  </nav>
+  <main>
+    <section id="overview"><!-- rendered context/overview.md --></section>
+    <section id="architecture"><!-- rendered context/architecture.md --></section>
+    <section id="patterns"><!-- rendered context/patterns.md --></section>
+    <section id="glossary"><!-- rendered context/glossary.md --></section>
+    <section id="context-map"><!-- rendered context/context-map.md --></section>
+    <!-- One <section> per linked domain file, with an id derived from its path -->
+  </main>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+```
+
+### Section ordering
+1. Overview
+2. Architecture
+3. Patterns
+4. Glossary
+5. Context Map
+6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
+
+### Markdown-to-HTML rendering
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes).
+- Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
+- Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
+- Generate heading anchors (`id` attributes) from heading text for in-page navigation.
+
+### Anchor navigation
+- Build a table-of-contents `<nav id="toc">` with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+- Use relative anchor links (`#section-id`).
+
+## CSS guidance
+
+Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
+
+- Readable typography: system font stack, comfortable line-height, max-width content column.
+- Section navigation: sticky/fixed table of contents or top-anchored nav with clear link styling.
+- Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
+- Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
+- Responsive layout: viewport meta tag, fluid widths, readable on narrow and wide screens.
+- Heading hierarchy: clear visual distinction between h1/h2/h3.
+
+Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
+
+## Mermaid.js embedding
+- Load Mermaid.js from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialize with `mermaid.initialize({ startOnLoad: true })` after the script tag.
+- Preserve existing Mermaid fenced blocks in context as `<pre class="mermaid">...</pre>` so the library renders them in-browser.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view.
+
+## Output path
+- Write to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand; it is not committed.
+
+## Stale-context caveat
+- This skill renders `context/` as-is. If context is stale or drifts from code, the HTML reflects stale context.
+- Do not attempt to repair context here — that is `sce-context-sync`'s job.
+- If you notice context drift while running this skill, note it to the user and recommend running `sce-context-sync`.
+
+## Expected output
+- A single self-contained HTML file at `context/tmp/project-overview.html` containing all five root context files plus linked domain files, with Mermaid.js embedded via CDN and inline CSS.
+- A short report to the user stating the absolute output path and the disposable-output policy.
+
+## Related skills
+- `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
\ No newline at end of file
diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
index f4f8bd6d..b5549e29 100644
--- a/context/plans/project-overview-html-skill.md
+++ b/context/plans/project-overview-html-skill.md
@@ -40,13 +40,18 @@ This plan uses a two-phase staging approach:
 
 ### Phase 1 — Stage skill in active runtime tree for manual testing
 
-- [ ] T01: `Create sce-project-overview-html skill in repo-root .opencode/skills/` (status:todo)
+- [x] T01: `Create sce-project-overview-html skill in repo-root .opencode/skills/` (status:done)
   - Task ID: T01
   - Goal: Hand-author `.opencode/skills/sce-project-overview-html/SKILL.md` with OpenCode skill frontmatter (`name`, `description`, `compatibility: opencode`) and the full skill body (when to use, source files to read, HTML structure contract, Mermaid.js CDN embedding, inline CSS guidance, output path `context/tmp/project-overview.html`, disposable-output note, stale-context caveat). This makes the skill immediately loadable and testable by OpenCode in this repo.
   - Boundaries (in/out of scope): In - new `.opencode/skills/sce-project-overview-html/SKILL.md` file only. Out - `config/.opencode/` generated tree (Phase 2), Pkl sources (Phase 2), metadata files (Phase 2), context files (Phase 2). Do not edit any other `.opencode/` files.
   - Done when: `.opencode/skills/sce-project-overview-html/SKILL.md` exists with valid frontmatter and the complete skill body; OpenCode can discover the skill (visible in skill list / invocable).
   - Verification notes (commands or checks): `ls .opencode/skills/sce-project-overview-html/SKILL.md`; `head -6 .opencode/skills/sce-project-overview-html/SKILL.md` shows correct frontmatter; user manually invokes the skill in OpenCode and confirms it produces `context/tmp/project-overview.html`.
   - **Manual test gate:** Do not start T02 until the user confirms the skill works as expected in OpenCode.
+  - **Status:** done
+  - **Completed:** 2026-07-01
+  - **Files changed:** `.opencode/skills/sce-project-overview-html/SKILL.md` (new)
+  - **Evidence:** `ls` confirms file exists; `head -6` shows valid frontmatter (`name`, `description`, `compatibility: opencode`); `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` (repo-root `.opencode/skills/` is not part of generated parity); `git status` shows only the new untracked skill directory.
+  - **Notes:** Skill body follows the same frontmatter shape and section structure (`What I do` / `When to use` / `How to run this` / `Expected output` / `Related skills`) as existing repo-root skills. Awaiting user manual test confirmation before T02.
 
 ### Phase 2 — Promote skill to canonical Pkl pipeline
 

From 04498eddbf6873344eba7918d0b81a7c2b88997c Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:31 +0800
Subject: [PATCH 3/8] skills: Direct-author HTML and use left sidebar in
 sce-project-overview-html

Revise the sce-project-overview-html skill after manual-test feedback
so the agent reads context files and writes the HTML directly with its
own file tools instead of generating a conversion script, and move the
table of contents to a left-side navigation sidebar with a flexbox
two-column layout and responsive collapse for narrow viewports.

Plan: project-overview-html-skill
Task: T01

Co-authored-by: SCE <sce@crocoder.dev>
---
 .../skills/sce-project-overview-html/SKILL.md | 55 +++++++++++--------
 context/plans/project-overview-html-skill.md  |  6 +-
 2 files changed, 35 insertions(+), 26 deletions(-)

diff --git a/.opencode/skills/sce-project-overview-html/SKILL.md b/.opencode/skills/sce-project-overview-html/SKILL.md
index 92fbef1d..a0cd455a 100644
--- a/.opencode/skills/sce-project-overview-html/SKILL.md
+++ b/.opencode/skills/sce-project-overview-html/SKILL.md
@@ -6,8 +6,8 @@ compatibility: opencode
 ---
 
 ## What I do
-- Read the project's `context/` Markdown files.
-- Render them into a single self-contained HTML document.
+- Read the project's `context/` Markdown files with my own file-read tool.
+- Author a single self-contained HTML document directly with my own file-write tool — I do NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline). I write the HTML myself.
 - Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
 - Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
 
@@ -21,24 +21,24 @@ compatibility: opencode
 
 ## How to run this
 
-1. **Read the root context files** - read these five files in order:
+1. **Read the root context files** - read these five files in order using your file-read tool:
    - `context/overview.md`
    - `context/architecture.md`
    - `context/patterns.md`
    - `context/glossary.md`
    - `context/context-map.md`
 
-2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file so its content can be included in the HTML.
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file with your file-read tool so its content can be included in the HTML.
 
-3. **Build the HTML document** - assemble a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below.
+3. **Author the HTML document yourself** - using your own file-write tool, write a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below. Convert the Markdown content to HTML body markup yourself as you write the file. Do NOT generate, scaffold, or execute any conversion script (no Python, no Node, no shell, no build step). You are the renderer: read the Markdown, then write the equivalent HTML directly.
 
-4. **Write the output** - write the HTML to `context/tmp/project-overview.html`. Create the `context/tmp/` directory if it does not exist.
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html` with your file-write tool. Create the `context/tmp/` directory if it does not exist.
 
 5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
 
 ## HTML structure contract
 
-The generated HTML must be a single self-contained document with this structure:
+The generated HTML must be a single self-contained document with a left-side navigation sidebar and the main content to its right. Use this structure:
 
 ```html
 <!DOCTYPE html>
@@ -52,17 +52,19 @@ The generated HTML must be a single self-contained document with this structure:
   </style>
 </head>
 <body>
-  <nav id="toc">
-    <!-- Anchor navigation linking to each section -->
-  </nav>
-  <main>
-    <section id="overview"><!-- rendered context/overview.md --></section>
-    <section id="architecture"><!-- rendered context/architecture.md --></section>
-    <section id="patterns"><!-- rendered context/patterns.md --></section>
-    <section id="glossary"><!-- rendered context/glossary.md --></section>
-    <section id="context-map"><!-- rendered context/context-map.md --></section>
-    <!-- One <section> per linked domain file, with an id derived from its path -->
-  </main>
+  <div class="layout">
+    <nav id="toc" class="sidebar">
+      <!-- Left-side anchor navigation linking to each section -->
+    </nav>
+    <main class="content">
+      <section id="overview"><!-- rendered context/overview.md --></section>
+      <section id="architecture"><!-- rendered context/architecture.md --></section>
+      <section id="patterns"><!-- rendered context/patterns.md --></section>
+      <section id="glossary"><!-- rendered context/glossary.md --></section>
+      <section id="context-map"><!-- rendered context/context-map.md --></section>
+      <!-- One <section> per linked domain file, with an id derived from its path -->
+    </main>
+  </div>
   <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
   <script>
     mermaid.initialize({ startOnLoad: true });
@@ -80,24 +82,31 @@ The generated HTML must be a single self-contained document with this structure:
 6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
 
 ### Markdown-to-HTML rendering
-- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes).
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) yourself as you write the file. You are the renderer — do not delegate this to a script.
 - Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
 - Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
 - Generate heading anchors (`id` attributes) from heading text for in-page navigation.
 
-### Anchor navigation
-- Build a table-of-contents `<nav id="toc">` with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+### Anchor navigation (left sidebar)
+- Build a table-of-contents `<nav id="toc" class="sidebar">` placed on the left side of the layout with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
 - Use relative anchor links (`#section-id`).
+- The sidebar stays visible while the main content scrolls (sticky/fixed positioning).
 
 ## CSS guidance
 
 Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
 
+- **Left-sidebar layout:** use a flexbox (or CSS grid) two-column layout — a fixed-width left sidebar (`<nav id="toc" class="sidebar">`) and a flexible main content area (`.content`) to its right. Example skeleton:
+  ```css
+  .layout { display: flex; min-height: 100vh; }
+  .sidebar { width: 260px; position: sticky; top: 0; align-self: flex-start; height: 100vh; overflow-y: auto; }
+  .content { flex: 1; max-width: 900px; margin: 0 auto; padding: 0 1.5rem; }
+  ```
+- **Responsive collapse:** on narrow viewports (e.g. `@media (max-width: 768px)`), collapse the sidebar to the top or hide it behind a toggle so the page stays readable on mobile.
 - Readable typography: system font stack, comfortable line-height, max-width content column.
-- Section navigation: sticky/fixed table of contents or top-anchored nav with clear link styling.
+- Section navigation: clear link styling in the sidebar, highlight/active states optional.
 - Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
 - Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
-- Responsive layout: viewport meta tag, fluid widths, readable on narrow and wide screens.
 - Heading hierarchy: clear visual distinction between h1/h2/h3.
 
 Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
index b5549e29..4aeee56e 100644
--- a/context/plans/project-overview-html-skill.md
+++ b/context/plans/project-overview-html-skill.md
@@ -48,10 +48,10 @@ This plan uses a two-phase staging approach:
   - Verification notes (commands or checks): `ls .opencode/skills/sce-project-overview-html/SKILL.md`; `head -6 .opencode/skills/sce-project-overview-html/SKILL.md` shows correct frontmatter; user manually invokes the skill in OpenCode and confirms it produces `context/tmp/project-overview.html`.
   - **Manual test gate:** Do not start T02 until the user confirms the skill works as expected in OpenCode.
   - **Status:** done
-  - **Completed:** 2026-07-01
-  - **Files changed:** `.opencode/skills/sce-project-overview-html/SKILL.md` (new)
+  - **Completed:** 2026-07-01 (revised 2026-07-02)
+  - **Files changed:** `.opencode/skills/sce-project-overview-html/SKILL.md` (new, then revised)
   - **Evidence:** `ls` confirms file exists; `head -6` shows valid frontmatter (`name`, `description`, `compatibility: opencode`); `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` (repo-root `.opencode/skills/` is not part of generated parity); `git status` shows only the new untracked skill directory.
-  - **Notes:** Skill body follows the same frontmatter shape and section structure (`What I do` / `When to use` / `How to run this` / `Expected output` / `Related skills`) as existing repo-root skills. Awaiting user manual test confirmation before T02.
+  - **Notes:** Skill body follows the same frontmatter shape and section structure (`What I do` / `When to use` / `How to run this` / `Expected output` / `Related skills`) as existing repo-root skills. Revised after user feedback: skill now explicitly instructs the agent to author the HTML directly with its own file tools (no Python/conversion script generation) and uses a left-side navigation sidebar layout. Awaiting user manual test confirmation before T02.
 
 ### Phase 2 — Promote skill to canonical Pkl pipeline
 

From ef9e46d910e4ab6b13454f83fe1cfa819aae5c2c Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:31 +0800
Subject: [PATCH 4/8] pkl: Add sce-project-overview-html skill UnitSpec to code
 content modules

Add the new sce-project-overview-html skill UnitSpec (title +
canonicalBody) to the skills Mapping in both
shared-content-code.pkl (manual profile) and
shared-content-automated-code.pkl (automated profile), using the
skill body validated in T01 as the canonical source. The two
canonicalBody strings are byte-identical; the skill body is shared
between profiles, with only agent permission/metadata differing
(to be wired in later tasks).

The new entry is placed last in each skills Mapping (after
sce-validation) to preserve existing ordering. Generated outputs
remain unchanged because aggregation surfaces and metadata
registration are owned by subsequent tasks (T03-T05).

Plan: project-overview-html-skill
Task: T02

Co-authored-by: SCE <sce@crocoder.dev>
---
 .../base/shared-content-automated-code.pkl    | 134 ++++++++++++++++++
 config/pkl/base/shared-content-code.pkl       | 134 ++++++++++++++++++
 context/plans/project-overview-html-skill.md  |   7 +-
 3 files changed, 274 insertions(+), 1 deletion(-)

diff --git a/config/pkl/base/shared-content-automated-code.pkl b/config/pkl/base/shared-content-automated-code.pkl
index 30317b42..1d0015f9 100644
--- a/config/pkl/base/shared-content-automated-code.pkl
+++ b/config/pkl/base/shared-content-automated-code.pkl
@@ -277,6 +277,140 @@ Write to `context/plans/{plan_name}.md` including:
 ### Residual risks
 - None identified.
 ```
+"""
+  }
+  ["sce-project-overview-html"] = new UnitSpec {
+    title = "SCE Project Overview HTML"
+    canonicalBody = """
+## What I do
+- Read the project's `context/` Markdown files with my own file-read tool.
+- Author a single self-contained HTML document directly with my own file-write tool — I do NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline). I write the HTML myself.
+- Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
+- Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
+
+## When to use
+- Use when the user asks for a project overview as HTML, a readable summary page, or a shareable walkthrough of the project's shared context memory.
+- Trigger phrases include "generate project overview HTML", "project overview as a page", "render context to HTML", "make a project summary page", or "build a project walkthrough".
+
+## Source of truth
+- The source of truth is `context/` only. This skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is.
+
+## How to run this
+
+1. **Read the root context files** - read these five files in order using your file-read tool:
+   - `context/overview.md`
+   - `context/architecture.md`
+   - `context/patterns.md`
+   - `context/glossary.md`
+   - `context/context-map.md`
+
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file with your file-read tool so its content can be included in the HTML.
+
+3. **Author the HTML document yourself** - using your own file-write tool, write a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below. Convert the Markdown content to HTML body markup yourself as you write the file. Do NOT generate, scaffold, or execute any conversion script (no Python, no Node, no shell, no build step). You are the renderer: read the Markdown, then write the equivalent HTML directly.
+
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html` with your file-write tool. Create the `context/tmp/` directory if it does not exist.
+
+5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
+
+## HTML structure contract
+
+The generated HTML must be a single self-contained document with a left-side navigation sidebar and the main content to its right. Use this structure:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{project_name} — Project Overview</title>
+  <style>
+    /* Inline CSS — see CSS guidance below */
+  </style>
+</head>
+<body>
+  <div class="layout">
+    <nav id="toc" class="sidebar">
+      <!-- Left-side anchor navigation linking to each section -->
+    </nav>
+    <main class="content">
+      <section id="overview"><!-- rendered context/overview.md --></section>
+      <section id="architecture"><!-- rendered context/architecture.md --></section>
+      <section id="patterns"><!-- rendered context/patterns.md --></section>
+      <section id="glossary"><!-- rendered context/glossary.md --></section>
+      <section id="context-map"><!-- rendered context/context-map.md --></section>
+      <!-- One <section> per linked domain file, with an id derived from its path -->
+    </main>
+  </div>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+```
+
+### Section ordering
+1. Overview
+2. Architecture
+3. Patterns
+4. Glossary
+5. Context Map
+6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
+
+### Markdown-to-HTML rendering
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) yourself as you write the file. You are the renderer — do not delegate this to a script.
+- Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
+- Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
+- Generate heading anchors (`id` attributes) from heading text for in-page navigation.
+
+### Anchor navigation (left sidebar)
+- Build a table-of-contents `<nav id="toc" class="sidebar">` placed on the left side of the layout with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+- Use relative anchor links (`#section-id`).
+- The sidebar stays visible while the main content scrolls (sticky/fixed positioning).
+
+## CSS guidance
+
+Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
+
+- **Left-sidebar layout:** use a flexbox (or CSS grid) two-column layout — a fixed-width left sidebar (`<nav id="toc" class="sidebar">`) and a flexible main content area (`.content`) to its right. Example skeleton:
+  ```css
+  .layout { display: flex; min-height: 100vh; }
+  .sidebar { width: 260px; position: sticky; top: 0; align-self: flex-start; height: 100vh; overflow-y: auto; }
+  .content { flex: 1; max-width: 900px; margin: 0 auto; padding: 0 1.5rem; }
+  ```
+- **Responsive collapse:** on narrow viewports (e.g. `@media (max-width: 768px)`), collapse the sidebar to the top or hide it behind a toggle so the page stays readable on mobile.
+- Readable typography: system font stack, comfortable line-height, max-width content column.
+- Section navigation: clear link styling in the sidebar, highlight/active states optional.
+- Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
+- Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
+- Heading hierarchy: clear visual distinction between h1/h2/h3.
+
+Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
+
+## Mermaid.js embedding
+- Load Mermaid.js from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialize with `mermaid.initialize({ startOnLoad: true })` after the script tag.
+- Preserve existing Mermaid fenced blocks in context as `<pre class="mermaid">...</pre>` so the library renders them in-browser.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view.
+
+## Output path
+- Write to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand; it is not committed.
+
+## Stale-context caveat
+- This skill renders `context/` as-is. If context is stale or drifts from code, the HTML reflects stale context.
+- Do not attempt to repair context here — that is `sce-context-sync`'s job.
+- If you notice context drift while running this skill, note it to the user and recommend running `sce-context-sync`.
+
+## Expected output
+- A single self-contained HTML file at `context/tmp/project-overview.html` containing all five root context files plus linked domain files, with Mermaid.js embedded via CDN and inline CSS.
+- A short report to the user stating the absolute output path and the disposable-output policy.
+
+## Related skills
+- `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
 """
   }
 }
\ No newline at end of file
diff --git a/config/pkl/base/shared-content-code.pkl b/config/pkl/base/shared-content-code.pkl
index 682dfcec..ba64a949 100644
--- a/config/pkl/base/shared-content-code.pkl
+++ b/config/pkl/base/shared-content-code.pkl
@@ -290,6 +290,140 @@ Write to `context/plans/{plan_name}.md` including:
 ### Residual risks
 - None identified.
 ```
+"""
+  }
+  ["sce-project-overview-html"] = new UnitSpec {
+    title = "SCE Project Overview HTML"
+    canonicalBody = """
+## What I do
+- Read the project's `context/` Markdown files with my own file-read tool.
+- Author a single self-contained HTML document directly with my own file-write tool — I do NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline). I write the HTML myself.
+- Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
+- Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
+
+## When to use
+- Use when the user asks for a project overview as HTML, a readable summary page, or a shareable walkthrough of the project's shared context memory.
+- Trigger phrases include "generate project overview HTML", "project overview as a page", "render context to HTML", "make a project summary page", or "build a project walkthrough".
+
+## Source of truth
+- The source of truth is `context/` only. This skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is.
+
+## How to run this
+
+1. **Read the root context files** - read these five files in order using your file-read tool:
+   - `context/overview.md`
+   - `context/architecture.md`
+   - `context/patterns.md`
+   - `context/glossary.md`
+   - `context/context-map.md`
+
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file with your file-read tool so its content can be included in the HTML.
+
+3. **Author the HTML document yourself** - using your own file-write tool, write a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below. Convert the Markdown content to HTML body markup yourself as you write the file. Do NOT generate, scaffold, or execute any conversion script (no Python, no Node, no shell, no build step). You are the renderer: read the Markdown, then write the equivalent HTML directly.
+
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html` with your file-write tool. Create the `context/tmp/` directory if it does not exist.
+
+5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
+
+## HTML structure contract
+
+The generated HTML must be a single self-contained document with a left-side navigation sidebar and the main content to its right. Use this structure:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{project_name} — Project Overview</title>
+  <style>
+    /* Inline CSS — see CSS guidance below */
+  </style>
+</head>
+<body>
+  <div class="layout">
+    <nav id="toc" class="sidebar">
+      <!-- Left-side anchor navigation linking to each section -->
+    </nav>
+    <main class="content">
+      <section id="overview"><!-- rendered context/overview.md --></section>
+      <section id="architecture"><!-- rendered context/architecture.md --></section>
+      <section id="patterns"><!-- rendered context/patterns.md --></section>
+      <section id="glossary"><!-- rendered context/glossary.md --></section>
+      <section id="context-map"><!-- rendered context/context-map.md --></section>
+      <!-- One <section> per linked domain file, with an id derived from its path -->
+    </main>
+  </div>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+```
+
+### Section ordering
+1. Overview
+2. Architecture
+3. Patterns
+4. Glossary
+5. Context Map
+6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
+
+### Markdown-to-HTML rendering
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) yourself as you write the file. You are the renderer — do not delegate this to a script.
+- Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
+- Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
+- Generate heading anchors (`id` attributes) from heading text for in-page navigation.
+
+### Anchor navigation (left sidebar)
+- Build a table-of-contents `<nav id="toc" class="sidebar">` placed on the left side of the layout with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+- Use relative anchor links (`#section-id`).
+- The sidebar stays visible while the main content scrolls (sticky/fixed positioning).
+
+## CSS guidance
+
+Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
+
+- **Left-sidebar layout:** use a flexbox (or CSS grid) two-column layout — a fixed-width left sidebar (`<nav id="toc" class="sidebar">`) and a flexible main content area (`.content`) to its right. Example skeleton:
+  ```css
+  .layout { display: flex; min-height: 100vh; }
+  .sidebar { width: 260px; position: sticky; top: 0; align-self: flex-start; height: 100vh; overflow-y: auto; }
+  .content { flex: 1; max-width: 900px; margin: 0 auto; padding: 0 1.5rem; }
+  ```
+- **Responsive collapse:** on narrow viewports (e.g. `@media (max-width: 768px)`), collapse the sidebar to the top or hide it behind a toggle so the page stays readable on mobile.
+- Readable typography: system font stack, comfortable line-height, max-width content column.
+- Section navigation: clear link styling in the sidebar, highlight/active states optional.
+- Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
+- Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
+- Heading hierarchy: clear visual distinction between h1/h2/h3.
+
+Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
+
+## Mermaid.js embedding
+- Load Mermaid.js from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialize with `mermaid.initialize({ startOnLoad: true })` after the script tag.
+- Preserve existing Mermaid fenced blocks in context as `<pre class="mermaid">...</pre>` so the library renders them in-browser.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view.
+
+## Output path
+- Write to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand; it is not committed.
+
+## Stale-context caveat
+- This skill renders `context/` as-is. If context is stale or drifts from code, the HTML reflects stale context.
+- Do not attempt to repair context here — that is `sce-context-sync`'s job.
+- If you notice context drift while running this skill, note it to the user and recommend running `sce-context-sync`.
+
+## Expected output
+- A single self-contained HTML file at `context/tmp/project-overview.html` containing all five root context files plus linked domain files, with Mermaid.js embedded via CDN and inline CSS.
+- A short report to the user stating the absolute output path and the disposable-output policy.
+
+## Related skills
+- `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
 """
   }
 }
diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
index 4aeee56e..ef87bcfc 100644
--- a/context/plans/project-overview-html-skill.md
+++ b/context/plans/project-overview-html-skill.md
@@ -55,12 +55,17 @@ This plan uses a two-phase staging approach:
 
 ### Phase 2 — Promote skill to canonical Pkl pipeline
 
-- [ ] T02: `Author sce-project-overview-html skill body in shared-content-code.pkl` (status:todo)
+- [x] T02: `Author sce-project-overview-html skill body in shared-content-code.pkl` (status:done)
   - Task ID: T02
   - Goal: Add the `sce-project-overview-html` skill `UnitSpec` (title + canonicalBody) to the `skills` Mapping in `config/pkl/base/shared-content-code.pkl`, and the mirrored entry in `config/pkl/base/shared-content-automated-code.pkl`. Use the skill body validated in T01 as the canonical source.
   - Boundaries (in/out of scope): In - new `UnitSpec` entry in both manual and automated code Pkl modules. Out - aggregation surface changes (T03), metadata registration (T04), generated output regeneration (T05), context-map update (T06).
   - Done when: Both `shared-content-code.pkl` and `shared-content-automated-code.pkl` contain a `["sce-project-overview-html"]` entry in their `skills` Mapping with identical `title` and `canonicalBody` (skill body is shared between profiles; only agent permission/metadata differs).
   - Verification notes (commands or checks): `grep -n 'sce-project-overview-html' config/pkl/base/shared-content-code.pkl config/pkl/base/shared-content-automated-code.pkl` returns the new entry in both files; diff of the two `canonicalBody` strings shows identical content.
+  - **Status:** done
+  - **Completed:** 2026-07-04
+  - **Files changed:** `config/pkl/base/shared-content-code.pkl`, `config/pkl/base/shared-content-automated-code.pkl`
+  - **Evidence:** `grep -n 'sce-project-overview-html'` returns line 295 in `shared-content-code.pkl` and line 282 in `shared-content-automated-code.pkl`; `diff` of the extracted `["sce-project-overview-html"]` entries from both files shows identical content; `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` (Pkl syntax valid; generated trees unchanged because aggregation surfaces are T03).
+  - **Notes:** New entry placed last in each `skills` Mapping (after `["sce-validation"]`) to preserve existing ordering and minimize diff noise. `title = "SCE Project Overview HTML"` follows the `UpperCamelCase` convention of other `UnitSpec` titles. The `canonicalBody` is the T01-validated skill body (content after YAML frontmatter). No triple-double-quote sequences in the body, so no Pkl escaping needed.
 
 - [ ] T03: `Register skill in shared-content aggregation surfaces` (status:todo)
   - Task ID: T03

From 0fce1a65eecd66addd359ac3310ebd02a3dd6d2b Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:31 +0800
Subject: [PATCH 5/8] config: Register sce-project-overview-html skill in Pkl
 pipeline

Add the sce-project-overview-html skill to the shared-content
aggregation surfaces (shared-content.pkl, shared-content-automated.pkl),
register its description in all four metadata/renderer files, and add
it to the Shared Context Code agent's skill: allowlist in both OpenCode
metadata variants. Regenerate all three target trees (manual OpenCode,
automated OpenCode, Claude) and sync the repo-root active runtime copy
with the canonical generated output.

Plan: project-overview-html-skill
Tasks: T03, T04, T05

Co-authored-by: SCE <sce@crocoder.dev>
---
 .../skills/sce-project-overview-html/SKILL.md |   2 +-
 .../skills/sce-project-overview-html/SKILL.md | 136 ++++++++++++++++++
 config/.opencode/agent/Shared Context Code.md |   1 +
 .../skills/sce-project-overview-html/SKILL.md | 136 ++++++++++++++++++
 .../.opencode/agent/Shared Context Code.md    |   1 +
 .../skills/sce-project-overview-html/SKILL.md | 136 ++++++++++++++++++
 config/pkl/base/shared-content-automated.pkl  |   7 +
 config/pkl/base/shared-content.pkl            |   7 +
 config/pkl/renderers/claude-metadata.pkl      |   1 +
 config/pkl/renderers/common.pkl               |   1 +
 .../renderers/opencode-automated-metadata.pkl |   2 +
 config/pkl/renderers/opencode-metadata.pkl    |   2 +
 context/plans/project-overview-html-skill.md  |  21 ++-
 13 files changed, 449 insertions(+), 4 deletions(-)
 create mode 100644 config/.claude/skills/sce-project-overview-html/SKILL.md
 create mode 100644 config/.opencode/skills/sce-project-overview-html/SKILL.md
 create mode 100644 config/automated/.opencode/skills/sce-project-overview-html/SKILL.md

diff --git a/.opencode/skills/sce-project-overview-html/SKILL.md b/.opencode/skills/sce-project-overview-html/SKILL.md
index a0cd455a..518c07d4 100644
--- a/.opencode/skills/sce-project-overview-html/SKILL.md
+++ b/.opencode/skills/sce-project-overview-html/SKILL.md
@@ -133,4 +133,4 @@ Do not load external CSS frameworks. The document must be self-contained except
 
 ## Related skills
 - `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
-- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
\ No newline at end of file
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
diff --git a/config/.claude/skills/sce-project-overview-html/SKILL.md b/config/.claude/skills/sce-project-overview-html/SKILL.md
new file mode 100644
index 00000000..cfbee957
--- /dev/null
+++ b/config/.claude/skills/sce-project-overview-html/SKILL.md
@@ -0,0 +1,136 @@
+---
+name: sce-project-overview-html
+description: |
+  Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document.
+compatibility: claude
+---
+
+## What I do
+- Read the project's `context/` Markdown files with my own file-read tool.
+- Author a single self-contained HTML document directly with my own file-write tool — I do NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline). I write the HTML myself.
+- Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
+- Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
+
+## When to use
+- Use when the user asks for a project overview as HTML, a readable summary page, or a shareable walkthrough of the project's shared context memory.
+- Trigger phrases include "generate project overview HTML", "project overview as a page", "render context to HTML", "make a project summary page", or "build a project walkthrough".
+
+## Source of truth
+- The source of truth is `context/` only. This skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is.
+
+## How to run this
+
+1. **Read the root context files** - read these five files in order using your file-read tool:
+   - `context/overview.md`
+   - `context/architecture.md`
+   - `context/patterns.md`
+   - `context/glossary.md`
+   - `context/context-map.md`
+
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file with your file-read tool so its content can be included in the HTML.
+
+3. **Author the HTML document yourself** - using your own file-write tool, write a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below. Convert the Markdown content to HTML body markup yourself as you write the file. Do NOT generate, scaffold, or execute any conversion script (no Python, no Node, no shell, no build step). You are the renderer: read the Markdown, then write the equivalent HTML directly.
+
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html` with your file-write tool. Create the `context/tmp/` directory if it does not exist.
+
+5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
+
+## HTML structure contract
+
+The generated HTML must be a single self-contained document with a left-side navigation sidebar and the main content to its right. Use this structure:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{project_name} — Project Overview</title>
+  <style>
+    /* Inline CSS — see CSS guidance below */
+  </style>
+</head>
+<body>
+  <div class="layout">
+    <nav id="toc" class="sidebar">
+      <!-- Left-side anchor navigation linking to each section -->
+    </nav>
+    <main class="content">
+      <section id="overview"><!-- rendered context/overview.md --></section>
+      <section id="architecture"><!-- rendered context/architecture.md --></section>
+      <section id="patterns"><!-- rendered context/patterns.md --></section>
+      <section id="glossary"><!-- rendered context/glossary.md --></section>
+      <section id="context-map"><!-- rendered context/context-map.md --></section>
+      <!-- One <section> per linked domain file, with an id derived from its path -->
+    </main>
+  </div>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+```
+
+### Section ordering
+1. Overview
+2. Architecture
+3. Patterns
+4. Glossary
+5. Context Map
+6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
+
+### Markdown-to-HTML rendering
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) yourself as you write the file. You are the renderer — do not delegate this to a script.
+- Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
+- Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
+- Generate heading anchors (`id` attributes) from heading text for in-page navigation.
+
+### Anchor navigation (left sidebar)
+- Build a table-of-contents `<nav id="toc" class="sidebar">` placed on the left side of the layout with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+- Use relative anchor links (`#section-id`).
+- The sidebar stays visible while the main content scrolls (sticky/fixed positioning).
+
+## CSS guidance
+
+Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
+
+- **Left-sidebar layout:** use a flexbox (or CSS grid) two-column layout — a fixed-width left sidebar (`<nav id="toc" class="sidebar">`) and a flexible main content area (`.content`) to its right. Example skeleton:
+  ```css
+  .layout { display: flex; min-height: 100vh; }
+  .sidebar { width: 260px; position: sticky; top: 0; align-self: flex-start; height: 100vh; overflow-y: auto; }
+  .content { flex: 1; max-width: 900px; margin: 0 auto; padding: 0 1.5rem; }
+  ```
+- **Responsive collapse:** on narrow viewports (e.g. `@media (max-width: 768px)`), collapse the sidebar to the top or hide it behind a toggle so the page stays readable on mobile.
+- Readable typography: system font stack, comfortable line-height, max-width content column.
+- Section navigation: clear link styling in the sidebar, highlight/active states optional.
+- Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
+- Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
+- Heading hierarchy: clear visual distinction between h1/h2/h3.
+
+Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
+
+## Mermaid.js embedding
+- Load Mermaid.js from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialize with `mermaid.initialize({ startOnLoad: true })` after the script tag.
+- Preserve existing Mermaid fenced blocks in context as `<pre class="mermaid">...</pre>` so the library renders them in-browser.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view.
+
+## Output path
+- Write to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand; it is not committed.
+
+## Stale-context caveat
+- This skill renders `context/` as-is. If context is stale or drifts from code, the HTML reflects stale context.
+- Do not attempt to repair context here — that is `sce-context-sync`'s job.
+- If you notice context drift while running this skill, note it to the user and recommend running `sce-context-sync`.
+
+## Expected output
+- A single self-contained HTML file at `context/tmp/project-overview.html` containing all five root context files plus linked domain files, with Mermaid.js embedded via CDN and inline CSS.
+- A short report to the user stating the absolute output path and the disposable-output policy.
+
+## Related skills
+- `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
diff --git a/config/.opencode/agent/Shared Context Code.md b/config/.opencode/agent/Shared Context Code.md
index d5edcd48..e67d3018 100644
--- a/config/.opencode/agent/Shared Context Code.md	
+++ b/config/.opencode/agent/Shared Context Code.md	
@@ -28,6 +28,7 @@ permission:
     "sce-context-sync": allow
     "sce-validation": allow
     "sce-atomic-commit": allow
+    "sce-project-overview-html": allow
 ---
 
 You are the Shared Context Code agent.
diff --git a/config/.opencode/skills/sce-project-overview-html/SKILL.md b/config/.opencode/skills/sce-project-overview-html/SKILL.md
new file mode 100644
index 00000000..518c07d4
--- /dev/null
+++ b/config/.opencode/skills/sce-project-overview-html/SKILL.md
@@ -0,0 +1,136 @@
+---
+name: sce-project-overview-html
+description: |
+  Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document.
+compatibility: opencode
+---
+
+## What I do
+- Read the project's `context/` Markdown files with my own file-read tool.
+- Author a single self-contained HTML document directly with my own file-write tool — I do NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline). I write the HTML myself.
+- Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
+- Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
+
+## When to use
+- Use when the user asks for a project overview as HTML, a readable summary page, or a shareable walkthrough of the project's shared context memory.
+- Trigger phrases include "generate project overview HTML", "project overview as a page", "render context to HTML", "make a project summary page", or "build a project walkthrough".
+
+## Source of truth
+- The source of truth is `context/` only. This skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is.
+
+## How to run this
+
+1. **Read the root context files** - read these five files in order using your file-read tool:
+   - `context/overview.md`
+   - `context/architecture.md`
+   - `context/patterns.md`
+   - `context/glossary.md`
+   - `context/context-map.md`
+
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file with your file-read tool so its content can be included in the HTML.
+
+3. **Author the HTML document yourself** - using your own file-write tool, write a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below. Convert the Markdown content to HTML body markup yourself as you write the file. Do NOT generate, scaffold, or execute any conversion script (no Python, no Node, no shell, no build step). You are the renderer: read the Markdown, then write the equivalent HTML directly.
+
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html` with your file-write tool. Create the `context/tmp/` directory if it does not exist.
+
+5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
+
+## HTML structure contract
+
+The generated HTML must be a single self-contained document with a left-side navigation sidebar and the main content to its right. Use this structure:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{project_name} — Project Overview</title>
+  <style>
+    /* Inline CSS — see CSS guidance below */
+  </style>
+</head>
+<body>
+  <div class="layout">
+    <nav id="toc" class="sidebar">
+      <!-- Left-side anchor navigation linking to each section -->
+    </nav>
+    <main class="content">
+      <section id="overview"><!-- rendered context/overview.md --></section>
+      <section id="architecture"><!-- rendered context/architecture.md --></section>
+      <section id="patterns"><!-- rendered context/patterns.md --></section>
+      <section id="glossary"><!-- rendered context/glossary.md --></section>
+      <section id="context-map"><!-- rendered context/context-map.md --></section>
+      <!-- One <section> per linked domain file, with an id derived from its path -->
+    </main>
+  </div>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+```
+
+### Section ordering
+1. Overview
+2. Architecture
+3. Patterns
+4. Glossary
+5. Context Map
+6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
+
+### Markdown-to-HTML rendering
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) yourself as you write the file. You are the renderer — do not delegate this to a script.
+- Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
+- Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
+- Generate heading anchors (`id` attributes) from heading text for in-page navigation.
+
+### Anchor navigation (left sidebar)
+- Build a table-of-contents `<nav id="toc" class="sidebar">` placed on the left side of the layout with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+- Use relative anchor links (`#section-id`).
+- The sidebar stays visible while the main content scrolls (sticky/fixed positioning).
+
+## CSS guidance
+
+Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
+
+- **Left-sidebar layout:** use a flexbox (or CSS grid) two-column layout — a fixed-width left sidebar (`<nav id="toc" class="sidebar">`) and a flexible main content area (`.content`) to its right. Example skeleton:
+  ```css
+  .layout { display: flex; min-height: 100vh; }
+  .sidebar { width: 260px; position: sticky; top: 0; align-self: flex-start; height: 100vh; overflow-y: auto; }
+  .content { flex: 1; max-width: 900px; margin: 0 auto; padding: 0 1.5rem; }
+  ```
+- **Responsive collapse:** on narrow viewports (e.g. `@media (max-width: 768px)`), collapse the sidebar to the top or hide it behind a toggle so the page stays readable on mobile.
+- Readable typography: system font stack, comfortable line-height, max-width content column.
+- Section navigation: clear link styling in the sidebar, highlight/active states optional.
+- Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
+- Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
+- Heading hierarchy: clear visual distinction between h1/h2/h3.
+
+Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
+
+## Mermaid.js embedding
+- Load Mermaid.js from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialize with `mermaid.initialize({ startOnLoad: true })` after the script tag.
+- Preserve existing Mermaid fenced blocks in context as `<pre class="mermaid">...</pre>` so the library renders them in-browser.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view.
+
+## Output path
+- Write to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand; it is not committed.
+
+## Stale-context caveat
+- This skill renders `context/` as-is. If context is stale or drifts from code, the HTML reflects stale context.
+- Do not attempt to repair context here — that is `sce-context-sync`'s job.
+- If you notice context drift while running this skill, note it to the user and recommend running `sce-context-sync`.
+
+## Expected output
+- A single self-contained HTML file at `context/tmp/project-overview.html` containing all five root context files plus linked domain files, with Mermaid.js embedded via CDN and inline CSS.
+- A short report to the user stating the absolute output path and the disposable-output policy.
+
+## Related skills
+- `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
diff --git a/config/automated/.opencode/agent/Shared Context Code.md b/config/automated/.opencode/agent/Shared Context Code.md
index ca4e6507..f81a9953 100644
--- a/config/automated/.opencode/agent/Shared Context Code.md	
+++ b/config/automated/.opencode/agent/Shared Context Code.md	
@@ -28,6 +28,7 @@ permission:
     "sce-context-sync": allow
     "sce-validation": allow
     "sce-atomic-commit": allow
+    "sce-project-overview-html": allow
 ---
 
 You are the Shared Context Code agent (automated profile).
diff --git a/config/automated/.opencode/skills/sce-project-overview-html/SKILL.md b/config/automated/.opencode/skills/sce-project-overview-html/SKILL.md
new file mode 100644
index 00000000..518c07d4
--- /dev/null
+++ b/config/automated/.opencode/skills/sce-project-overview-html/SKILL.md
@@ -0,0 +1,136 @@
+---
+name: sce-project-overview-html
+description: |
+  Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document.
+compatibility: opencode
+---
+
+## What I do
+- Read the project's `context/` Markdown files with my own file-read tool.
+- Author a single self-contained HTML document directly with my own file-write tool — I do NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline). I write the HTML myself.
+- Embed Mermaid.js via CDN so existing Mermaid blocks render in-browser.
+- Write the result to `context/tmp/project-overview.html` (disposable, gitignored).
+
+## When to use
+- Use when the user asks for a project overview as HTML, a readable summary page, or a shareable walkthrough of the project's shared context memory.
+- Trigger phrases include "generate project overview HTML", "project overview as a page", "render context to HTML", "make a project summary page", or "build a project walkthrough".
+
+## Source of truth
+- The source of truth is `context/` only. This skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is.
+
+## How to run this
+
+1. **Read the root context files** - read these five files in order using your file-read tool:
+   - `context/overview.md`
+   - `context/architecture.md`
+   - `context/patterns.md`
+   - `context/glossary.md`
+   - `context/context-map.md`
+
+2. **Read linked domain files** - parse `context/context-map.md` for linked domain files under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections. Read each linked file with your file-read tool so its content can be included in the HTML.
+
+3. **Author the HTML document yourself** - using your own file-write tool, write a single self-contained HTML file with the structure described in [HTML structure contract](#html-structure-contract) below. Convert the Markdown content to HTML body markup yourself as you write the file. Do NOT generate, scaffold, or execute any conversion script (no Python, no Node, no shell, no build step). You are the renderer: read the Markdown, then write the equivalent HTML directly.
+
+4. **Write the output** - write the HTML to `context/tmp/project-overview.html` with your file-write tool. Create the `context/tmp/` directory if it does not exist.
+
+5. **Report the result** - print the absolute path of the generated file and remind the user it is disposable (regenerated on demand, gitignored).
+
+## HTML structure contract
+
+The generated HTML must be a single self-contained document with a left-side navigation sidebar and the main content to its right. Use this structure:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{project_name} — Project Overview</title>
+  <style>
+    /* Inline CSS — see CSS guidance below */
+  </style>
+</head>
+<body>
+  <div class="layout">
+    <nav id="toc" class="sidebar">
+      <!-- Left-side anchor navigation linking to each section -->
+    </nav>
+    <main class="content">
+      <section id="overview"><!-- rendered context/overview.md --></section>
+      <section id="architecture"><!-- rendered context/architecture.md --></section>
+      <section id="patterns"><!-- rendered context/patterns.md --></section>
+      <section id="glossary"><!-- rendered context/glossary.md --></section>
+      <section id="context-map"><!-- rendered context/context-map.md --></section>
+      <!-- One <section> per linked domain file, with an id derived from its path -->
+    </main>
+  </div>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+```
+
+### Section ordering
+1. Overview
+2. Architecture
+3. Patterns
+4. Glossary
+5. Context Map
+6. Domain files (one `<section>` per linked file, ordered as listed in `context-map.md`)
+
+### Markdown-to-HTML rendering
+- Convert each Markdown file's content to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) yourself as you write the file. You are the renderer — do not delegate this to a script.
+- Preserve Mermaid blocks as `<pre class="mermaid">...</pre>` so the client-side Mermaid.js library renders them. Do not convert Mermaid fenced blocks to plain code blocks.
+- Preserve inline code as `<code>` and fenced code blocks as `<pre><code>`.
+- Generate heading anchors (`id` attributes) from heading text for in-page navigation.
+
+### Anchor navigation (left sidebar)
+- Build a table-of-contents `<nav id="toc" class="sidebar">` placed on the left side of the layout with links to each top-level section (`#overview`, `#architecture`, `#patterns`, `#glossary`, `#context-map`, plus one per domain file section).
+- Use relative anchor links (`#section-id`).
+- The sidebar stays visible while the main content scrolls (sticky/fixed positioning).
+
+## CSS guidance
+
+Inline all CSS in a single `<style>` block in the document head. Keep the stylesheet minimal and readable:
+
+- **Left-sidebar layout:** use a flexbox (or CSS grid) two-column layout — a fixed-width left sidebar (`<nav id="toc" class="sidebar">`) and a flexible main content area (`.content`) to its right. Example skeleton:
+  ```css
+  .layout { display: flex; min-height: 100vh; }
+  .sidebar { width: 260px; position: sticky; top: 0; align-self: flex-start; height: 100vh; overflow-y: auto; }
+  .content { flex: 1; max-width: 900px; margin: 0 auto; padding: 0 1.5rem; }
+  ```
+- **Responsive collapse:** on narrow viewports (e.g. `@media (max-width: 768px)`), collapse the sidebar to the top or hide it behind a toggle so the page stays readable on mobile.
+- Readable typography: system font stack, comfortable line-height, max-width content column.
+- Section navigation: clear link styling in the sidebar, highlight/active states optional.
+- Code block styling: monospace font, background color, padding, horizontal scroll for long lines.
+- Mermaid block styling: ensure `<pre class="mermaid">` blocks render with enough width and centering.
+- Heading hierarchy: clear visual distinction between h1/h2/h3.
+
+Do not load external CSS frameworks. The document must be self-contained except for the Mermaid.js CDN script.
+
+## Mermaid.js embedding
+- Load Mermaid.js from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialize with `mermaid.initialize({ startOnLoad: true })` after the script tag.
+- Preserve existing Mermaid fenced blocks in context as `<pre class="mermaid">...</pre>` so the library renders them in-browser.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view.
+
+## Output path
+- Write to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand; it is not committed.
+
+## Stale-context caveat
+- This skill renders `context/` as-is. If context is stale or drifts from code, the HTML reflects stale context.
+- Do not attempt to repair context here — that is `sce-context-sync`'s job.
+- If you notice context drift while running this skill, note it to the user and recommend running `sce-context-sync`.
+
+## Expected output
+- A single self-contained HTML file at `context/tmp/project-overview.html` containing all five root context files plus linked domain files, with Mermaid.js embedded via CDN and inline CSS.
+- A short report to the user stating the absolute output path and the disposable-output policy.
+
+## Related skills
+- `sce-context-sync` - repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` - creates the `context/` baseline this skill reads from.
diff --git a/config/pkl/base/shared-content-automated.pkl b/config/pkl/base/shared-content-automated.pkl
index 169f7419..575bfbc6 100644
--- a/config/pkl/base/shared-content-automated.pkl
+++ b/config/pkl/base/shared-content-automated.pkl
@@ -131,4 +131,11 @@ skills = new Mapping {
     title = code.skills["sce-validation"].title
     canonicalBody = code.skills["sce-validation"].canonicalBody
   }
+  ["sce-project-overview-html"] = new common.ContentUnit {
+    id = "skill.sce-project-overview-html"
+    kind = "skill"
+    slug = "sce-project-overview-html"
+    title = code.skills["sce-project-overview-html"].title
+    canonicalBody = code.skills["sce-project-overview-html"].canonicalBody
+  }
 }
\ No newline at end of file
diff --git a/config/pkl/base/shared-content.pkl b/config/pkl/base/shared-content.pkl
index 5f2b7ec6..73552d92 100644
--- a/config/pkl/base/shared-content.pkl
+++ b/config/pkl/base/shared-content.pkl
@@ -117,4 +117,11 @@ skills = new Mapping {
     title = code.skills["sce-validation"].title
     canonicalBody = code.skills["sce-validation"].canonicalBody
   }
+  ["sce-project-overview-html"] = new common.ContentUnit {
+    id = "skill.sce-project-overview-html"
+    kind = "skill"
+    slug = "sce-project-overview-html"
+    title = code.skills["sce-project-overview-html"].title
+    canonicalBody = code.skills["sce-project-overview-html"].canonicalBody
+  }
 }
diff --git a/config/pkl/renderers/claude-metadata.pkl b/config/pkl/renderers/claude-metadata.pkl
index b9e7e5ce..6ff1501f 100644
--- a/config/pkl/renderers/claude-metadata.pkl
+++ b/config/pkl/renderers/claude-metadata.pkl
@@ -32,6 +32,7 @@ skillDescriptions = new Mapping {
   ["sce-task-execution"] = "Executes a single planned implementation task with a mandatory approval gate, scope guardrails, and evidence capture. Use when a user wants to implement, run, or execute a specific task from a project plan — such as coding a feature, applying a patch, or making targeted file changes — while enforcing explicit scope boundaries, a pre-implementation confirmation prompt, test/lint verification, and status tracking in context/plans/{plan_id}.md."
   ["sce-atomic-commit"] = "Write atomic, repo-style git commits from a change summary or diff. Use when preparing commit messages, splitting work into coherent commits, or reviewing whether a commit is too broad."
   ["sce-validation"] = "Runs the final validation phase of a project plan by executing the full test suite, lint and format checks, removing temporary scaffolding, and writing a structured validation report with command outputs and success-criteria evidence to `context/plans/{plan_name}.md`. Use when the user wants to verify a completed implementation, confirm all success criteria are met, wrap up a plan, finalize a feature or fix, or sign off on a change before closing it out."
+  ["sce-project-overview-html"] = "Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document."
 }
 
 skillCompatibility = "claude"
diff --git a/config/pkl/renderers/common.pkl b/config/pkl/renderers/common.pkl
index 1147f00e..db1a7e21 100644
--- a/config/pkl/renderers/common.pkl
+++ b/config/pkl/renderers/common.pkl
@@ -43,5 +43,6 @@ skillDescriptions = new Mapping {
   ["sce-task-execution"] = "Use when user wants to Execute one approved task with explicit scope, evidence, and status updates."
   ["sce-atomic-commit"] = "Write atomic, repo-style git commits from a change summary or diff. Use when preparing commit messages, splitting work into coherent commits, or reviewing whether a commit is too broad."
   ["sce-validation"] = "Use when user wants to Run final plan validation and cleanup with evidence capture."
+  ["sce-project-overview-html"] = "Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document."
 }
 
diff --git a/config/pkl/renderers/opencode-automated-metadata.pkl b/config/pkl/renderers/opencode-automated-metadata.pkl
index 23cffe6b..252f3247 100644
--- a/config/pkl/renderers/opencode-automated-metadata.pkl
+++ b/config/pkl/renderers/opencode-automated-metadata.pkl
@@ -72,6 +72,7 @@ permission:
     "sce-context-sync": allow
     "sce-validation": allow
     "sce-atomic-commit": allow
+    "sce-project-overview-html": allow
 """
 }
 
@@ -94,6 +95,7 @@ skillDescriptions = new Mapping {
   ["sce-task-execution"] = "Executes a single scoped coding task with structured implementation logging, test and lint evidence capture, and plan status updates. Use when the user wants to run, implement, or complete one approved task from a plan — such as writing code changes, applying fixes, or executing a defined unit of work — while enforcing strict single-task scope boundaries, logging intent to context/tmp/automated-session-log.md, and updating task status in context/plans/{plan_id}.md. Triggers on phrases like \"execute task\", \"run this task\", \"implement task\", \"do the next task\", or \"apply this change\"."
   ["sce-atomic-commit"] = "Write atomic, repo-style git commits from a change summary or diff. Use when preparing commit messages, splitting work into coherent commits, or reviewing whether a commit is too broad."
   ["sce-validation"] = "Runs the final validation phase of a project plan by executing the full test suite, lint and format checks, removing temporary scaffolding, and writing a structured validation report with command outputs and success-criteria evidence to `context/plans/{plan_name}.md`. Use when the user wants to verify a completed implementation, confirm all success criteria are met, wrap up a plan, finalize a feature or fix, or sign off on a change before closing it out."
+  ["sce-project-overview-html"] = "Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document."
 }
 
 skillCompatibility = "opencode"
diff --git a/config/pkl/renderers/opencode-metadata.pkl b/config/pkl/renderers/opencode-metadata.pkl
index 19ba5161..663e013b 100644
--- a/config/pkl/renderers/opencode-metadata.pkl
+++ b/config/pkl/renderers/opencode-metadata.pkl
@@ -69,6 +69,7 @@ permission:
     "sce-context-sync": allow
     "sce-validation": allow
     "sce-atomic-commit": allow
+    "sce-project-overview-html": allow
 """
 }
 
@@ -90,6 +91,7 @@ skillDescriptions = new Mapping {
   ["sce-task-execution"] = "Executes a single planned implementation task with a mandatory approval gate, scope guardrails, and evidence capture. Use when a user wants to implement, run, or execute a specific task from a project plan — such as coding a feature, applying a patch, or making targeted file changes — while enforcing explicit scope boundaries, a pre-implementation confirmation prompt, test/lint verification, and status tracking in context/plans/{plan_id}.md."
   ["sce-atomic-commit"] = "Write atomic, repo-style git commits from a change summary or diff. Use when preparing commit messages, splitting work into coherent commits, or reviewing whether a commit is too broad."
   ["sce-validation"] = "Runs the final validation phase of a project plan by executing the full test suite, lint and format checks, removing temporary scaffolding, and writing a structured validation report with command outputs and success-criteria evidence to `context/plans/{plan_name}.md`. Use when the user wants to verify a completed implementation, confirm all success criteria are met, wrap up a plan, finalize a feature or fix, or sign off on a change before closing it out."
+  ["sce-project-overview-html"] = "Generates a single self-contained HTML document from the project's `context/` Markdown files so a human reader can quickly understand the project and how it works. Embeds Mermaid.js (client-side, CDN) so existing Mermaid diagrams in context render in-browser, and includes inline CSS for a clean, readable layout. Output is written to `context/tmp/project-overview.html` (disposable, gitignored). Use when the user wants a project overview as HTML, a readable project summary page, a shareable project walkthrough, or to visualize the context memory as a single document."
 }
 
 skillCompatibility = "opencode"
diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
index ef87bcfc..fe9d06be 100644
--- a/context/plans/project-overview-html-skill.md
+++ b/context/plans/project-overview-html-skill.md
@@ -67,26 +67,41 @@ This plan uses a two-phase staging approach:
   - **Evidence:** `grep -n 'sce-project-overview-html'` returns line 295 in `shared-content-code.pkl` and line 282 in `shared-content-automated-code.pkl`; `diff` of the extracted `["sce-project-overview-html"]` entries from both files shows identical content; `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` (Pkl syntax valid; generated trees unchanged because aggregation surfaces are T03).
   - **Notes:** New entry placed last in each `skills` Mapping (after `["sce-validation"]`) to preserve existing ordering and minimize diff noise. `title = "SCE Project Overview HTML"` follows the `UpperCamelCase` convention of other `UnitSpec` titles. The `canonicalBody` is the T01-validated skill body (content after YAML frontmatter). No triple-double-quote sequences in the body, so no Pkl escaping needed.
 
-- [ ] T03: `Register skill in shared-content aggregation surfaces` (status:todo)
+- [x] T03: `Register skill in shared-content aggregation surfaces` (status:done)
   - Task ID: T03
   - Goal: Add `["sce-project-overview-html"]` entries to the `skills` Mapping in both `config/pkl/base/shared-content.pkl` (manual) and `config/pkl/base/shared-content-automated.pkl` (automated), referencing the new `UnitSpec` from `code.skills["sce-project-overview-html"]`.
   - Boundaries (in/out of scope): In - the two aggregation surface Pkl files. Out - renderer files (T04), Pkl regeneration (T05).
   - Done when: Both aggregation files contain a `["sce-project-overview-html"]` entry in `skills` that references `code.skills["sce-project-overview-html"]` with `id = "skill.sce-project-overview-html"`, `kind = "skill"`, `slug = "sce-project-overview-html"`, and the correct `title`/`canonicalBody` forwarding.
   - Verification notes (commands or checks): `grep -n 'sce-project-overview-html' config/pkl/base/shared-content.pkl config/pkl/base/shared-content-automated.pkl` returns the new entry in both files.
+  - **Status:** done
+  - **Completed:** 2026-07-04
+  - **Files changed:** `config/pkl/base/shared-content.pkl`, `config/pkl/base/shared-content-automated.pkl`
+  - **Evidence:** `grep -n 'sce-project-overview-html'` returns line 120 in `shared-content.pkl` and line 134 in `shared-content-automated.pkl`; both entries reference `code.skills["sce-project-overview-html"]` with `id = "skill.sce-project-overview-html"`, `kind = "skill"`, `slug = "sce-project-overview-html"`, and `title`/`canonicalBody` forwarding.
+  - **Notes:** Executed together with T04 and T05 in the same session because T03 alone breaks `pkl-check-generated` (the renderer looks up `metadata.skillDescriptions[unitSlug]`, which T04 owns). User approved scope expansion to T03+T04+T05 so the repo stays green. New entry placed last in each `skills` Mapping (after `["sce-validation"]`) to preserve existing ordering and minimize diff noise.
 
-- [ ] T04: `Register skill descriptions and permissions in all four metadata files` (status:todo)
+- [x] T04: `Register skill descriptions and permissions in all four metadata files` (status:done)
   - Task ID: T04
   - Goal: Add the `sce-project-overview-html` description to `skillDescriptions` in all four metadata files (`config/pkl/renderers/opencode-metadata.pkl`, `config/pkl/renderers/opencode-automated-metadata.pkl`, `config/pkl/renderers/claude-metadata.pkl`, `config/pkl/renderers/common.pkl`) and add `sce-project-overview-html` to the Shared Context Code agent `skill:` allowlist in both `opencode-metadata.pkl` and `opencode-automated-metadata.pkl` permission blocks.
   - Boundaries (in/out of scope): In - the four metadata/renderer files plus the Shared Context Code permission allowlists. Out - skill body content (T02), aggregation (T03), regeneration (T05).
   - Done when: All four metadata files have a `["sce-project-overview-html"]` entry in `skillDescriptions`; both OpenCode metadata files list `"sce-project-overview-html": allow` under the `shared-context-code` agent's `skill:` block; `common.pkl` `skillDescriptions` Mapping includes the new slug.
   - Verification notes (commands or checks): `grep -n 'sce-project-overview-html' config/pkl/renderers/opencode-metadata.pkl config/pkl/renderers/opencode-automated-metadata.pkl config/pkl/renderers/claude-metadata.pkl config/pkl/renderers/common.pkl` returns entries in all four files; `grep -A2 'sce-project-overview-html' config/pkl/renderers/opencode-metadata.pkl` shows it under the `shared-context-code` permission block.
+  - **Status:** done
+  - **Completed:** 2026-07-04
+  - **Files changed:** `config/pkl/renderers/common.pkl`, `config/pkl/renderers/opencode-metadata.pkl`, `config/pkl/renderers/opencode-automated-metadata.pkl`, `config/pkl/renderers/claude-metadata.pkl`
+  - **Evidence:** `grep -n 'sce-project-overview-html'` returns entries in all four metadata files; `grep -B1 -A2` confirms `"sce-project-overview-html": allow` sits under the `shared-context-code` `skill:` block in both OpenCode metadata files (manual line 72, automated line 75). The full skill description (matching the T01 SKILL.md frontmatter `description`) is added to `opencode-metadata.pkl`, `opencode-automated-metadata.pkl`, and `claude-metadata.pkl`; a shorter shared description is added to `common.pkl`.
+  - **Notes:** Executed together with T03 and T05. The `common.pkl` description is a shorter shared form ("Use when the user wants a project overview as HTML...") consistent with the shorter shared descriptions already present for other skills in `common.pkl`; the three target-specific metadata files carry the full description matching the T01 SKILL.md frontmatter.
 
-- [ ] T05: `Regenerate generated config outputs and verify parity` (status:todo)
+- [x] T05: `Regenerate generated config outputs and verify parity` (status:done)
   - Task ID: T05
   - Goal: Run `nix develop -c pkl eval -m . config/pkl/generate.pkl` to regenerate `config/.opencode/skills/sce-project-overview-html/SKILL.md`, `config/automated/.opencode/skills/sce-project-overview-html/SKILL.md`, and `config/.claude/skills/sce-project-overview-html/SKILL.md`, then verify parity with `nix run .#pkl-check-generated`. Also sync the repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` with the regenerated `config/.opencode/` version so the active runtime tree matches the canonical generated output.
   - Boundaries (in/out of scope): In - running Pkl regeneration, the parity check, and syncing the repo-root `.opencode/skills/` copy with the regenerated `config/.opencode/skills/` output. Out - editing generated files by hand (generated trees are build artifacts), editing Pkl sources (covered by T02-T04).
   - Done when: `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` and exits 0; the three generated `SKILL.md` files exist with correct frontmatter (`name`, `description`, `compatibility`) and the authored body; the repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` matches `config/.opencode/skills/sce-project-overview-html/SKILL.md`.
   - Verification notes (commands or checks): `nix run .#pkl-check-generated`; `ls config/.opencode/skills/sce-project-overview-html/SKILL.md config/automated/.opencode/skills/sce-project-overview-html/SKILL.md config/.claude/skills/sce-project-overview-html/SKILL.md`; `diff .opencode/skills/sce-project-overview-html/SKILL.md config/.opencode/skills/sce-project-overview-html/SKILL.md` shows no differences.
+  - **Status:** done
+  - **Completed:** 2026-07-04
+  - **Files changed:** `config/.opencode/skills/sce-project-overview-html/SKILL.md` (new), `config/automated/.opencode/skills/sce-project-overview-html/SKILL.md` (new), `config/.claude/skills/sce-project-overview-html/SKILL.md` (new), `config/.opencode/agent/Shared Context Code.md` (permission allowlist), `config/automated/.opencode/agent/Shared Context Code.md` (permission allowlist), `.opencode/skills/sce-project-overview-html/SKILL.md` (synced with regenerated canonical output)
+  - **Evidence:** `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` and exits 0; `ls` confirms all three generated `SKILL.md` files exist; `head -6` confirms correct frontmatter (`name`, `description`, `compatibility: opencode` for OpenCode variants, `compatibility: claude` for Claude variant); `diff .opencode/skills/sce-project-overview-html/SKILL.md config/.opencode/skills/sce-project-overview-html/SKILL.md` shows no differences after sync (trailing newline added to repo-root copy to match generated canonical output).
+  - **Notes:** Executed together with T03 and T04. Regeneration also updated the two Shared Context Code agent files (`config/.opencode/agent/Shared Context Code.md` and `config/automated/.opencode/agent/Shared Context Code.md`) with the new `"sce-project-overview-html": allow` permission entry, as expected from the T04 metadata edits.
 
 - [ ] T06: `Update context-map.md with new skill discoverability link` (status:todo)
   - Task ID: T06

From ba042c538506eec67d55c95816109b3082052a09 Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:32 +0800
Subject: [PATCH 6/8] context: Add sce-project-overview-html skill domain file
 and context-map link

Add context/sce/project-overview-html-skill.md capturing the current-state
contract for the sce-project-overview-html skill (purpose, context/-only
source of truth, files read, direct-author HTML rendering contract, Mermaid.js
CDN dependency, disposable output path, canonical Pkl authoring/generation
surfaces) and add a discoverability bullet in context/context-map.md.

Plan: project-overview-html-skill
Task: T06

Co-authored-by: SCE <sce@crocoder.dev>
---
 context/context-map.md                       |  1 +
 context/plans/project-overview-html-skill.md |  7 ++-
 context/sce/project-overview-html-skill.md   | 64 ++++++++++++++++++++
 3 files changed, 71 insertions(+), 1 deletion(-)
 create mode 100644 context/sce/project-overview-html-skill.md

diff --git a/context/context-map.md b/context/context-map.md
index 623ba8f4..371d9b3b 100644
--- a/context/context-map.md
+++ b/context/context-map.md
@@ -24,6 +24,7 @@ Feature/domain context:
 - `context/sce/shared-context-plan-workflow.md` (canonical `/change-to-plan` workflow, clarification/readiness gate contract, and one-task/one-atomic-commit task-slicing policy)
 - `context/sce/plan-code-overlap-map.md` (T01 overlap matrix for Shared Context Plan/Code, related commands, and core skill ownership/dedup targets)
 - `context/sce/dedup-ownership-table.md` (current-state canonical owner-vs-consumer matrix for shared SCE behavior domains and thin-command ownership boundaries)
+- `context/sce/project-overview-html-skill.md` (current-state contract for the `sce-project-overview-html` skill: purpose, `context/`-only source of truth, files read, direct-author HTML rendering contract, Mermaid.js CDN dependency, disposable `context/tmp/project-overview.html` output, and canonical Pkl authoring/generation surfaces)
 
 - `context/sce/atomic-commit-workflow.md` (canonical manual-vs-automated `/commit` contract, including the single-message rule, the staged-plan commit-body requirement to cite affected plan slug(s) + updated task ID(s), automated single-commit execution behavior, and the manual-profile `/commit oneshot`/`/commit skip` argument-based bypass mode that skips staging confirmation, context-guidance gate, split guidance, and plan-citation ambiguity stops to produce one message and auto-execute `git commit`)
 - `context/sce/agent-trace-implementation-contract.md` (historical no-git-wrapper Agent Trace design contract; not active runtime behavior)
diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
index fe9d06be..d19a9ccf 100644
--- a/context/plans/project-overview-html-skill.md
+++ b/context/plans/project-overview-html-skill.md
@@ -103,12 +103,17 @@ This plan uses a two-phase staging approach:
   - **Evidence:** `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` and exits 0; `ls` confirms all three generated `SKILL.md` files exist; `head -6` confirms correct frontmatter (`name`, `description`, `compatibility: opencode` for OpenCode variants, `compatibility: claude` for Claude variant); `diff .opencode/skills/sce-project-overview-html/SKILL.md config/.opencode/skills/sce-project-overview-html/SKILL.md` shows no differences after sync (trailing newline added to repo-root copy to match generated canonical output).
   - **Notes:** Executed together with T03 and T04. Regeneration also updated the two Shared Context Code agent files (`config/.opencode/agent/Shared Context Code.md` and `config/automated/.opencode/agent/Shared Context Code.md`) with the new `"sce-project-overview-html": allow` permission entry, as expected from the T04 metadata edits.
 
-- [ ] T06: `Update context-map.md with new skill discoverability link` (status:todo)
+- [x] T06: `Update context-map.md with new skill discoverability link` (status:done)
   - Task ID: T06
   - Goal: Add a `context/sce/project-overview-html-skill.md` domain file describing the new skill's current-state contract, and add a discoverability link to it in `context/context-map.md` under the SCE working-area or feature/domain section.
   - Boundaries (in/out of scope): In - new `context/sce/project-overview-html-skill.md` file and one new bullet in `context/context-map.md`. Out - editing other context files, editing `context/overview.md` (this is a localized skill addition, verify-only for root context per `sce-context-sync` gating).
   - Done when: `context/sce/project-overview-html-skill.md` exists with a concise current-state description of the skill (purpose, source files, output path, Mermaid.js CDN dependency, disposable-output policy); `context/context-map.md` contains a bullet linking to it.
   - Verification notes (commands or checks): `ls context/sce/project-overview-html-skill.md`; `grep -n 'project-overview-html' context/context-map.md`.
+  - **Status:** done
+  - **Completed:** 2026-07-05
+  - **Files changed:** `context/sce/project-overview-html-skill.md` (new), `context/context-map.md` (one new bullet in Feature/domain context)
+  - **Evidence:** `ls context/sce/project-overview-html-skill.md` confirms the file exists (4464 bytes); `grep -n 'project-overview-html' context/context-map.md` returns line 25 with the new discoverability bullet; `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` (no Pkl/generated changes, parity unaffected).
+  - **Notes:** Domain file follows the current-state contract style of existing `context/sce/*.md` entries (purpose, source of truth, files read, rendering contract, HTML structure, Mermaid.js CDN dependency, output path/disposable policy, canonical Pkl authoring/generation surfaces, related skills). The context-map bullet is placed in the Feature/domain context list immediately after `dedup-ownership-table.md`, grouping it with the other SCE workflow/skill entries. No root context files (`overview.md`, `architecture.md`, `patterns.md`, `glossary.md`) were edited — this is a localized skill addition, so root context is verify-only per `sce-context-sync` gating.
 
 - [ ] T07: `Validation and cleanup` (status:todo)
   - Task ID: T07
diff --git a/context/sce/project-overview-html-skill.md b/context/sce/project-overview-html-skill.md
new file mode 100644
index 00000000..72c122f6
--- /dev/null
+++ b/context/sce/project-overview-html-skill.md
@@ -0,0 +1,64 @@
+# `sce-project-overview-html` skill
+
+## What this skill is for
+
+The `sce-project-overview-html` skill renders the project's current-state `context/` Markdown memory into a single self-contained HTML document so a human reader can quickly understand the project and how it works. It is owned by the Shared Context Code agent and is invocable through the Shared Context Code agent's `skill:` allowlist in both manual and automated OpenCode profiles.
+
+Use this skill when the user asks for a project overview as HTML, a readable summary page, a shareable walkthrough, or a single-document view of the shared context memory.
+
+## Source of truth
+
+- The source of truth is `context/` only. The skill does not scan or analyze application code.
+- It renders the current-state context memory into HTML as-is. If context is stale, the HTML reflects stale context; the skill does not repair context (that is `sce-context-sync`'s job).
+
+## Files read
+
+The skill reads, in order:
+
+1. `context/overview.md`
+2. `context/architecture.md`
+3. `context/patterns.md`
+4. `context/glossary.md`
+5. `context/context-map.md`
+6. Every linked domain file discovered by parsing `context/context-map.md` (under `context/cli/`, `context/sce/`, and any other `context/{domain}/` sections).
+
+## Rendering contract
+
+- The agent authors the HTML directly with its own file-write tool. It does NOT generate, run, or emit any conversion script (no Python, no Node, no shell pipeline, no build step). The agent is the renderer.
+- Markdown is converted to HTML body markup (headings, paragraphs, lists, tables, code blocks, blockquotes) by the agent as it writes the file.
+- Mermaid fenced blocks in context are preserved as `<pre class="mermaid">...</pre>` so the client-side library renders them in-browser. They are not converted to plain code blocks.
+- Inline code is preserved as `<code>`; fenced code blocks as `<pre><code>`.
+- Heading anchors (`id` attributes) are generated from heading text for in-page navigation.
+
+## HTML structure
+
+- Single self-contained document with a left-side navigation sidebar (`<nav id="toc" class="sidebar">`) and main content (`.content`) to its right.
+- Section ordering: Overview, Architecture, Patterns, Glossary, Context Map, then one `<section>` per linked domain file ordered as listed in `context-map.md`.
+- The sidebar stays visible while the main content scrolls (sticky positioning) and collapses on narrow viewports.
+- All CSS is inlined in a single `<style>` block in the document head. No external CSS frameworks are loaded.
+
+## Mermaid.js dependency
+
+- Mermaid.js is loaded from CDN at view time: `<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>`.
+- Initialized with `mermaid.initialize({ startOnLoad: true })`.
+- No vendoring, no build step, no pre-rendering to SVG. Diagrams require internet to view. Offline support is a non-goal for this iteration.
+
+## Output path and disposable-output policy
+
+- Output is written to `context/tmp/project-overview.html`.
+- `context/tmp/` is disposable and gitignored by the existing `context/tmp/.gitignore` (`*` ignore, `!.gitignore`).
+- The file is regenerated on demand and is not committed.
+
+## Canonical authoring and generation
+
+- The skill body is authored canonically in `config/pkl/base/shared-content-code.pkl` and `config/pkl/base/shared-content-automated-code.pkl` (shared `UnitSpec`), aggregated in `config/pkl/base/shared-content.pkl` and `config/pkl/base/shared-content-automated.pkl`, and rendered into all three target trees:
+  - `config/.opencode/skills/sce-project-overview-html/SKILL.md` (manual OpenCode)
+  - `config/automated/.opencode/skills/sce-project-overview-html/SKILL.md` (automated OpenCode)
+  - `config/.claude/skills/sce-project-overview-html/SKILL.md` (Claude)
+- The repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` is the active runtime copy, kept in sync with the generated `config/.opencode/` output.
+- Skill descriptions and the Shared Context Code `skill:` allowlist entry are owned by the four metadata/renderer files: `config/pkl/renderers/common.pkl`, `config/pkl/renderers/opencode-metadata.pkl`, `config/pkl/renderers/opencode-automated-metadata.pkl`, and `config/pkl/renderers/claude-metadata.pkl`.
+
+## Related skills
+
+- `sce-context-sync` — repairs context drift; run it first if context is stale before generating the overview.
+- `sce-bootstrap-context` — creates the `context/` baseline this skill reads from.
\ No newline at end of file

From 13e075057e02fa04d5c99db6794b2f10a5514347 Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:32 +0800
Subject: [PATCH 7/8] plans: Close out project-overview-html-skill plan

Mark T07 (validation and cleanup) done and record the final validation report. All 7 tasks (T01-T07) are complete; the sce-project-overview-html skill is authored, promoted to Pkl sources, generated into all three target trees, registered in the Shared Context Code agent allowlist, and discoverable via context-map.md.

Validation: nix run .#pkl-check-generated and nix flake check both pass (exit 0). Plan-produced scratch files removed from context/tmp/.

Plan: project-overview-html-skill
Task: T07

Co-authored-by: SCE <sce@crocoder.dev>
---
 context/plans/project-overview-html-skill.md | 53 +++++++++++++++++++-
 1 file changed, 51 insertions(+), 2 deletions(-)

diff --git a/context/plans/project-overview-html-skill.md b/context/plans/project-overview-html-skill.md
index d19a9ccf..ce1eed83 100644
--- a/context/plans/project-overview-html-skill.md
+++ b/context/plans/project-overview-html-skill.md
@@ -115,12 +115,31 @@ This plan uses a two-phase staging approach:
   - **Evidence:** `ls context/sce/project-overview-html-skill.md` confirms the file exists (4464 bytes); `grep -n 'project-overview-html' context/context-map.md` returns line 25 with the new discoverability bullet; `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` (no Pkl/generated changes, parity unaffected).
   - **Notes:** Domain file follows the current-state contract style of existing `context/sce/*.md` entries (purpose, source of truth, files read, rendering contract, HTML structure, Mermaid.js CDN dependency, output path/disposable policy, canonical Pkl authoring/generation surfaces, related skills). The context-map bullet is placed in the Feature/domain context list immediately after `dedup-ownership-table.md`, grouping it with the other SCE workflow/skill entries. No root context files (`overview.md`, `architecture.md`, `patterns.md`, `glossary.md`) were edited — this is a localized skill addition, so root context is verify-only per `sce-context-sync` gating.
 
-- [ ] T07: `Validation and cleanup` (status:todo)
+- [x] T07: `Validation and cleanup` (status:done)
   - Task ID: T07
   - Goal: Run full repo validation (`nix flake check`), confirm all success criteria are met, and verify no stray temporary artifacts were left behind.
   - Boundaries (in/out of scope): In - `nix flake check`, success-criteria walkthrough, cleanup of any `context/tmp/` scratch files produced during planning/testing. Out - new code or context edits beyond cleanup.
   - Done when: `nix flake check` passes; each success criterion above has concrete evidence (command output or file path); no unexpected files exist under `context/tmp/` other than `.gitignore`.
   - Verification notes (commands or checks): `nix flake check`; `git status` shows only intended changes (repo-root `.opencode/skills/` new file, Pkl sources, generated config, new context file, updated context-map).
+  - **Status:** done
+  - **Completed:** 2026-07-06
+  - **Files changed:** `context/plans/project-overview-html-skill.md` (T07 status update); `context/tmp/project-overview.html` and `context/tmp/cli_sce_md_contents.json` deleted (plan scratch cleanup).
+  - **Evidence:**
+    - `nix run .#pkl-check-generated` prints `Generated outputs are up to date.` and exits 0.
+    - `nix flake check` exits 0 with all 14 `aarch64-darwin` checks ✅ (`cli-tests`, `cli-clippy`, `cli-fmt`, `integrations-install-tests`, `integrations-install-clippy`, `integrations-install-fmt`, `workflow-actionlint`, `pkl-parity`, `npm-bun-tests`, `npm-biome-check`, `npm-biome-format`, `config-lib-bun-tests`, `config-lib-biome-check`, `config-lib-biome-format`).
+    - Success-criteria walkthrough (all met):
+      - SC1 (skill in repo-root `.opencode/skills/`): `.opencode/skills/sce-project-overview-html/SKILL.md` exists (8309 bytes) with valid frontmatter (`name`, `description`, `compatibility: opencode`).
+      - SC2 (promoted to Pkl + generated into all three trees): `sce-project-overview-html` present in `shared-content-code.pkl`, `shared-content-automated-code.pkl`, `shared-content.pkl`, `shared-content-automated.pkl`; generated `SKILL.md` exists in `config/.opencode/`, `config/automated/.opencode/`, and `config/.claude/`; `nix run .#pkl-check-generated` passes (parity verified).
+      - SC3 (skill body reads context files + renders HTML): verified in T01/T02 skill body — reads `context/overview.md`, `architecture.md`, `patterns.md`, `glossary.md`, `context-map.md` plus linked domain files; renders single self-contained HTML.
+      - SC4 (HTML includes Mermaid.js CDN, inline CSS, sectioned content with anchor nav, `<pre class="mermaid">` blocks): verified in T01/T02 skill body contract.
+      - SC5 (output to `context/tmp/project-overview.html`, gitignored): `context/tmp/.gitignore` is `*` + `!.gitignore`, covering the output path.
+      - SC6 (`pkl-check-generated` + `nix flake check` pass): both pass (see above).
+      - SC7 (invocable by Shared Context Code agent): `"sce-project-overview-html": allow` present in both `config/.opencode/agent/Shared Context Code.md` and `config/automated/.opencode/agent/Shared Context Code.md` (line 31 each); `skillDescriptions` entries present in all four renderer metadata files.
+      - SC8 (context-map discoverability link): `context/sce/project-overview-html-skill.md` exists (4464 bytes); `context/context-map.md` line 25 has the discoverability bullet.
+    - Repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` is identical to generated `config/.opencode/skills/sce-project-overview-html/SKILL.md` (`diff` shows no differences).
+    - Cleanup: deleted plan-produced scratch files `context/tmp/project-overview.html` and `context/tmp/cli_sce_md_contents.json`. Remaining `context/tmp/` contents are gitignored runtime byproducts (`*-diff-trace.json`, `*-post-commit.json`, `sce.log`) from normal `sce hooks` operation, not plan scratch files.
+    - `git status --porcelain` is empty (working tree clean; all plan changes were committed in prior tasks).
+  - **Notes:** This is the final plan task. All 7 tasks (T01–T07) are complete. Plan is ready for closure.
 
 ## Open questions
 
@@ -129,4 +148,34 @@ None. All blocking ambiguities were resolved during the clarification gate:
 - Output location: `context/tmp/project-overview.html` (disposable, gitignored).
 - Diagram rendering: Mermaid.js client-side via CDN.
 - Skill ownership: Shared Context Code agent.
-- Staging: Phase 1 in repo-root `.opencode/skills/` for manual testing, Phase 2 promotes to Pkl canonical pipeline.
\ No newline at end of file
+- Staging: Phase 1 in repo-root `.opencode/skills/` for manual testing, Phase 2 promotes to Pkl canonical pipeline.
+
+## Validation Report
+
+### Commands run
+- `nix run .#pkl-check-generated` -> exit 0 (`Generated outputs are up to date.`)
+- `nix flake check` -> exit 0 (all 14 `aarch64-darwin` checks ✅: `cli-tests`, `cli-clippy`, `cli-fmt`, `integrations-install-tests`, `integrations-install-clippy`, `integrations-install-fmt`, `workflow-actionlint`, `pkl-parity`, `npm-bun-tests`, `npm-biome-check`, `npm-biome-format`, `config-lib-bun-tests`, `config-lib-biome-check`, `config-lib-biome-format`)
+- `git status --porcelain` -> empty (working tree clean)
+- Removed: `context/tmp/project-overview.html` and `context/tmp/cli_sce_md_contents.json` (plan-produced scratch files from T01 manual testing)
+
+### Success-criteria verification
+- [x] SC1: Skill exists in repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` and is manually testable -> confirmed via `ls` (8309 bytes) + `head -6` shows valid frontmatter (`name`, `description`, `compatibility: opencode`)
+- [x] SC2: Skill promoted to canonical Pkl sources and generated into all three target trees with parity verified -> `sce-project-overview-html` present in `shared-content-code.pkl`, `shared-content-automated-code.pkl`, `shared-content.pkl`, `shared-content-automated.pkl`; generated `SKILL.md` exists in `config/.opencode/`, `config/automated/.opencode/`, `config/.claude/`; `nix run .#pkl-check-generated` passes
+- [x] SC3: Skill body instructs reading `context/overview.md`, `architecture.md`, `patterns.md`, `glossary.md`, `context-map.md` plus linked domain files and rendering into single HTML -> verified in T01/T02 skill body
+- [x] SC4: Generated HTML includes Mermaid.js CDN `<script>`, inline CSS, sectioned content with anchor navigation, `<pre class="mermaid">` blocks -> verified in T01/T02 skill body contract
+- [x] SC5: Output written to `context/tmp/project-overview.html` (disposable, gitignored) -> `context/tmp/.gitignore` is `*` + `!.gitignore`, covering the path
+- [x] SC6: `nix run .#pkl-check-generated` passes + `nix flake check` passes -> both pass (see Commands run)
+- [x] SC7: Skill invocable by Shared Context Code agent (registered in `skill:` allowlist in both manual and automated OpenCode metadata) -> `"sce-project-overview-html": allow` at line 31 in both `config/.opencode/agent/Shared Context Code.md` and `config/automated/.opencode/agent/Shared Context Code.md`; `skillDescriptions` entries in all four renderer metadata files
+- [x] SC8: `context/context-map.md` updated with discoverability link to `context/sce/project-overview-html-skill.md` -> line 25 bullet; domain file exists (4464 bytes)
+
+### Context sync
+- Classification: verify-only (localized skill addition; no root-level behavior/architecture/terminology impact).
+- Root files (`overview.md`, `architecture.md`, `glossary.md`, `patterns.md`) verified against code truth — no edits needed. The skill is a standalone utility skill not wired into command-body orchestration, so it does not belong in the command-orchestration descriptions like `/next-task`/`/change-to-plan`/`/commit` skills.
+- Feature existence documentation present and linked: `context/sce/project-overview-html-skill.md` + `context/context-map.md` line 25.
+- Repo-root `.opencode/skills/sce-project-overview-html/SKILL.md` is identical to generated `config/.opencode/skills/sce-project-overview-html/SKILL.md`.
+
+### Failed checks and follow-ups
+- None.
+
+### Residual risks
+- None identified. Plan is complete; all 7 tasks (T01–T07) done.
\ No newline at end of file

From 2e4d679c290a874c4f987792927f9762024ca591 Mon Sep 17 00:00:00 2001
From: Goreng <hi@goreng.me>
Date: Mon, 6 Jul 2026 19:22:32 +0800
Subject: [PATCH 8/8] context: Preserve install-channel context entry

---
 context/context-map.md                        |  2 +-
 ...all-channel-integration-test-entrypoint.md | 26 +++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 context/sce/optional-install-channel-integration-test-entrypoint.md

diff --git a/context/context-map.md b/context/context-map.md
index 371d9b3b..55269204 100644
--- a/context/context-map.md
+++ b/context/context-map.md
@@ -22,9 +22,9 @@ Feature/domain context:
 - `context/sce/cli-observability-contract.md` (implemented config-backed runtime observability contract for the flat logging config-file shape with env-over-config fallback, concrete logger/telemetry runtime behavior plus logger and object-safe telemetry trait boundaries, AppContext observability wiring, generic `RunOutcome<L: Logger>` final rendering, runtime-classified repeated telemetry action protection, operator-facing `sce config show` observability reporting, and the trimmed `sce config validate` status-only validation surface)
 - `context/sce/shared-context-code-workflow.md`
 - `context/sce/shared-context-plan-workflow.md` (canonical `/change-to-plan` workflow, clarification/readiness gate contract, and one-task/one-atomic-commit task-slicing policy)
+- `context/sce/project-overview-html-skill.md` (current `sce-project-overview-html` skill contract for rendering `context/` Markdown memory into a disposable self-contained HTML overview at `context/tmp/project-overview.html`)
 - `context/sce/plan-code-overlap-map.md` (T01 overlap matrix for Shared Context Plan/Code, related commands, and core skill ownership/dedup targets)
 - `context/sce/dedup-ownership-table.md` (current-state canonical owner-vs-consumer matrix for shared SCE behavior domains and thin-command ownership boundaries)
-- `context/sce/project-overview-html-skill.md` (current-state contract for the `sce-project-overview-html` skill: purpose, `context/`-only source of truth, files read, direct-author HTML rendering contract, Mermaid.js CDN dependency, disposable `context/tmp/project-overview.html` output, and canonical Pkl authoring/generation surfaces)
 
 - `context/sce/atomic-commit-workflow.md` (canonical manual-vs-automated `/commit` contract, including the single-message rule, the staged-plan commit-body requirement to cite affected plan slug(s) + updated task ID(s), automated single-commit execution behavior, and the manual-profile `/commit oneshot`/`/commit skip` argument-based bypass mode that skips staging confirmation, context-guidance gate, split guidance, and plan-citation ambiguity stops to produce one message and auto-execute `git commit`)
 - `context/sce/agent-trace-implementation-contract.md` (historical no-git-wrapper Agent Trace design contract; not active runtime behavior)
diff --git a/context/sce/optional-install-channel-integration-test-entrypoint.md b/context/sce/optional-install-channel-integration-test-entrypoint.md
new file mode 100644
index 00000000..bfce0d3f
--- /dev/null
+++ b/context/sce/optional-install-channel-integration-test-entrypoint.md
@@ -0,0 +1,26 @@
+# Optional Install-Channel Integration-Test Entrypoint
+
+This file is retained as historical context for the removed optional install-channel integration-test runner.
+
+## Current State
+
+- The former standalone `integrations/install/` Rust runner is not an active current-state surface.
+- The former `apps.install-channel-integration-tests` flake app is not exposed by the current root flake.
+- Default `nix flake check` does not run the removed integration runner or its former `integrations-install-*` checks.
+- Current install-channel validation is covered by the active release, package, and distribution checks documented in the install-channel and release contracts.
+
+## Historical Scope
+
+The removed runner previously provided opt-in install-channel integration coverage for npm, Bun, and Cargo behind:
+
+```bash
+nix run .#install-channel-integration-tests -- --channel <npm|bun|cargo|all>
+```
+
+That command is intentionally not documented as current usage. See `context/plans/remove-integrations-install.md` for the removal decision and validation evidence.
+
+## Related Current Context
+
+- `context/overview.md`
+- `context/architecture.md`
+- `context/sce/cli-first-install-channels-contract.md`