oh-my-opencode 4.17.1 → 4.18.1

package/dist/skills/frontend/SKILL.md

@@ -32,7 +32,7 @@ Every implementation must choose one of these branches before UI code changes:
    - **Embedded references:** use `references/design/_INDEX.md` to shortlist 2-3 plausible Layer B references, then read exactly one Layer A style skill and one Layer B reference in full — every line, no partial reads (they are 200-500 lines; a sliced read produces the flattened token set this gate exists to prevent). Log the shortlist, the pick, and why. Use `open-design` only when the curated set has no fit; add `ui-ux-db` lookups for palette/type/domain questions.
    - **Lazyweb real-product screens:** READ `references/design/lazyweb.md` FIRST and run its recipe verbatim — do not improvise curl calls against lazyweb.com; the recipe mints its own anonymous token. Log the queries run, how many screens you actually VIEWED, and the layout grammar harvested — never pixel copies.
    - **Imagen concept drafts:** generate 2-3 imagen concept drafts, each seeded with the loaded Layer A + Layer B tokens (palette, type, material); pick the strongest and treat the chosen draft as the reference-fidelity contract. Log the draft paths and the pick.
-   Synthesize every lane into `DESIGN.md`. Treat sources as source material, not mood labels: extract tokens, layout grammar, component anatomy, interaction states, motion, and taste decisions, then recombine them into project-specific primitives. Never freestyle past the selected references, never copy logos or brand-specific copy. Then run the Primitive Showcase Gate (`references/design/README.md` Phase 0) before any product screen.
+   Synthesize every lane into `DESIGN.md`. Treat sources as source material, not mood labels: extract tokens, layout grammar, component anatomy, interaction states, motion, and taste decisions, then recombine them into project-specific primitives. Before laying out sections, inventory the content blocks and assign each a job — hook, explain, prove, compare, convert, navigate, retain — then order sections by the visitor's decision path, not by visual symmetry. Never freestyle past the selected references, never copy logos or brand-specific copy. Then run the Primitive Showcase Gate (`references/design/README.md` Phase 0) before any product screen.
 3. **Existing project with `DESIGN.md` or a component system:** read it, follow it, and update it before implementation only when the requested work needs a new token, primitive, state, motion rule, accessibility constraint, accepted debt, or reference-fidelity requirement.
 4. **Existing project with UI but no `DESIGN.md` and no reusable component layer:** STOP and ask the user one focused question: should you preserve the current look with copy-nearby styling, or extract a real `DESIGN.md` plus reusable components before continuing? Do not silently choose.
 

package/dist/skills/frontend/references/design/README.md

@@ -169,6 +169,12 @@ Triggers (mid-conversation, not initial): "you keep leaving placeholders", "stop
 
 **Action:** Add `output-skill.md` on top of whatever is currently loaded. This stacks cleanly — it is purely about output completeness, not visual style.
 
+### Step 8 — Is the screen an app shell, not a scroll-the-page site?
+
+Triggers: dashboard, settings, mail/inbox, list-detail, command surface, split panes, fixed sidebar + scrolling body, admin console — or the user reports a layout that breaks when content gets long, empty, or unbroken (panel won't scroll, footer pushed off-screen, horizontal overflow on mobile).
+
+**Action:** Add `layout-skill.md` on top of whatever style skill you selected in Steps 1-2. It carries scroll-ownership doctrine, the two silently-failing CSS contracts (`min-block-size: 0` scroll shells, `minmax(min(…),100%)` grids), the named-primitive vocabulary, container-vs-viewport routing, and the content-stress matrix. It adds no visual direction — the style skill still owns taste. Skip it for pure scroll-the-document marketing pages, where `taste-skill` layout guidance already fits.
+
 ## Stacking rules (read this once, internalize it)
 
 1. **At most one Layer A *style* skill at a time.** A layout cannot be both `minimalist-skill` and `brutalist-skill` simultaneously — they encode opposite spacing and typography philosophies. Pick one.
@@ -177,6 +183,7 @@ Triggers (mid-conversation, not initial): "you keep leaving placeholders", "stop
 4. **`redesign-skill.md` replaces a style-skill** when the task is auditing, not building. Stack a Layer B brand if the user wants a specific direction.
 5. **`image-to-code-skill.md` pairs with one imagegen skill** for the full flow.
 6. **Layer B (brand DESIGN.md) is orthogonal to Layer A.** You can pair any Layer A skill with any Layer B brand. Use Layer B as the source of color/type/component tokens; let Layer A drive the execution discipline.
+7. **`layout-skill.md` stacks on top of any style skill** for app-shell / dashboard / split-pane work. It owns spatial structure and scroll ownership only — no visual direction — so it never conflicts with the style skill you picked.
 
 ## Anti-patterns — do not do these
 
@@ -218,6 +225,8 @@ Once references are loaded, before writing any UI code:
 | "Generate a brand identity board for {company}" | `imagegen-brandkit.md` |
 | "Stop using placeholders" | Add `output-skill.md` to current stack |
 | "Also output a DESIGN.md doc" | Add `stitch-skill.md` to current stack |
+| "Build a dashboard / settings / inbox / app shell" | one style skill (usually `taste-skill.md`) + `layout-skill.md` |
+| "Panel won't scroll / footer pushed off-screen / mobile overflow" | Add `layout-skill.md` to current stack |
 
 ## Phase Final — Design QA (MANDATORY, runs after implementation)
 

package/dist/skills/frontend/references/design/design-system-architecture.md

@@ -116,7 +116,7 @@ All spacing derives from a base of **4px**.
 - Breakpoints: sm 640px, md 768px, lg 1024px, xl 1280px, 2xl 1536px
 
 ### Rules
-- No magic numbers. Every spacing value maps to a token.
+- Tokenize design *intent* — spacing steps, content width, gutters, section gaps, density steps. Keep browser *mechanics* raw: `auto`, `%`, `min-content`, `max-content`, `fit-content`, `clamp()`, viewport/container units, intrinsic sizing. A `clamp(1rem, 4vw, 2rem)` gap or a `minmax(min(16rem, 100%), 1fr)` track is mechanics, not a magic number — do not force it into a token.
 - Asymmetric spacing is intentional, not accidental — document why.
 
 ## 5. Components
@@ -130,6 +130,7 @@ Document reusable patterns before implementation for greenfield work, and as the
 - **States**: default, hover, active, focus, disabled, loading, empty, error
 - **Accessibility**: keyboard, ARIA, contrast
 - **Motion**: entry/exit animations
+- **Layout**: spatial primitive (stack / cluster / sidebar / grid / shell…) and, if the component scrolls or pins anything, its scroll owner
 
 Greenfield starts with the primitives you are about to build, assembled from
 the selected references' component anatomy and adapted to the user's product.
@@ -214,13 +215,14 @@ After every component implementation, check:
 
 - [ ] All colors reference tokens from Section 2. No raw hex outside `DESIGN.md`.
 - [ ] All font sizes match Section 3 scale. No arbitrary sizes.
-- [ ] All spacing values are multiples of `--space-1` (4px). No magic numbers.
+- [ ] Spacing intent maps to a token (Section 4); browser mechanics (`clamp()`, intrinsic sizing, container units) stay raw. No arbitrary px.
 - [ ] Interactive elements have all required states from Section 5 and Section 6.
 - [ ] Depth treatment matches the chosen strategy from Section 7.
 - [ ] Component reused 2+ times? Documented in Section 5.
 - [ ] Motion follows the timing table. No arbitrary durations.
 - [ ] Component visual QA passed for each primitive and required state before product screens were composed.
 - [ ] Section 8 accessibility constraints hold for the new component; any new debt is recorded in Section 8, not silently accepted.
+- [ ] Survives content stress: empty, long label, unbroken string. Reflows to one readable column at 375px with no horizontal scroll of primary content.
 
 ## Memory Management
 

package/dist/skills/frontend/references/design/layout-skill.md

@@ -0,0 +1,107 @@
+---
+name: layout-skill
+description: "Layer A layout-mechanics reference. Stacks on any style skill when the screen is an app shell, dashboard, settings, list-detail, mail/inbox, or any layout with fixed regions plus a scrolling body — or when a layout breaks under long, empty, or unbroken content. Owns spatial structure and scroll ownership; owns zero visual taste. Load it alongside a style skill; it does not replace one."
+---
+
+# Layout Mechanics
+
+Style skills decide how a surface looks. This file decides how it is *built to hold content* — what scrolls, what stays fixed, how regions shrink, and which layouts survive real data. It stacks on top of any Layer A style skill (`taste-skill`, `minimalist-skill`, `soft-skill`, `brutalist-skill`, `gpt-tasteskill`) and any Layer B brand. It adds ZERO visual direction — color, type, shadow, radius, and motion still come from the style skill and `DESIGN.md`.
+
+Load this when the screen is an **application shell**, not a scroll-the-whole-document marketing page: dashboards, settings, list-detail, mail/inbox, command surfaces, split panes, sidebars — or when a page that looked fine breaks the moment content gets long, empty, or unbroken.
+
+## 1. Scroll ownership — decide this BEFORE writing layout CSS
+
+The single most common agent-built layout bug is an app shell where the wrong thing scrolls: the whole page scrolls when only a panel should, two panels fight over the scrollbar, or a "fixed" header scrolls away. Prevent it by naming ownership up front, in `DESIGN.md` and in the component:
+
+- **What scrolls?** Name the ONE element that owns vertical scroll for this region.
+- **What stays fixed?** Header, sidebar, footer, toolbar — list them.
+- **Where is height determined?** The scroll container needs a bounded height ancestor, or it will grow instead of scroll.
+
+Rules:
+
+- **One scroll container per region unless each extra one has a named job.** Nested scrollbars with no declared responsibility are a defect — the user loses track of what a wheel/trackpad gesture will move.
+- Full-height shells are bounded by `100dvh`/`100dvb` (dynamic viewport units), never `100vh` — `vh` causes the iOS Safari address-bar jump.
+- A sticky element (`position: sticky`) follows document scroll; a fixed shell region (grid row/column with `overflow: auto` body) owns its own scroll. Do not mix the two models in one region without reason.
+
+## 2. The two CSS contracts agents get wrong
+
+These two are worth memorizing verbatim. They fail *silently* — the layout looks right until content arrives.
+
+**Bounded scroll shell** (fixed header/footer, scrolling body):
+
+```css
+.shell {
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr) auto; /* header / body / footer */
+  max-block-size: 100dvb;
+}
+.shell__body {
+  min-block-size: 0; /* WITHOUT THIS the grid child refuses to shrink and overflow never fires */
+  overflow: auto;
+}
+```
+
+The `min-block-size: 0` (or `min-height: 0`) on the scroll child is the fix for "why won't my panel scroll — it just pushes the footer off-screen." A grid/flex child's default `min-*-size: auto` refuses to shrink below its content. The same applies to a flex column: the scrollable child needs `min-height: 0`.
+
+**Overflow-safe intrinsic grid** (repeat as many columns as fit, no media queries):
+
+```css
+.grid {
+  display: grid;
+  gap: var(--gap);
+  grid-template-columns: repeat(auto-fit, minmax(min(16rem, 100%), 1fr));
+}
+```
+
+The inner `min(16rem, 100%)` is load-bearing: plain `minmax(16rem, 1fr)` forces a 16rem track even when the container is 12rem wide, causing horizontal overflow on narrow screens. `min(…, 100%)` lets the track collapse below its floor when space is genuinely tight. Use `auto-fit` to stretch the last row, `auto-fill` to keep empty tracks.
+
+## 3. Named layout primitives (shared vocabulary)
+
+Build shells from these named primitives instead of ad-hoc fl/grid. Naming them makes `DESIGN.md` Section 5 and subagent handoffs precise ("wrap it in a `sidebar` with a 20rem aside" beats "put it on the left, roughly"). Lineage: Every Layout + web.dev one-line layouts.
+
+| Primitive | Spatial job | Core mechanic |
+|---|---|---|
+| **stack** | Vertical rhythm between siblings | flex column + `gap`, or `> * + *` margin |
+| **cluster** | Wrapping row of items (tags, actions) | `flex-wrap: wrap` + `gap`; wraps before overflow |
+| **content-limiter** | Readable prose measure inside a fluid parent | `max-inline-size: ~65ch; margin-inline: auto` |
+| **sidebar** | Narrow aside + fluid main, wraps when tight | flex; aside fixed basis, main `min-inline-size` floor, both `flex-wrap` |
+| **switcher** | N equal regions: row when roomy, stack when tight, NO breakpoint | flex + `min()` basis so it flips at a content threshold |
+| **cover** | Centered region between optional header/footer, min viewport tall | grid rows `auto 1fr auto`, `min-block-size: 100dvb` |
+| **frame** | Media held to an aspect ratio | `aspect-ratio` + `object-fit: cover` |
+| **reel** | Row that scrolls horizontally instead of wrapping | `overflow-inline: auto` + `scroll-snap`; declare keyboard access |
+| **imposter** | Overlay centered over a parent without changing document order | `position: absolute` + translate; do not use to reorder focus |
+| **overlay-stack** | Several layers intentionally in one cell | single grid cell, all children `grid-area: 1/1` |
+| **scroll-body-shell** | Fixed shell regions, only the body scrolls | §2 bounded scroll shell |
+| **fixed-sidenav-shell** | Side nav stays put, main scrolls | grid columns `auto 1fr`, main is the scroll owner |
+| **list-detail** | Explorable list beside its detail region | two-column grid, each pane's scroll ownership named |
+| **sticky-aside** | Support content stays visible during a long read | `position: sticky; top:` on the aside, document scroll |
+
+## 4. Container-local vs viewport-level responsiveness
+
+Ask **what the layout is responding to** before reaching for a breakpoint:
+
+- The component should adapt to *its own available width* (a card that's wide in main but narrow in a rail) → wrap it in `container-type: inline-size` and use `@container`. This is correct far more often than agents assume, because a component rarely knows the viewport it lands in.
+- The *page frame itself* changes (sidebar collapses, columns drop) → `@media`.
+
+Prefer intrinsic adaptation (`switcher`, `sidebar`, intrinsic grid, `clamp()`) over any query — the best breakpoint is often none. Use breakpoint *names* for layout states, never device names (`--bp-wide`, not `--bp-ipad`).
+
+## 5. Recipes are spatial models, not product categories
+
+Choose a layout by the screen's spatial shape, not its product label. A settings page and a docs app both want `fixed-sidenav-shell`; a support inbox and a file browser both want `list-detail`; a metrics view and a photo gallery both want an intrinsic grid. Do not invent a bespoke "dashboard layout" when `page-grid + intrinsic grid + cluster` already covers it — and do not force marketing-page structure (hero, zigzag, bento) onto a task app.
+
+## 6. Content stress — the layout is not done until it survives this
+
+Landing pages fail on taste; app shells fail on *content*. Before declaring any layout done, stress every region against:
+
+- **Empty** — no rows, no avatar, no value. Does the region collapse gracefully or leave a broken frame?
+- **Long label** — a 40-char name in a 12-char slot. Truncate (`text-overflow: ellipsis`) or wrap by design, never by accident.
+- **Long paragraph** — does the measure stay readable, or does text run 200 chars wide?
+- **Unbroken string** — a URL or token with no spaces. Needs `overflow-wrap: anywhere` / `min-inline-size: 0`, or it forces horizontal scroll.
+- **Reflow** — at 375px width the layout reflows to a single readable column with NO horizontal scrollbar. Two-dimensional scrolling of primary content is a fail.
+- **Direction** — if the app supports RTL, the layout uses logical properties (`margin-inline`, `inset-inline-start`) so it mirrors correctly.
+
+A layout that only holds the happy-path mock is not finished. Drive these states in `/visual-qa` alongside the interaction states the style skill requires.
+
+## Boundary
+
+This file owns spatial structure only. It never sets color, typography, shadow, radius, or motion values — those trace to `DESIGN.md` and the loaded style skill. If you find yourself adding a brand color to a layout primitive, stop: the primitive stays layout-only and the styling wraps or composes around it.

package/dist/skills/programming/SKILL.md

@@ -104,9 +104,17 @@ Mocks are a last resort, not a default. The priority order:
 - **Deterministic**: no `sleep`, no wall-clock dependence, no order dependence (`-shuffle=on`, pytest-randomly, vitest random seed). Inject a `Clock`. Subscribe to the event, do not poll for it. Time-based flake is a bug, not a test issue.
 - **Isolated**: every test starts from a known fixture and tears down. `t.TempDir()`, `t.Setenv()`, transactional rollback for DB tests. Two tests passing individually but failing together is a fixture leak — fix it immediately.
 
-### Prompt tests follow the same rule
+### Prompt tests: NEVER assert prose
 
-When tests cover LLM prompts or agent outputs, assert on **parsed structure, decisions, or rule data**, never on exact prompt strings. Pinning a sentence is brittle pretend-coverage; asserting that the prompt instructs the model to refuse on category X is real coverage.
+**FORBIDDEN — NO EXCEPTIONS: a test MUST NOT assert natural-language prompt text.** `expect(prompt).toContain("based on GPT-5.6")`, `not.toContain("old wording")`, `toMatchSnapshot()` on prose, grepping a sentence fragment — every one of these is pretend-coverage. It stays green while the behavior it claims to guard breaks, then blocks every legitimate rewording until someone bumps the pinned string. A reviewer MUST block it as HIGH; deleting such a test is a fix, not a coverage loss. "A nearby test already does it" is not a defense — that test is the disease, not the convention.
+
+Assert ONLY what a machine consumes:
+
+- the builder's routing decision — `expect(getPromptSource(model)).toBe("gpt-5-6")`, never the sentence that routing produces
+- a structural token the runtime dispatches on — a tool name, a tag like `<agent-identity>`, a parsed frontmatter field
+- the conditional the code enforces — skill loaded → tool present; `verbose=false` → directive absent
+
+If no machine consumes the text, there is no seam: write NO test and say so in the PR; review guards prose. When you DELEGATE test-writing, hand the child the behavior the test must distinguish ("fails if override precedence breaks"), never a ready-made assertion string, prompt fragment, or marker to copy — a prescribed mechanism that is wrong gets implemented faithfully, and the error ships with a green suite.
 
 ### Anti-patterns the skill rejects
 
@@ -119,6 +127,8 @@ When tests cover LLM prompts or agent outputs, assert on **parsed structure, dec
 | Snapshot tests for everything | Locks formatting, not behavior. | Snapshots for *structure* (CLI help, JSON shape). Assertions for *behavior*. |
 | Removing a failing test to "unblock CI" | You just deleted a bug report. | Fix the code or fix the test — never delete to silence. |
 | `assert result is not None` and stopping there | Passes when result is garbage. | Assert the *value*, not its existence. |
+| Expected value derived from the output under test (`expect(config.prompt).toBe(getPrompt(config.model))` when the criterion is about `config.prompt`) | Recomputes a projection of the output and compares it to itself — passes even when the artifact is built from the wrong input. | Derive the expected value from the test's *input*: `expect(config.prompt).toBe(getPrompt(inputModel))` (independent known-good builder fed the fixture's input), or a stable builder routing decision. |
+| Override/precedence fixture equal to its fallback (override == system default) | The assertion passes whether or not the code honored the override — precedence is never exercised. | Make every value the code must select, preserve, or override differ from its fallback. Prove it: temporarily force the regression the test names, watch it fail, revert. |
 | Single happy-path E2E, no edges | Most bugs live on edges. | Edges are unit-test territory — but include at least one E2E that exercises an error path. |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "4.17.1",
+  "version": "4.18.1",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -107,8 +107,10 @@
     "build": "bun run script/build.ts",
     "build:cli-node": "bun run script/build-cli-node.ts",
     "build:codex-install": "bun run script/build-codex-install.ts",
+    "install:codex-dev": "bun run script/build-codex-install.ts && bun run script/install-codex-dev.ts",
     "build:codex-plugin": "npm --prefix packages/omo-codex/plugin ci && bun run --cwd packages/omo-codex/plugin build",
-    "build:senpi-plugin": "node packages/omo-senpi/plugin/scripts/build-extension.mjs && node packages/omo-senpi/plugin/scripts/sync-skills.mjs && node packages/omo-senpi/plugin/scripts/embed-directive.mjs --check",
+    "build:senpi-plugin": "bun run build:lsp-daemon && bun run build:senpi-plugin:stage",
+    "build:senpi-plugin:stage": "node packages/omo-senpi/plugin/scripts/stage-lsp-daemon-runtime.mjs && node packages/omo-senpi/plugin/scripts/build-extension.mjs && node packages/omo-senpi/plugin/scripts/sync-skills.mjs && node packages/omo-senpi/plugin/scripts/embed-directive.mjs --check && node packages/omo-senpi/plugin/scripts/build-install.mjs",
     "build:materialize-frontend": "node packages/omo-codex/plugin/scripts/materialize-shared-upstreams.mjs --strict",
     "build:shared-skills-assets": "bun run build:materialize-frontend && rm -rf dist/skills && cp -R packages/shared-skills/skills dist/skills",
     "build:lsp-tools-mcp": "npm --prefix packages/lsp-tools-mcp ci && npm --prefix packages/lsp-tools-mcp run build",
@@ -130,7 +132,7 @@
     "typecheck:script": "tsgo --noEmit -p script/tsconfig.json",
     "test": "bun test",
     "test:codex": "bun run build:codex-install && bun run build:git-bash-mcp && bun run build:lsp-tools-mcp && bun run build:lsp-daemon && npm --prefix packages/lsp-tools-mcp test && npm --prefix packages/omo-codex/plugin ci && npm --prefix packages/omo-codex/plugin/components/ulw-loop test && bun run --cwd packages/omo-codex/plugin build && npm --prefix packages/omo-codex/plugin/components/codegraph run typecheck && npm --prefix packages/omo-codex/plugin/components/codegraph test && node scripts/check-third-party-notices.mjs --ship && bun test packages/omo-opencode/src/cli/cli-installer.platform.test.ts packages/omo-codex/src/install/codex-cache.test.ts packages/omo-codex/src/install/codex-cleanup.test.ts packages/omo-codex/src/install/codex-config-agent-cleanup.test.ts packages/omo-codex/src/install/codex-config-autonomous-features.test.ts packages/omo-codex/src/install/codex-config-reasoning.test.ts packages/omo-codex/src/install/codex-config-toml.test.ts packages/omo-codex/src/install/codex-project-local-cleanup.test.ts packages/omo-codex/src/install/install-codex-project-local-cleanup.test.ts packages/omo-codex/src/install/install-codex.test.ts packages/omo-codex/src/install/install-codex-packaged.test.ts packages/omo-codex/src/install/link-cached-plugin-agents.test.ts packages/omo-codex/src/**/*.test.ts packages/utils/src/jsonc-parser.test.ts packages/utils/src/frontmatter.test.ts packages/hashline-core/src/hash-computation.test.ts packages/hashline-core/src/smoke-untested-modules.test.ts packages/rules-engine/src/index.test.ts packages/rules-engine/src/security-boundary.test.ts packages/agents-md-core/src/injector.test.ts packages/omo-codex/plugin/components/lsp/test/package-smoke.test.ts && node --test packages/omo-codex/plugin/test/*.test.mjs packages/omo-codex/scripts/install-cache-copy.test.mjs packages/omo-codex/scripts/install-cli-args.test.mjs packages/omo-codex/scripts/install-delegated-command.test.mjs packages/omo-codex/scripts/install-config-autonomous-features.test.mjs packages/omo-codex/scripts/install-config-autonomous.test.mjs packages/omo-codex/scripts/install-config-reasoning.test.mjs packages/omo-codex/scripts/install-config.test.mjs packages/omo-codex/scripts/install-hook-targets.test.mjs packages/omo-codex/scripts/install-project-local-cleanup.test.mjs packages/omo-codex/scripts/install-lazycodex-version-stamp.test.mjs packages/omo-codex/scripts/install-local-entrypoint.test.mjs packages/omo-codex/scripts/install-local-git-bash-preflight.test.mjs packages/omo-codex/scripts/install-local.test.mjs packages/omo-codex/scripts/install-marketplace-cache.test.mjs packages/omo-codex/scripts/install-mcp-context7-runtime.test.mjs packages/omo-codex/scripts/install-mcp-runtime.test.mjs packages/omo-codex/scripts/install-packaged-local.test.mjs packages/omo-codex/scripts/install-generated-bundle.test.mjs packages/omo-codex/scripts/install-agent-links.test.mjs packages/omo-codex/scripts/install-bin-links.test.mjs",
-    "test:senpi": "node packages/omo-senpi/plugin/scripts/build-extension.mjs && node packages/omo-senpi/plugin/scripts/sync-skills.mjs && node packages/omo-senpi/plugin/scripts/embed-directive.mjs --check && bun test packages/omo-senpi",
+    "test:senpi": "bun run build:senpi-plugin && tsgo --noEmit -p packages/omo-senpi/tsconfig.json && bun test packages/omo-senpi",
     "test:windows-codex": "bun run test:codex",
     "build:git-bash-mcp": "bun run --cwd packages/git-bash-mcp build"
   },
@@ -170,7 +172,6 @@
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.4",
     "posthog-node": "^5.34.3",
-    "vscode-jsonrpc": "^8.2.1",
     "zod": "^4.4.3"
   },
   "devDependencies": {
@@ -211,18 +212,18 @@
     "typescript": "^6.0.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "4.17.1",
-    "oh-my-opencode-darwin-x64": "4.17.1",
-    "oh-my-opencode-darwin-x64-baseline": "4.17.1",
-    "oh-my-opencode-linux-arm64": "4.17.1",
-    "oh-my-opencode-linux-arm64-musl": "4.17.1",
-    "oh-my-opencode-linux-x64": "4.17.1",
-    "oh-my-opencode-linux-x64-baseline": "4.17.1",
-    "oh-my-opencode-linux-x64-musl": "4.17.1",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.17.1",
-    "oh-my-opencode-windows-arm64": "4.17.1",
-    "oh-my-opencode-windows-x64": "4.17.1",
-    "oh-my-opencode-windows-x64-baseline": "4.17.1"
+    "oh-my-opencode-darwin-arm64": "4.18.1",
+    "oh-my-opencode-darwin-x64": "4.18.1",
+    "oh-my-opencode-darwin-x64-baseline": "4.18.1",
+    "oh-my-opencode-linux-arm64": "4.18.1",
+    "oh-my-opencode-linux-arm64-musl": "4.18.1",
+    "oh-my-opencode-linux-x64": "4.18.1",
+    "oh-my-opencode-linux-x64-baseline": "4.18.1",
+    "oh-my-opencode-linux-x64-musl": "4.18.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.18.1",
+    "oh-my-opencode-windows-arm64": "4.18.1",
+    "oh-my-opencode-windows-x64": "4.18.1",
+    "oh-my-opencode-windows-x64-baseline": "4.18.1"
   },
   "overrides": {
     "@earendil-works/pi-agent-core": "0.80.3",

package/packages/lsp-core/package.json

@@ -25,6 +25,10 @@
       "types": "./src/mcp.ts",
       "import": "./src/mcp.ts"
     },
+    "./post-edit": {
+      "types": "./src/post-edit/index.ts",
+      "import": "./src/post-edit/index.ts"
+    },
     "./lsp/*": {
       "types": "./src/lsp/*.ts",
       "import": "./src/lsp/*.ts"

package/packages/lsp-core/src/index.ts

@@ -24,5 +24,6 @@ export * from "./lsp/utils.js";
 export * from "./lsp/workspace-edit.js";
 export * from "./mcp.js";
 export * from "./missing-dependency-result.js";
+export * from "./post-edit/index.js";
 export * from "./request-context.js";
 export * from "./tools.js";

package/packages/lsp-core/src/lsp/cleanup-errors.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+
+import { reportBestEffortCleanupError } from "./cleanup-errors.js";
+
+describe("reportBestEffortCleanupError", () => {
+	test("#given an injected cleanup logger #when cleanup fails #then the normal diagnostic is emitted without an environment gate", () => {
+		// given
+		const messages: string[] = [];
+
+		// when
+		reportBestEffortCleanupError("client stop", new Error("connection closed"), (message) => {
+			messages.push(message);
+		});
+
+		// then
+		expect(messages).toEqual(["[lsp] ignored client stop failure during cleanup: connection closed"]);
+	});
+});

package/packages/lsp-core/src/lsp/cleanup-errors.ts

@@ -1,5 +1,14 @@
-export function reportBestEffortCleanupError(operation: string, error: unknown): void {
-	if (process.env["CODEX_LSP_DEBUG_CLEANUP"] !== "1") return;
+export type CleanupErrorLogger = (message: string) => void;
+
+function writeCleanupError(message: string): void {
+	process.stderr.write(`${message}\n`);
+}
+
+export function reportBestEffortCleanupError(
+	operation: string,
+	error: unknown,
+	logger: CleanupErrorLogger = writeCleanupError,
+): void {
 	const message = error instanceof Error ? error.message : String(error);
-	console.error(`[codex-lsp] ignored ${operation} failure during cleanup: ${message}`);
+	logger(`[lsp] ignored ${operation} failure during cleanup: ${message}`);
 }

package/packages/lsp-core/src/lsp/client-diagnostics-freshness.integration.test.ts

@@ -0,0 +1,261 @@
+import { writeFileSync } from "node:fs";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	waitForEventCount,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient diagnostics freshness", () => {
+	it("#given concurrent diagnostics on a cold file and an exact didOpen publish #when pull is not advertised #then one didOpen opens the file and both requests receive the current diagnostics", async () => {
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						version: 1,
+						diagnostics: [diagnostic("exact-current")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const [first, second] = await Promise.all([
+			context.client.diagnostics(context.source),
+			context.client.diagnostics(context.source),
+		]);
+
+		expect(first.items).toEqual([diagnostic("exact-current")]);
+		expect(second.items).toEqual([diagnostic("exact-current")]);
+		expect(
+			readEvents(context.events).filter(
+				(event) => event.type === "clientNotification" && event.method === "textDocument/didOpen",
+			),
+		).toHaveLength(1);
+	});
+
+	it("#given a versionless publish that arrives after the current change #when no newer eligible publish arrives before quiescence #then diagnostics wait for that quiescence window and return the versionless payload", async () => {
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didChange",
+						diagnostics: [diagnostic("post-generation-versionless")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20 },
+		);
+		await context.client.openFile(context.source);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "serverNotification" && event.method === "textDocument/publishDiagnostics",
+			1,
+		);
+		writeFileSync(context.source, "const after = 1;\n", "utf-8");
+		await context.client.openFile(context.source);
+
+		const startedAt = Date.now();
+		const result = await context.client.diagnostics(context.source);
+		const elapsedMs = Date.now() - startedAt;
+
+		expect(result.items).toEqual([diagnostic("post-generation-versionless")]);
+		expect(elapsedMs).toBeGreaterThanOrEqual(15);
+	});
+
+	it("#given only a pre-generation versionless publish #when a newer local version asks for diagnostics #then the stale versionless publish is ignored and the request does not resolve clean", async () => {
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						diagnostics: [diagnostic("pre-generation-versionless")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 300, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+		expect((await context.client.diagnostics(context.source)).items).toEqual([diagnostic("pre-generation-versionless")]);
+		writeFileSync(context.source, "const after = 1;\n", "utf-8");
+		await context.client.openFile(context.source);
+
+		const result = await context.client.diagnostics(context.source);
+
+		expect(result.items).toEqual([]);
+		expect(result.transientError?.kind).toBe("freshness_timeout");
+	});
+
+	it("#given stale and future publish versions #when diagnostics target the current version #then neither stale nor future diagnostics satisfy the request", async () => {
+		const stale = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didChange",
+						version: 1,
+						diagnostics: [diagnostic("stale")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+		);
+		await stale.client.openFile(stale.source);
+		writeFileSync(stale.source, "const stale = 1;\n", "utf-8");
+		await stale.client.openFile(stale.source);
+
+		const staleResult = await stale.client.diagnostics(stale.source);
+
+		expect(staleResult.items).toEqual([]);
+		expect(staleResult.transientError?.kind).toBe("freshness_timeout");
+
+		await harness.cleanup();
+
+		const future = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didChange",
+						version: 3,
+						diagnostics: [diagnostic("future")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+		);
+		await future.client.openFile(future.source);
+		writeFileSync(future.source, "const future = 1;\n", "utf-8");
+		await future.client.openFile(future.source);
+
+		const futureResult = await future.client.diagnostics(future.source);
+
+		expect(futureResult.items).toEqual([]);
+		expect(futureResult.transientError?.kind).toBe("freshness_timeout");
+	});
+
+	it("#given a pull response overtaken by a later local change #when the stale full report returns first #then diagnostics restart within the same request and resolve from the current version", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [
+					{
+						delayMs: 20,
+						report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
+					},
+					{
+						report: { kind: "full", resultId: "v2", items: [diagnostic("pull-fresh")] },
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+
+		const pending = context.client.diagnostics(context.source);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+			1,
+		);
+		writeFileSync(context.source, "const pull_fresh = 1;\n", "utf-8");
+		await context.client.openFile(context.source);
+
+		const result = await pending;
+
+		expect(result.items).toEqual([diagnostic("pull-fresh")]);
+		expect(
+			readEvents(context.events).filter(
+				(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+			),
+		).toHaveLength(2);
+	});
+
+	it("#given a full pull report followed by an unchanged report for the same version and resultId #when diagnostics repeat without a local change #then the cached full items are reused", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [
+					{
+						report: { kind: "full", resultId: "same-version", items: [diagnostic("cached-full")] },
+					},
+					{
+						report: { kind: "unchanged", resultId: "same-version" },
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+
+		const first = await context.client.diagnostics(context.source);
+		const second = await context.client.diagnostics(context.source);
+
+		expect(first.items).toEqual([diagnostic("cached-full")]);
+		expect(second.items).toEqual([diagnostic("cached-full")]);
+	});
+
+	it("#given a server that claims pull support but closes instead of answering #when diagnostics run #then the transport failure is not labeled clean", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [{ action: "close" }],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+
+		await expect(context.client.diagnostics(context.source)).rejects.toThrow(/exited|closed/i);
+	});
+
+	it("#given an advertised pull method that is explicitly unsupported and a matching push publish #when diagnostics run #then the client falls back to push diagnostics", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						version: 1,
+						diagnostics: [diagnostic("push-fallback")],
+					},
+				],
+				diagnosticResponses: [{ error: { code: -32601, message: "Method not found" } }],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const result = await context.client.diagnostics(context.source);
+
+		expect(result.items).toEqual([diagnostic("push-fallback")]);
+	});
+
+	it("#given a diagnostic pull request times out #when the fake server keeps it pending #then the client sends cancel for the LSP request id", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [{ action: "hang" }],
+			},
+			{ requestTimeoutMs: 30, diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const result = await context.client.diagnostics(context.source);
+		const [cancel] = await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientNotification" && event.method === "$/cancelRequest",
+			1,
+		);
+		const events = readEvents(context.events);
+		const request = events.find((event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic");
+
+		expect(result.transientError?.kind).toBe("freshness_timeout");
+		expect(cancel?.params).toEqual({ id: request?.id });
+	});
+});