diff --git a/AGENTS.md b/AGENTS.md
index 984188308..98b058340 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -160,6 +160,18 @@ Significant changes should have a plan file in `plans/` before implementation
 begins. Plans document the context, approach, and verification steps. Review
 existing plans in that directory for format examples.
 
+## AI Skills
+
+Reusable workflow instructions for AI agents live in `skills/`. Each skill is a
+self-contained folder with a `SKILL.md` and optional supporting assets
+(templates, scripts, references).
+
+| Skill | Purpose |
+|-------|---------|
+| `typescript-code-review` | Perform comprehensive TypeScript code reviews covering type safety, security, performance, and code quality with actionable feedback |
+
+Skills are loaded on-demand when the agent detects a matching task.
+
 ## Agent-First Documentation
 
 AI coding agents are first-class citizens of TKO. The docs site serves both
diff --git a/plans/typescript-code-review-findings-2.md b/plans/typescript-code-review-findings-2.md
new file mode 100644
index 000000000..b73556d20
--- /dev/null
+++ b/plans/typescript-code-review-findings-2.md
@@ -0,0 +1,100 @@
+# Plan: TypeScript Code Review — Findings (Round 2, Deduplicated)
+
+**Risk class:** `MEDIUM`
+
+**Status:** Active Backlog
+
+## Status Update (2026-04-21)
+
+- Updated to current toolchain (Bun + Biome).
+- Removed completed/obsolete items and cross-round duplicates.
+- This file now keeps only Round-2-specific backlog items not promoted as canonical findings in rounds 3–4.
+
+## Stack Baseline (Current)
+
+- Type-check: `bun run tsc`
+- Lint/format: `bun run check`
+- Tests: `bun run test`
+- Unused analysis: `bun run knip`
+
+## Summary
+
+Round 2 currently tracks medium/low-risk cleanup and consistency work that is still relevant,
+but not duplicated in newer findings plans.
+
+## Remaining Round-2 Findings
+
+### Important Improvements 🟡
+
+1. `subscribable.when()` may keep subscription alive forever when condition never becomes true.
+File: `packages/observable/src/subscribable.ts`
+
+2. Duplicate `bindingKey` in apply-bindings error message.
+File: `packages/bind/src/applyBindings.ts`
+
+3. `value.isInput()` checks `this.$element` instead of the parameter.
+File: `packages/binding.core/src/value.ts`
+
+4. Loose equality debt (`==`/`!=`) still needs intentional triage and selective replacement.
+Scope: multiple packages
+
+5. Deprecated `clonePlainObjectDeep` remains exported.
+File: `packages/utils/src/object.ts`
+
+6. `AttributeMustacheProvider.getBindingAccessors` returns `false` for non-element nodes (type-contract mismatch).
+File: `packages/provider.mustache/src/AttributeMustacheProvider.ts`
+Cross-ref: Issue [#235](https://github.com/knockout/tko/issues/235) — re-check against current code before committing to a fix route (per PR #297 review).
+
+7. `Parser` imported as value and downcast via `as any` in component provider path.
+File: `packages/provider.component/src/ComponentProvider.ts`
+PR: [#362](https://github.com/knockout/tko/pull/362) (open)
+
+8. JsxObserver subscription callback ignores callback value.
+File: `packages/utils.jsx/src/JsxObserver.ts`
+
+9. `NativeProvider` redundant null fallback.
+File: `packages/provider.native/src/NativeProvider.ts`
+
+### Suggestions 🔵
+
+10. Unused `SubscriptionCallback` import.
+File: `packages/bind/src/bindingEvent.ts`
+
+11. Legacy `event.returnValue` fallback.
+File: `packages/binding.core/src/submit.ts`
+
+12. `readElseChain()` returns `false` where object shape is expected.
+File: `packages/binding.if/src/else.ts`
+
+13. Redundant `nodeType` check after `instanceof Element`.
+File: `packages/provider.component/src/ComponentProvider.ts`
+
+14. AMD `require` call has no explicit error callback path.
+File: `packages/utils.component/src/loaders.ts`
+PR: [#361](https://github.com/knockout/tko/pull/361) (open)
+
+## De-duplication Rules
+
+- Findings tracked in rounds 3 or 4 must not be re-added here.
+- Fixed findings stay in git history, not in the active list.
+- Obsolete paths (for example removed files) are excluded.
+
+## PR #297 Review — Verification Status
+
+Brian's review flagged five original Round-2 critical findings for independent spot-checking.
+Disposition of each (findings may have been moved to later rounds or resolved via separate PRs):
+
+| Finding | Status | Reference |
+|---------|--------|-----------|
+| Proxy `deleteProperty` trap dropping property key | **Fixed** | PR [#336](https://github.com/knockout/tko/pull/336) (merged) |
+| `??` behaves identically to `||` (earlyOut) | **Fixed** | PR [#345](https://github.com/knockout/tko/pull/345) (merged) ; canonical in Round 3 |
+| Parser operator-precedence inversion | **Fixed** | Issue [#342](https://github.com/knockout/tko/issues/342) (closed); PR [#343](https://github.com/knockout/tko/pull/343) (merged) |
+| `TextInputLegacyFirefox` dead code | **Fixed** | PR [#346](https://github.com/knockout/tko/pull/346) (merged) |
+| `style` binding referencing global `jQuery` | Uses `options.jQuery` (gated) | PR [#339](https://github.com/knockout/tko/pull/339) (merged) |
+
+## Verification
+
+- `bun run tsc`
+- `bun run check`
+- `bun run test`
+- `bun run knip`
diff --git a/plans/typescript-code-review-findings-3.md b/plans/typescript-code-review-findings-3.md
new file mode 100644
index 000000000..96c159750
--- /dev/null
+++ b/plans/typescript-code-review-findings-3.md
@@ -0,0 +1,59 @@
+# Plan: TypeScript Code Review — Findings (Round 3, Deduplicated)
+
+**Risk class:** `MEDIUM`
+
+**Status:** Active Backlog
+
+## Status Update (2026-04-21)
+
+- Updated to current software stack terminology.
+- Kept only canonical Round-3 findings.
+- Removed overlap duplicates with rounds 1, 2, and 4.
+
+## Stack Baseline (Current)
+
+- Type-check: `bun run tsc`
+- Lint/format: `bun run check`
+- Tests: `bun run test`
+
+## Summary
+
+Round 3 focuses on parser-semantics parity and runtime portability concerns.
+It tracks one critical and two important findings that remain canonical for this round.
+
+## Detailed Findings
+
+### Critical Issues 🔴
+
+1. `LifeCycle.__addEventListener` removes listeners with mismatched signature.
+File: `packages/lifecycle/src/LifeCycle.ts`
+
+- Register uses `addEventListener(..., options)` but dispose used `removeEventListener(... )` without options.
+- Capture listeners can remain attached after disposal.
+- PR: [#363](https://github.com/knockout/tko/pull/363) (open)
+
+### Important Improvements 🟡
+
+2. Parser accepts invalid JavaScript mixing of `??` with `||` / `&&` without required parentheses.
+File: `packages/utils.parser/src/operators.ts`
+
+- Native JS requires explicit grouping for these mixes.
+- Current parser accepts and evaluates such expressions.
+- **Independently verified**: `operators['??'].earlyOut = a => a` is identical to `||`'s earlyOut, making `??` short-circuit on any falsy value instead of only `null`/`undefined`. Confirmed bug.
+- PR [#345](https://github.com/knockout/tko/pull/345) (merged) — fixes the earlyOut.
+- PR [#343](https://github.com/knockout/tko/pull/343) (merged) — fixes operator precedence.
+- Issue [#342](https://github.com/knockout/tko/issues/342) (parser operator-precedence, closed).
+
+3. Runtime paths use ambient `document/window` instead of configured options.
+Files:
+- `packages/utils.component/src/loaders.ts`
+- `packages/binding.foreach/src/foreach.ts`
+
+- Should consistently use `options.document` / `options.global` for portability.
+
+## Verification
+
+- `bun run tsc`
+- `bun run check`
+- `bun run test`
+- Targeted parser and lifecycle regression tests for the above paths
diff --git a/plans/typescript-code-review-findings-4.md b/plans/typescript-code-review-findings-4.md
new file mode 100644
index 000000000..45790d487
--- /dev/null
+++ b/plans/typescript-code-review-findings-4.md
@@ -0,0 +1,215 @@
+# Plan: TypeScript Code Review — Findings (Round 4)
+
+**Risk class:** `MEDIUM`
+
+**Status:** Active Backlog
+
+## Status Update (2026-04-21)
+
+- Updated to current toolchain language (Bun + Biome).
+- Deduplicated against rounds 1–3.
+- This file keeps only Round-4-canonical findings.
+
+## Stack Baseline (Current)
+
+- Type-check: `bun run tsc`
+- Lint/format: `bun run check`
+- Tests: `bun run test`
+- Unused analysis: `bun run knip`
+
+## Summary
+
+Round 4 tracks **2 critical bugs**, **8 important improvements**, and **9 suggestions**
+that are not duplicated as canonical findings in rounds 1–3.
+
+## Prior Rounds
+
+For historical context and previously cataloged findings, see:
+
+1. `plans/typescript-code-review-findings.md`
+2. `plans/typescript-code-review-findings-2.md`
+3. `plans/typescript-code-review-findings-3.md`
+
+---
+
+## Detailed Findings
+
+### Critical Issues 🔴
+
+#### 1. `notifyNextChange` closure variable never reset — sticky spurious notifications
+**File**: `packages/observable/src/observable.ts:212`
+- **Issue**: In `subscribable.fn.limit`, the chained assignment
+  `self._notifyNextChange = didUpdate = ignoreBeforeChange = false` writes to
+  the instance property `self._notifyNextChange` — which is never read anywhere
+  in the codebase — instead of resetting the closure variable `notifyNextChange`.
+  Once `_notifyNextChangeIfValueIsDifferent()` sets `notifyNextChange = true`
+  (line 238), it is **never** reset to `false`. Every subsequent call to
+  `finish()` will see `shouldNotify === true` regardless of value equality,
+  causing spurious notifications for any rate-limited or deferred observable.
+- **Verified**: `notifyNextChange` is a closure-scoped `let` (line 194).
+  `self._notifyNextChange` is never read. Confirmed bug.
+- **Current**:
+  ```ts
+  self._notifyNextChange = didUpdate = ignoreBeforeChange = false
+  ```
+- **Recommended**:
+  ```ts
+  notifyNextChange = didUpdate = ignoreBeforeChange = false
+  ```
+
+#### 2. Missing `getOwnPropertyDescriptor` Proxy trap breaks `Object.keys()`, `JSON.stringify()`
+**File**: `packages/computed/src/proxy.ts:47–84`
+- **Issue**: The Proxy defines an `ownKeys` trap returning keys from the source
+  `object`, but no `getOwnPropertyDescriptor` trap. The proxy target is an empty
+  `function () {}`. When `Object.keys(proxy)` is called, the engine calls
+  `ownKeys` (returns real keys), then calls `getOwnPropertyDescriptor` for each —
+  which falls through to the empty function target, returning `undefined`. All
+  keys are filtered out.
+- **Impact**: `Object.keys(proxy)` returns `[]`, `JSON.stringify(proxy)` returns
+  `undefined`, and `{...proxy}` produces `{}`.
+- **Verified**: Confirmed — no `getOwnPropertyDescriptor` trap exists in the
+  handler. The related `deleteProperty` trap bug in the same file was independently
+  confirmed and fixed in PR [#336](https://github.com/knockout/tko/pull/336),
+  validating the review's accuracy for this proxy handler.
+- **Recommended**:
+  ```ts
+  getOwnPropertyDescriptor(_target, prop) {
+    return Object.getOwnPropertyDescriptor(object, prop)
+      ?? Reflect.getOwnPropertyDescriptor(_target, prop)
+  }
+  ```
+
+---
+
+### Important Improvements 🟡
+
+#### 3. Base `Provider.preprocessNode` returns `[node]`, short-circuiting MultiProvider
+**File**: `packages/provider/src/Provider.ts:53–55`
+- **Issue**: The base `Provider.preprocessNode` returns `[node]` (truthy) instead
+  of `null`. In `MultiProvider.preprocessNode`, the first provider returning
+  truthy wins — subsequent providers are never consulted. Any provider inheriting
+  the default claims every node, preventing later providers from preprocessing.
+- **Current**: `return [node]`
+- **Recommended**: `return null`
+
+#### 4. `Text.textNodeReplacement` ignores `textNode` parameter, uses global `document`
+**File**: `packages/provider.mustache/src/mustacheParser.ts:67–70`
+- **Issue**: `Text.textNodeReplacement()` declares zero parameters, but callers
+  pass `textNode`. The argument is silently ignored. Uses global
+  `document.createTextNode(...)` while sibling `Expression.textNodeReplacement`
+  correctly uses `textNode.ownerDocument`. Causes cross-document DOM adoption
+  errors.
+- **Recommended**: Accept `textNode` parameter, use `textNode.ownerDocument`.
+
+#### 5. `VirtualProvider.preprocessNode` removes node unconditionally when `parent` is null
+**File**: `packages/provider.virtual/src/VirtualProvider.ts:21–31`
+- **Issue**: Replacement insertions use `parent?.insertBefore(...)` (no-op when
+  null), but `node.remove()` always executes. Content silently lost.
+- **Recommended**: Early-return `null` when `!parent`.
+
+#### 6. `slotBinding.ts` `getSlot()` returns `Node[]` typed as `Node`
+**File**: `packages/binding.component/src/slotBinding.ts:76–86`
+- **Issue**: `getSlot` declares return type `Node`, but the default-slot fallback
+  returns a filtered `Node[]`.
+- **Recommended**: Correct return type to `Node | Node[]` or normalize.
+
+#### 7. `foreach.ts` `removeNodes` — null `parentNode` dereference
+**File**: `packages/binding.foreach/src/foreach.ts:~413`
+- **Issue**: `removeFn` reads `nodes[0].parentNode` into `parent`, then calls
+  `parent.removeChild()`. If nodes are already detached, throws `TypeError`.
+- **Recommended**: Use `parent?.removeChild(nodes[i])`.
+
+#### 8. `foreach.ts` `makeTemplateNode` bypasses HTML sanitization
+**File**: `packages/binding.foreach/src/foreach.ts:~60`
+- **Issue**: For `<script>` template elements, assigns `sourceNode.text` directly
+  to `parentNode.innerHTML`, bypassing `options.sanitizeHtmlTemplate`,
+  `options.templateSizeLimit`, and `options.allowScriptTagsInTemplates`.
+- **Recommended**: Route through `parseHtmlFragment`.
+- PR: [#352](https://github.com/knockout/tko/pull/352) (open)
+
+#### 9. `LifeCycle.mixInto` copies `constructor`, overwriting target class identity
+**File**: `packages/lifecycle/src/LifeCycle.ts:18–22`
+- **Issue**: `Object.getOwnPropertyNames(mixin)` includes `'constructor'`. Breaks
+  `instance.constructor === TargetClass` and `instanceof` transitivity.
+- **Recommended**: `if (prop === 'constructor') continue`
+
+#### 10. Shell command injection surface in build script
+**File**: `tools/build.ts:14–18`
+- **Issue**: `esbuild()` passes interpolated string to `sh -c`. Shell
+  metacharacters in `package.json` fields are interpreted.
+- **Recommended**: Replace `sh -c` with array-based `Bun.spawn`.
+
+---
+
+### Suggestions 🔵
+
+#### 11. `hasSubscriptionsForEvent` returns `number | undefined`, annotated `boolean`
+**File**: `packages/observable/src/subscribable.ts:155–157`
+- **Recommended**: `return (this._subscriptions[event]?.length ?? 0) > 0`
+
+#### 12. `LifeCycle.addEventListener` crashes when no anchor node is set
+**File**: `packages/lifecycle/src/LifeCycle.ts:60–66`
+- **Recommended**: Throw a clear error message early.
+
+#### 13. `BindingResult.completionPromise` may be `undefined` despite non-optional type
+**File**: `packages/bind/src/BindingResult.ts:5`
+- **Recommended**: Mark as optional or assign `Promise.resolve(this)` for sync.
+
+#### 14. Inconsistent `getBindingAccessors` return types across providers
+**Files**: `provider/src/Provider.ts`, `provider.bindingstring/src/BindingStringProvider.ts`,
+`provider.native/src/NativeProvider.ts`
+- **Recommended**: Standardize to `BindingAccessors | null`.
+
+#### 15. `editScriptItem` typed as `number[]` but is a keyed object
+**File**: `packages/bind/src/arrayToDomNodeChildren.ts:143–148`
+- **Recommended**: Define proper `EditScriptItem` interface.
+
+#### 16. `memoization.ts` variable shadowing of module-level `memos`
+**File**: `packages/utils/src/memoization.ts:6,56`
+- **Recommended**: Rename local to `foundMemos`.
+
+#### 17. ESM import-fix regex over-matches non-JS extensions
+**File**: `tools/build.ts:58`
+- **Recommended**: Use `(?<!\.\w+)` instead of `(?<!\.js)`.
+
+#### 18. Self-referential package import in `extenders.ts`
+**File**: `packages/observable/src/extenders.ts:8`
+- **Recommended**: `import type { ObservableArray } from './observableArray'`
+
+#### 19. Duplicate import from `@tko/utils.jsx` in reference build
+**File**: `builds/reference/src/index.ts:19–20`
+- **Recommended**: Merge into single import statement.
+
+---
+
+## PR #297 Review — Additional Notes
+
+- Brian recommended treating findings plans as separate follow-ups rather than bundling with the skill PR.
+- Each critical finding should be independently verified before locking it in as a plan item.
+- Findings #1 and #2 are confirmed as real bugs (see verification notes above).
+- Open PRs addressing findings from across all rounds: #352 (makeTemplateNode sanitization), #361 (AMD require error callback), #362 (Parser instantiation in ComponentProvider), #363 (LifeCycle removeEventListener options).
+- Merged PRs: #343 (operator precedence), #345 (`??` earlyOut), #346 (TextInputLegacyFirefox), #347 (duplicate options import).
+
+---
+
+## Steps
+
+### Phase 1: Critical Bug Fixes (HIGH priority)
+
+1. Fix `notifyNextChange` closure reset and add focused tests.
+2. Add `getOwnPropertyDescriptor` proxy trap and add focused tests for key enumeration/serialization.
+
+### Phase 2: Important Fixes (MEDIUM priority)
+
+3. Fix findings #3–#10 with package-scoped tests and one full-suite pass.
+
+### Phase 3: Suggestions (LOW priority)
+
+4. Triage findings #11–#19 and land low-risk cleanup separately.
+
+## Verification
+
+- `bun run tsc`
+- `bun run check`
+- `bun run test`
+- `bun run knip`
diff --git a/plans/typescript-code-review-findings-5.md b/plans/typescript-code-review-findings-5.md
new file mode 100644
index 000000000..ba7f20785
--- /dev/null
+++ b/plans/typescript-code-review-findings-5.md
@@ -0,0 +1,196 @@
+# Plan: TypeScript Code Review - Findings (Round 5)
+
+**Risk class:** `MEDIUM`
+
+**Status:** Active Backlog
+
+## Status Update (2026-05-02)
+
+- Reviewed with the TypeScript Code Review skill.
+- Deduplicated against rounds 1-4 before adding findings here.
+- This round focuses on async binding completion correctness, null/empty render paths, and stale cleanup edges.
+
+## Stack Baseline (Current)
+
+- Type-check: `bun run tsc`
+- Lint/format: `bun run check`
+- Tests: `bun run test`
+- Targeted tests: `bunx vitest run <path>`
+
+## Summary
+
+Round 5 tracks **3 critical bugs**, **5 important improvements**, and **1 suggestion** that are not
+canonical findings in rounds 1-4.
+
+## Prior Rounds
+
+For historical context and previously cataloged findings, see:
+
+1. `plans/typescript-code-review-findings.md`
+2. `plans/typescript-code-review-findings-2.md`
+3. `plans/typescript-code-review-findings-3.md`
+4. `plans/typescript-code-review-findings-4.md`
+
+---
+
+## Detailed Findings
+
+### Critical Issues
+
+#### 1. Conditional bindings do not honor the async completion contract
+**File**: `packages/binding.if/src/ConditionalBindingHandler.ts:72-88`
+
+- **Issue**: `render()` does not call `completeBinding()` when `shouldDisplay` is false and there is no else branch.
+  That leaves the `AsyncBindingHandler` promise unresolved for initial `if: false`, `ifnot: true`, or `with: null`.
+- **Second issue**: `renderAndApplyBindings()` does `await applyBindingsToDescendants(...)`, but
+  `applyBindingsToDescendants()` returns a `BindingResult`, not a promise. The await yields immediately and does not
+  wait for `BindingResult.completionPromise`.
+- **Impact**: `applyBindings()` can either hang forever on non-rendering conditional branches or resolve before async
+  descendants finish.
+- **Recommended**: Complete immediately for empty/non-rendering branches. In `renderAndApplyBindings()`, inspect the
+  returned `BindingResult`; await `completionPromise` only when `!bound.isSync`, then call `completeBinding(bound)`.
+- **Regression tests**: Add cases for `if: false`, `ifnot: true`, `with: null`, and an `if` branch containing an async
+  descendant binding.
+
+#### 2. Template binding completion is missing for empty render paths and can complete after the first child only
+**File**: `packages/binding.template/src/templating.ts:106-109, 429-459`
+
+- **Issue**: The `template` binding is an `AsyncBindingHandler`, but `onValueChange()` does not call
+  `completeBinding()` when `shouldDisplay` is false. The `foreach` template path also has no completion callback when
+  the rendered array is empty.
+- **Second issue**: `activateBindingsOnContinuousNodeArray()` calls `applyBindings(...).then(afterBindingCallback)` once
+  per top-level rendered node. The first node to finish can resolve the parent binding while sibling top-level nodes are
+  still applying async bindings.
+- **Impact**: Server/prerender callers and users awaiting `ko.applyBindings()` get unreliable completion: some empty
+  templates never complete, while multi-root templates can complete early.
+- **Recommended**: Aggregate the promises returned by all top-level `applyBindings()` calls and invoke the completion
+  callback once after all complete. Explicitly complete empty, false, and empty-foreach render paths.
+- **Regression tests**: Cover `template: { if: false }`, `template: { foreach: [] }`, and a multi-root template where a
+  later sibling has an async binding.
+
+#### 3. `foreach` resolves before async descendants because `BindingResult` objects are passed to `Promise.all`
+**File**: `packages/binding.foreach/src/foreach.ts:336-354`
+
+- **Issue**: `added()` pushes the return value from `applyBindingsToDescendants()` into `asyncBindingResults`, then calls
+  `Promise.all(asyncBindingResults)`. Those values are `BindingResult` objects, not promises, so `Promise.all()` resolves
+  immediately.
+- **Impact**: `applyBindings()` can resolve before async descendants inside `foreach` items finish. This weakens the
+  binding completion promise that tests, SSR, and automation depend on.
+- **Recommended**: Push `bindingResult.completionPromise` for non-sync results and a resolved value for sync results.
+  Prefer the configured promise constructor consistently when possible.
+- **Regression tests**: Add a `foreach` item with a descendant async binding and assert the outer `applyBindings()`
+  promise waits for it.
+
+### Important Improvements
+
+#### 4. `foreach` crashes on nullish data instead of treating it as an empty list
+**File**: `packages/binding.foreach/src/foreach.ts:119-151, 230-256`
+
+- **Issue**: The constructor and `processQueue()` read `unwrap(this.data).length` without normalizing nullish values.
+  `foreach: null` and observable arrays set to `null` can throw.
+- **Impact**: This diverges from the legacy template foreach behavior, where `null` means "no items". In the reference
+  build, `foreach` is provided by `@tko/binding.foreach`, so this is user-facing.
+- **Recommended**: Normalize `unwrap(this.data) || []` anywhere list length is read, and keep `elseChainSatisfied` false
+  for nullish lists.
+- **Regression tests**: Add `foreach: null`, `foreach: undefined`, and observable list transitions from populated to
+  `null`.
+
+#### 5. Virtual `html` binding does not clear existing content for nullish values
+**File**: `packages/utils/src/dom/html.ts:98-143`
+
+- **Issue**: `setHtml()` calls `emptyDomNode(node)` before checking the new value. That clears real elements, but not
+  virtual elements because a comment node has no `firstChild`. The later `virtualElements.emptyNode(node)` branch is
+  unreachable for `null` because it is nested under `if (html !== null && html !== undefined)`.
+- **Impact**: `<!-- ko html: value --><!-- /ko -->` leaves stale DOM in place when `value` changes from HTML to
+  `null` or `undefined`.
+- **Recommended**: For comment nodes, call `virtualElements.emptyNode(node)` before returning on nullish HTML.
+- **Regression tests**: Add a virtual `html` binding that first renders markup and then updates to `null`.
+
+#### 6. Async binding code bypasses `options.Promise` and rejects cross-realm/thenable promises
+**Files**:
+- `packages/bind/src/BindingHandler.ts:118`
+- `packages/bind/src/applyBindings.ts:382, 418, 501`
+- `packages/bind/src/BindingResult.ts:21-22`
+- `packages/computed/src/when.ts:18`
+- `packages/observable/src/subscribable.ts:207-208`
+- `packages/utils.jsx/src/JsxObserver.ts:404`
+
+- **Issue**: Several async paths use native `Promise`, and `applyBindings` only records async binding completion when
+  `bindingHandler.bindingCompleted instanceof Promise`.
+- **Impact**: A custom `options.Promise`, cross-window promises, or thenables can be ignored or wrapped by the wrong
+  constructor. The existing "returns a promise" test only proves the default case where `options.Promise === Promise`.
+- **Recommended**: Use a shared thenable check (for example `isThenable`) for completion detection and route framework
+  promise creation through `options.Promise`. Alternativ, you
+  should remove this unused old option.
+- **Regression tests**: Temporarily replace `options.Promise` with a compatible custom constructor and assert
+  `applyBindings()` waits for async bindings.
+
+#### 7. `Subscription.dispose()` is not idempotent
+**File**: `packages/observable/src/Subscription.ts:20-26`
+
+- **Issue**: Repeated `dispose()` calls keep invoking `_disposeCallback()`. For normal subscriptions this repeats
+  `afterSubscriptionRemove` even though the subscription has already been removed.
+- **Impact**: Pure computeds and subscription-count-sensitive code can observe duplicate removal notifications, and DOM
+  disposal callbacks can be removed more than once.
+- **Recommended**: Return early when `_isDisposed` is already true; clear `_domNodeDisposalCallback` after removing it.
+- **Regression tests**: Dispose the same subscription twice and assert `afterSubscriptionRemove` and callback removal
+  happen only once.
+
+#### 8. JSX attribute subscriptions can outlive the current attribute set
+**File**: `packages/utils.jsx/src/JsxObserver.ts:362-376`
+
+- **Issue**: `updateAttributes()` appends subscriptions for observable attribute values but does not dispose previous
+  subscriptions when an attribute is removed or replaced by a different observable.
+- **Impact**: A stale observable can later re-add or overwrite an attribute that no longer exists in the JSX attributes
+  object, and the old subscription remains alive until the whole node is removed.
+- **Not a duplicate**: Round 2 tracks the callback-value concern in this area. This finding is specifically about
+  subscription lifetime and stale attribute ownership.
+- **Recommended**: Track attribute subscriptions by attribute name and dispose the prior subscription before replacing
+  or removing that attribute.
+- **Regression tests**: Render an observable attributes object, replace/remove an observable attribute, then update the
+  old observable and assert the DOM is unchanged.
+
+### Suggestions
+
+#### 9. `safeStringify()` treats repeated `null` values as circular references
+**File**: `packages/utils/src/object.ts:88-98`
+
+- **Issue**: The JSON replacer calls `seen.has(v)` before checking whether `v` is object-like, then adds all values whose
+  `typeof` is `'object'`. Because `typeof null === 'object'`, repeated nulls are serialized as `"..."`.
+- **Impact**: `safeStringify([null, null])` would produce a misleading second entry. This is low risk but surprising for
+  a utility exported by `@tko/utils`.
+- **Recommended**: Only consult and update `seen` for non-null objects.
+- **Regression tests**: Add coverage for repeated `null`, repeated primitives, and a true circular object.
+
+---
+
+## Steps
+
+### Phase 1: Async Completion Contract
+
+1. Fix conditional, template, and foreach completion semantics with focused tests.
+2. Add a small shared helper for extracting a promise from `BindingResult` values.
+3. Re-run `packages/bind`, `packages/binding.if`, `packages/binding.template`, and `packages/binding.foreach` specs.
+
+### Phase 2: Runtime Correctness
+
+4. Normalize nullish `foreach` data and add reference-build coverage.
+5. Fix virtual `html` null clearing and add core binding coverage.
+6. Make subscription disposal idempotent.
+
+### Phase 3: Cleanup
+
+7. Standardize promise/thenable detection around `options.Promise`.
+8. Rework JSX attribute subscription ownership.
+9. Patch `safeStringify()` null handling.
+
+## Verification
+
+- `bunx vitest run packages/bind/spec/bindingCompletionPromiseBehavior.ts`
+- `bunx vitest run packages/binding.if`
+- `bunx vitest run packages/binding.template`
+- `bunx vitest run packages/binding.foreach`
+- `bunx vitest run packages/binding.core`
+- `bunx vitest run packages/observable`
+- `bun run tsc`
+- `bun run check`
diff --git a/plans/typescript-code-review-findings.md b/plans/typescript-code-review-findings.md
new file mode 100644
index 000000000..c6730a99d
--- /dev/null
+++ b/plans/typescript-code-review-findings.md
@@ -0,0 +1,36 @@
+# Plan: TypeScript Code Review — Findings (Round 1, Archived)
+
+**Risk class:** `MEDIUM`
+
+**Status:** Archived (superseded by rounds 2–4)
+
+## Status Update (2026-04-21)
+
+- This file is kept as historical context only.
+- Detailed actionable findings were migrated into later rounds.
+- Duplicate finding entries were removed from this round to keep one canonical location per finding.
+
+## Stack Baseline (Current)
+
+- Package manager / runner: `bun`
+- Lint + format: `bun run check` (Biome)
+- Type-check: `bun run tsc`
+- Tests: `bun run test`
+
+## Historical Scope
+
+Round 1 covered broad TS quality, deprecations, and framework-internal robustness.
+The concrete actionable findings are now maintained in:
+
+1. `plans/typescript-code-review-findings-2.md`
+2. `plans/typescript-code-review-findings-3.md`
+3. `plans/typescript-code-review-findings-4.md`
+
+## Active Findings In This File
+
+None. This round is intentionally de-duplicated and archival.
+
+## Notes
+
+- Do not add new findings here.
+- Add newly discovered items to the newest active findings plan.
diff --git a/skills/typescript-code-review/SKILL.md b/skills/typescript-code-review/SKILL.md
new file mode 100644
index 000000000..17883ffe7
--- /dev/null
+++ b/skills/typescript-code-review/SKILL.md
@@ -0,0 +1,137 @@
+---
+name: typescript-code-review
+description: Perform comprehensive code reviews for LLM-based linting of TypeScript projects. Analyzing type safety, best practices, clientside security and code quality. Result are actionable and ranked findings.
+---
+
+# TypeScript Code Review Skill
+
+## Review Process
+
+### 1. Initial Assessment
+- Understand purpose, scope, TS version, and `tsconfig.json` settings
+- Check for relevant docs, comments, and existing patterns
+
+### 2. Core Review Categories
+
+#### Type Safety
+- Verify `strict: true` and adherence; flag implicit `any`
+- Type guards, narrowing, and exhaustiveness checking for unions
+- Flag unnecessary type assertions (`as`, `!`); prefer `satisfies` or `instanceof`
+- Proper `?.` and `??` usage; explicit return types on functions
+- Generics constrained appropriately; discriminated unions with `type` field
+
+#### Code Quality
+- **Naming**: camelCase vars/fns, PascalCase types/classes; `is`/`has` for booleans; `get` for sync accessors, `fetch` for async IO; `is` for type predicates
+- **Functions**: max ~50 lines, max 3 params (use options object for more), no boolean flag params, prefer pure functions
+- **Constants**: no magic numbers/strings; use named constants
+- **Equality**: `===`/`!==` only (no `==`)
+- **Errors**: throw `Error` objects only; handle promise rejections
+- **Immutability**: prefer `const`, spread over mutation
+- **Enums**: prefer union types or `as const` lookup tables (enums emit runtime code)
+- **Defaults**: use ES6 parameter defaults, destructuring, spread
+
+#### Code Organization
+- Prefer `function` declarations at file scope (hoisting, stack traces); arrows for callbacks
+- Guard clauses / early returns over deep nesting (max 3-4 levels)
+- Import order: external libs → workspace packages → relative → type-only
+- `import type` mandatory with `verbatimModuleSyntax`
+- File order: constants → types → setup → functions → exports
+- `interface` for object shapes; `type` for unions/intersections/mapped types
+- String unions for fixed value sets
+
+#### Modern TS Features
+- `?.`, `??`, template literal types, utility types (`Partial`, `Pick`, `Omit`, `Record`)
+- `as const` for literal types and lookup tables; `satisfies` for validation
+- Type predicates for custom guards
+
+#### Security
+- Validate/sanitize user input at system boundaries; no `innerHTML` with untrusted data; no `eval`
+- No hardcoded secrets, tokens, or API keys — use environment variables
+- Strip sensitive fields before exposing data: `Omit<User, 'password'>`
+- Don't log sensitive data (passwords, tokens, PII)
+- Types as security layer: union types for allowed values, type guards at boundaries
+- `npm audit` dependencies; minimize count; review new packages before adding
+
+#### Testing & Maintainability
+- Note missing tests for critical paths; flag circular dependencies
+- Use `import type` for type-only imports; verify JSDoc on public APIs
+
+### 3. Output Format
+
+```markdown
+## Summary
+[Overview: quality, main concerns, highlights]
+
+## Critical Issues 🔴
+[Must fix: type errors, security vulns, bugs]
+
+## Important Improvements 🟡
+[Maintainability, performance, anti-patterns]
+
+## Suggestions 🔵
+[Nice-to-have: style, optimizations]
+
+## Positive Observations ✅
+[Good patterns to reinforce]
+
+## Detailed Findings
+### [Category]
+**File**: `path/file.ts:line`
+- **Issue**: [Description]
+- **Current**: `[code]`
+- **Recommended**: `[improved code]`
+- **Why**: [Reasoning]
+```
+
+### 4. Guidelines
+- Constructive, specific, with code examples. Severity: 🔴 critical → 🟡 important → 🔵 suggestion
+- Priority: security/bugs → anti-patterns → style
+- Respect existing patterns; note tradeoffs; reference tsconfig
+
+### 5. References
+
+Grep references for specific topics:
+- `references/review-reference.md` — type safety checklist, anti-patterns with bad/good examples
+- `references/tko-conventions.md` — TKO monorepo-specific patterns and overrides
+- `AGENTS.md` — when to use this skill vs others
+
+### 6. tsconfig Review
+
+Recommended strict settings: `strict`, `noUncheckedIndexedAccess`, `noImplicitOverride`,
+`noPropertyAccessFromIndexSignature`, `exactOptionalPropertyTypes`,
+`noFallthroughCasesInSwitch`, `noImplicitReturns`, `noUnusedLocals`, `noUnusedParameters`.
+
+### 7. TKO Monorepo Conventions
+
+When reviewing TKO code, apply these overrides:
+
+**Architecture** (do NOT flag):
+- Factory-function-as-constructor with `Object.setPrototypeOf` / `.fn` prototypes — core pattern
+- Module-level side effects (prototype wiring, Symbol polyfills) — essential
+- Pervasive `any` — accepted tech debt (`no-explicit-any: off`, `noImplicitAny: false`). Flag only in net-new code
+- `prefer-const` is off — `let` for never-reassigned vars is fine
+- No enums, no `readonly`, minimal `as const` in existing code
+
+**DO flag**:
+- Missing `import type` (mandatory: `verbatimModuleSyntax: true`)
+- Missing DOM disposal (`disposeWhenNodeIsRemoved`, `addDisposeCallback`, `LifeCycle.anchorTo()`)
+- Violations of centralized error handling (`options.onError` pattern)
+
+**Testing**: Mocha/Chai/Sinon (not Jasmine); vitest; tests in `packages/*/spec/`.
+**Zero runtime deps**: never suggest external packages for core `@tko/*` packages.
+
+See `references/tko-conventions.md` for full details.
+
+### 8. Review Workflow
+
+1. Scan critical issues (type errors, security, bugs)
+2. Review architecture (modules, boundaries, separation of concerns)
+3. Deep-dive logic (correctness, edge cases, error handling)
+4. Check types (accuracy, safety, TS feature usage)
+5. Style/consistency (naming, formatting, patterns)
+6. Testing/docs (coverage, clarity)
+
+## When to Use
+
+Activate when user asks for code review, feedback on TS implementation,
+checking for issues/bugs, or ensuring best practices.
diff --git a/skills/typescript-code-review/references/review-reference.md b/skills/typescript-code-review/references/review-reference.md
new file mode 100644
index 000000000..3dba05eb9
--- /dev/null
+++ b/skills/typescript-code-review/references/review-reference.md
@@ -0,0 +1,422 @@
+# TypeScript Review Reference
+
+Combined type-safety checklist and anti-pattern catalog. Grep for specific topics.
+
+---
+
+## tsconfig — Strict Settings
+
+```json
+{
+  "strict": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true,
+  "noPropertyAccessFromIndexSignature": true, "exactOptionalPropertyTypes": true,
+  "noFallthroughCasesInSwitch": true, "noImplicitReturns": true,
+  "noUnusedLocals": true, "noUnusedParameters": true
+}
+```
+
+---
+
+## Type Annotations & `any`
+
+### ❌ `any` as escape hatch → `unknown` + type guard
+```typescript
+// Bad
+function process(data: any) { return data.value * 2 }
+// Good
+function process(data: unknown): number {
+  if (isData(data)) return data.value * 2
+  throw new Error('Invalid data')
+}
+function isData(d: unknown): d is { value: number } {
+  return typeof d === 'object' && d !== null && 'value' in d
+    && typeof (d as any).value === 'number'
+}
+```
+
+### ❌ Excessive type assertions → validate with guards
+```typescript
+// Bad
+const user = data as User
+// Good
+function isUser(d: unknown): d is User {
+  return typeof d === 'object' && d !== null && 'name' in d
+}
+if (isUser(data)) { /* data is User */ }
+```
+
+### ❌ Over-specifying inferred types
+```typescript
+// Bad: const name: string = 'Alice'
+// Good: const name = 'Alice'  — still annotate function params/returns
+```
+
+### ✅ Explicit return types on all functions
+```typescript
+// Bad
+function total(items: Item[]) { return items.reduce((s, i) => s + i.price, 0) }
+// Good
+function total(items: Item[]): number { return items.reduce((s, i) => s + i.price, 0) }
+```
+
+---
+
+## Null / Undefined Handling
+
+### ✅ Optional chaining (`?.`) over manual null chains
+```typescript
+// Bad: const street = user && user.address && user.address.street
+// Good: const street = user?.address?.street
+```
+
+### ✅ Nullish coalescing (`??`) over logical OR
+```typescript
+// Bad: const name = user.name || 'Guest'   — replaces '', 0, false
+// Good: const name = user.name ?? 'Guest'  — only null/undefined
+```
+
+### ❌ Non-null assertion (`!`) → handle the null case
+```typescript
+// Bad: const el = document.getElementById('x')!
+// Good
+const el = document.getElementById('x')
+if (!el) throw new Error('Element not found')
+```
+
+---
+
+## Enums, Unions & Literal Types
+
+### ❌ Regular enums → union types or `as const` lookup tables
+```typescript
+// Bad: enum Status { Pending, Approved }  — emits runtime code
+// Good — union type
+type Status = 'pending' | 'approved'
+// Good — lookup table (provides both values and types)
+const Status = { Pending: 'PENDING', Approved: 'APPROVED' } as const
+type Status = typeof Status[keyof typeof Status]
+```
+
+### ❌ Missing discriminated union → add `type` field
+```typescript
+// Bad: type Result = { data: string } | { error: string }
+// Good
+type Result =
+  | { type: 'ok'; data: string }
+  | { type: 'err'; error: string }
+```
+
+### ✅ Exhaustiveness checking in switch
+```typescript
+function handle(r: Result): string {
+  switch (r.type) {
+    case 'ok': return r.data
+    case 'err': throw new Error(r.error)
+    default: const _: never = r; throw new Error('Unhandled')
+  }
+}
+```
+
+### ✅ String unions for fixed value sets
+```typescript
+// Bad: function setTheme(theme: string) {}
+// Good: function setTheme(theme: 'light' | 'dark' | 'system') {}
+```
+
+### ❌ Missing `as const` for literal config
+```typescript
+// Bad — loses literal types
+const CONFIG = { apiUrl: 'https://api.example.com', timeout: 5000 }
+// Good — preserves literal types, readonly
+const CONFIG = { apiUrl: 'https://api.example.com', timeout: 5000 } as const
+```
+
+---
+
+## Generics
+
+### ✅ Constrain generics
+```typescript
+// Bad: function get<T>(obj: T, key: string) { return obj[key] }
+// Good
+function get<T extends Record<string, unknown>, K extends keyof T>(obj: T, key: K): T[K] {
+  return obj[key]
+}
+```
+
+### ✅ Use generic defaults
+```typescript
+interface Response<T = unknown> { data: T; status: number }
+```
+
+---
+
+## Object Types & Utility Types
+
+### ✅ `interface` for object shapes; `type` for unions/intersections
+```typescript
+// Good — interface for objects
+interface User { id: string; name: string; email: string }
+// Good — type for unions and mapped types
+type Status = 'active' | 'inactive'
+type WithTimestamp<T> = T & { createdAt: Date }
+```
+
+### ✅ Use utility types: `Pick`, `Omit`, `Partial`, `Required`, `Readonly`, `Record`
+```typescript
+type PublicUser = Omit<User, 'password'>
+type UserUpdate = Partial<Pick<User, 'name' | 'email'>>
+```
+
+---
+
+## Arrays & Tuples
+
+### ✅ Type arrays explicitly
+```typescript
+// Bad: const items = []        — inferred as any[]
+// Good: const items: Item[] = []
+```
+
+### ✅ Tuples for fixed-length
+```typescript
+type Point = [x: number, y: number]
+```
+
+### ✅ Safe indexing with `noUncheckedIndexedAccess`
+```typescript
+const first = items[0]  // Type: Item | undefined — handle the undefined
+if (first !== undefined) { use(first) }
+```
+
+---
+
+## Assertions & Narrowing
+
+### ❌ `as T` assertions → use `instanceof`, `in`, or custom type guards
+```typescript
+// Bad: const el = document.getElementById('x') as HTMLInputElement
+// Good
+const el = document.getElementById('x')
+if (el instanceof HTMLInputElement) { el.value = 'text' }
+```
+
+### ✅ `satisfies` (TS 4.9+) — validates structure, preserves literal types
+```typescript
+const config = {
+  apiUrl: 'https://api.example.com',
+  timeout: 5000
+} satisfies Record<string, string | number>
+// config.apiUrl is 'https://api.example.com', not string
+```
+
+---
+
+## Functions
+
+### ❌ Too many parameters → options object
+```typescript
+// Bad: function create(id: string, name: string, email: string, age: number) {}
+// Good
+interface CreateParams { id: string; name: string; email: string; age: number }
+function create(params: CreateParams) {}
+```
+
+### ❌ Boolean flag parameters → separate functions
+```typescript
+// Bad: function getUsers(includeInactive: boolean) {}
+// Good
+function getAllUsers() {}
+function getActiveUsers() {}
+```
+
+### ❌ Arrow functions at file level → function declarations
+```typescript
+// Bad: const process = (items: Item[]) => items.map(transform)
+// Good: function process(items: Item[]) { return items.map(transform) }
+// Why: hoisting + better stack traces; arrows for callbacks only
+```
+
+### ❌ Manual undefined checks → default parameters
+```typescript
+// Bad: const t = timeout !== undefined ? timeout : 5000
+// Good: function fn(timeout = 5000) {}
+```
+
+### ❌ Optional before required params
+```typescript
+// Bad: function create(name?: string, id: string) {}
+// Good: function create(id: string, name?: string) {}
+```
+
+---
+
+## Arrays & Objects — Immutability
+
+### ❌ Mutating arrays → spread
+```typescript
+// Bad: items.push(newItem); return items
+// Good: return [...items, newItem]
+```
+
+### ❌ `forEach` for transforms → `map`/`filter`/`reduce`
+```typescript
+// Bad
+const names: string[] = []
+users.forEach(u => names.push(u.name))
+// Good
+const names = users.map(u => u.name)
+```
+
+### ❌ `Object.assign` mutation → spread
+```typescript
+// Bad: Object.assign(user, updates); return user
+// Good: return { ...user, ...updates }
+```
+
+### ❌ `delete` operator → destructuring rest
+```typescript
+// Bad: delete result.password; return result
+// Good: const { password, ...rest } = result; return rest
+```
+
+---
+
+## Classes
+
+### ❌ Classes for plain data → interface + factory
+```typescript
+// Bad
+class User { constructor(public id: string, public name: string) {} }
+// Good — when there's no behavior
+interface User { id: string; name: string }
+function createUser(id: string, name: string): User { return { id, name } }
+```
+
+### ✅ Parameter properties for classes with behavior
+```typescript
+class Service {
+  constructor(private readonly logger: Logger, private config: Config) {}
+}
+```
+
+---
+
+## Imports / Exports
+
+### ❌ Missing `import type` (build error with `verbatimModuleSyntax`)
+```typescript
+// Bad: import { User } from './types'   — if User is type-only
+// Good: import type { User } from './types'
+```
+
+### ❌ Barrel exports with side effects → import from specific modules
+```typescript
+// Bad: import { oneFunction } from './modules'  — loads all re-exports
+// Good: import { oneFunction } from './modules/specific'
+```
+
+### ❌ Circular dependencies → extract shared code to third module
+
+---
+
+## Error Handling
+
+### ❌ Catch without typing
+```typescript
+// Bad: catch (e) { console.log(e.message) }
+// Good
+catch (error) {
+  if (error instanceof Error) console.log(error.message)
+  else console.log('Unknown error')
+}
+```
+
+### ❌ Throwing strings → always `throw new Error(msg)`
+```typescript
+// Bad: throw 'User not found'
+// Good: throw new Error('User not found')
+```
+
+---
+
+## Structure & Design
+
+### ❌ Deep nesting → guard clauses / early returns
+```typescript
+// Bad
+if (user) { if (active) { if (email) { send(email) } } }
+// Good
+if (!user) return 'No user'
+if (!active) return 'Inactive'
+if (!email) return 'No email'
+send(email)
+```
+
+### ❌ `==` → always `===`
+```typescript
+// Bad: if (count == '0') {}   — type coercion: 0 == '' is true
+// Good: if (count === 0) {}
+```
+
+### ❌ Unencapsulated mutable globals → wrap in closure or class
+```typescript
+// Bad
+let current: User | null = null
+export function set(u: User) { current = u }
+// Good
+function createStore() {
+  let current: User | null = null
+  return { set(u: User) { current = u }, get() { return current } }
+}
+export const userStore = createStore()
+```
+
+---
+
+## Testing
+
+### ❌ `any` in tests → use proper types for mocks
+```typescript
+// Bad: const mock: any = { name: 'Alice' }
+// Good: const mock: User = { id: '1', name: 'Alice', email: 'a@b.com' }
+```
+
+### ✅ `@ts-expect-error` to verify type rejections
+```typescript
+// @ts-expect-error — should not accept number
+createUser(123)
+```
+
+---
+
+## Review Checklist
+
+### Type Safety
+- [ ] Explicit return types on functions
+- [ ] No implicit `any`; `unknown` + guards for unknown data
+- [ ] `?.` and `??` for null handling; no `!` assertions
+- [ ] Type guards for union narrowing; exhaustiveness in switches
+- [ ] Constrained generics; generic defaults where appropriate
+- [ ] Safe array indexing (`noUncheckedIndexedAccess`)
+- [ ] `satisfies` over `as` assertions where possible
+- [ ] `as const` for literal/lookup types; no regular enums
+- [ ] `interface` for objects, `type` for unions/mapped
+- [ ] `import type` for type-only imports
+- [ ] String unions for fixed value sets
+- [ ] Bool vars prefixed `is`/`has`/`can`/`should`
+
+### Code Quality
+- [ ] Function declarations at file scope; arrows for callbacks only
+- [ ] Max ~50 lines / 3 params per function; options object for more
+- [ ] No boolean flag params; no magic numbers/strings
+- [ ] `===` only; `Error` objects only; no unhandled rejections
+- [ ] Immutable ops (spread, not mutation); `const` default
+- [ ] Guard clauses over deep nesting
+- [ ] No circular dependencies; proper import grouping
+
+### Security
+- [ ] External input validated at boundaries; no `innerHTML` with untrusted data
+- [ ] No `eval`; no hardcoded secrets
+- [ ] Sensitive fields stripped; no PII in logs
+- [ ] Dependencies audited and minimal
diff --git a/skills/typescript-code-review/references/tko-conventions.md b/skills/typescript-code-review/references/tko-conventions.md
new file mode 100644
index 000000000..69792684c
--- /dev/null
+++ b/skills/typescript-code-review/references/tko-conventions.md
@@ -0,0 +1,171 @@
+# TKO Monorepo Conventions
+
+Review guidelines specific to the TKO (Technical Knockout) monorepo. TKO is a
+TypeScript MVVM framework for data binding and templating — the next generation
+of Knockout.js.
+
+## Core Architecture
+
+### Factory-Function-as-Constructor Pattern
+
+TKO's core primitives (`observable`, `computed`, `subscribable`) use factory
+functions that return callable function-objects, not class instances. Prototypes
+are wired up via `Object.setPrototypeOf`. This is currently acceptable for reasons of
+compatibility with Knockout.
+
+```typescript
+// This is idiomatic TKO — NOT an anti-pattern
+export function observable(initialValue) {
+  function obs() { /* ... */ }
+  Object.setPrototypeOf(obs, observable.fn)
+  obs[LATEST_VALUE] = initialValue
+  return obs
+}
+
+observable.fn = { /* shared methods */ }
+Object.setPrototypeOf(observable.fn, subscribable.fn)
+```
+
+**Do NOT flag**: `Object.setPrototypeOf`, `.fn` prototype objects, factory functions
+returning function-objects.
+
+### Module-Level Side Effects
+
+Some modules intentionally execute code at import time:
+- Prototype chain wiring (`Object.setPrototypeOf` calls)
+- `Symbol.observable` polyfill in subscribable
+- Prototype extension via `.fn` objects
+
+**Do NOT flag** these as "avoid side effects." They are essential architecture.
+
+### Symbol-Based Unique Keys
+
+TKO uses `Symbol()` and `createSymbolOrString()` for unique keys on objects
+rather than string literals or enums:
+
+```typescript
+const LATEST_VALUE = Symbol('LatestValue')
+const computedState = Symbol('ComputedState')
+const SUBSCRIBABLE_SYM = Symbol('Subscribable')
+```
+
+This is the preferred discriminator pattern.
+
+---
+
+## TypeScript Configuration
+
+Key settings to be aware of:
+
+| Setting | Value | Implication |
+|---------|-------|-------------|
+| `strict` | `true` | Strict mode enabled |
+| `verbatimModuleSyntax` | `true` | `import type` is mandatory for type-only imports |
+| `noEmit` | `true` | esbuild handles compilation; `tsc` only type-checks |
+| `target` | `ES2022` | ES2022 output target |
+
+
+### `import type` Enforcement
+
+`verbatimModuleSyntax: true` means type-only imports **must** use `import type`.
+Cross-package type imports always use this form:
+
+```typescript
+// Correct
+import type { Observable } from '@tko/observable'
+
+// Wrong — will cause build errors
+import { Observable } from '@tko/observable'  // if Observable is type-only
+```
+
+---
+
+## DOM & Reactive Patterns
+
+### Disposal is Critical
+
+Every subscription or computed tied to a DOM node must have disposal wired up.
+Missing disposal causes memory leaks.
+
+```typescript
+// LifeCycle-based binding — disposal is automatic via anchorTo()
+class myBinding extends BindingHandler {
+  constructor(params) {
+    super(params)
+    this.computed(() => {
+      // auto-disposes when DOM node is removed
+    })
+  }
+}
+
+// Manual subscription — must wire up disposal
+const sub = someObservable.subscribe(callback)
+addDisposeCallback(element, () => sub.dispose())
+```
+
+**Always check**: Is there a `disposeWhenNodeIsRemoved`, `addDisposeCallback`, or
+`LifeCycle.anchorTo()` for every subscription created in a binding handler?
+
+### Centralized Error Handling
+
+Errors flow through `options.onError` — a global error handler. Functions are
+wrapped with `catchFunctionErrors()`. Per-site `try/catch` is used sparingly
+and only in critical paths (computed evaluation, binding init).
+
+Do not suggest adding try/catch to every function. Respect the delegation pattern.
+
+### Binding Handler Styles
+
+Both patterns are valid in the codebase:
+
+```typescript
+// Modern: class-based
+class value extends BindingHandler {
+  constructor(params) { super(params) }
+  get controlsDescendants() { return false }
+}
+
+// Legacy: plain object with init/update
+const textInput = {
+  init(element, valueAccessor) { /* ... */ },
+  update(element, valueAccessor) { /* ... */ }
+}
+```
+
+---
+
+## Naming Conventions
+
+| Category | Convention | Examples |
+|----------|-----------|----------|
+| Files (general) | camelCase | `observable.ts`, `bindingContext.ts` |
+| Files (classes) | PascalCase | `BindingHandler.ts`, `LifeCycle.ts` |
+| Variables/functions | camelCase | `arrayForEach`, `registerDependency` |
+| Classes | PascalCase | `BindingHandler`, `Subscription` |
+| Interfaces/Types | PascalCase (no `I` prefix) | `Observable`, `ComputedOptions` |
+| Binding handlers | lowercase matching binding name | `value`, `textInput`, `css` |
+| Symbols/constants | UPPER_SNAKE_CASE | `LATEST_VALUE`, `DISPOSED_STATE` |
+| Private members | underscore prefix | `_subscriptions`, `_isDisposed` |
+
+---
+
+## Package Conventions
+
+- Inter-package deps use `@tko/package-name` (npm workspaces)
+- **Zero runtime dependencies** — never add external packages to core
+- **Named exports** are strongly preferred (~281 inline vs ~29 default)
+- **Barrel files** (`index.ts`) re-export via `export *` and `export type { ... }`
+
+## Testing
+
+- **Runner**: Vitest + Playwright
+- **Test location**: `packages/*/spec/**/*.ts` and `builds/*/spec/**/*.js`
+- Coverage target: ~89% statements, ~83% branches
+
+## Code Style
+
+- Run `bun run format` before committing
+
+## References
+
+- More Examples are located under `/tko.io/public/`
diff --git a/tsconfig.json b/tsconfig.json
index 7f50389d1..fb4ddc0fc 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -33,6 +33,8 @@
     "builds",
     "docs",
     "tools",
-    "tko.io"
+    "tko.io",
+    "skills",
+    "plans"
   ]
 }