pi-continual-harness 0.20.0 → 0.22.0

package/CHANGELOG.md

@@ -0,0 +1,1035 @@
+# Changelog
+
+All notable changes to **pi-continual-harness** are documented here. The format
+follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the
+project adheres to [Semantic Versioning](https://semver.org/).
+
+Releases are tag-driven (`vX.Y.Z`) and published by GitHub Actions via npm
+Trusted Publishing. This file begins at 0.7.0; earlier releases are recorded in
+the git tags (`git tag -l`) and the [GitHub release history](https://github.com/pungggi/pi-continual-harness/releases).
+
+## [0.22.0] — 2026-11-11
+
+### Added
+
+- **Classifier auto-discovery** (pi ≥ 1.5.1 interplay): when `classifier.model`
+  is unset, the classifier seam now falls back to a single known-good hosted
+  classifier — `github-copilot/microsoft-decision-1`, shipped by pi 1.5.1+
+  with GitHub Copilot auth — so classifier-confirmed dedupe and the auto-refine
+  gate work with zero setup for Copilot users. Discovery deliberately never
+  picks a local llama.cpp entry (the catalog can list one while no server
+  runs). An explicit `classifier.model` always wins; `"classifier": { "auto":
+  false }` restores explicit-only. `/harness status` and the setup/reminder
+  copy now treat the gate as the only required key when discovery is on.
+- **Determinism contract for the injected block** (pinned by a test): for an
+  unchanged store + config, `renderHarnessBlock` is byte-identical. This is
+  what lets pi 1.5.1+'s Anthropic message threads `continue` a conversation —
+  the thread-prefix hash covers the system prompt, so unchanged harness state
+  rides the server-side thread and the warmed prompt cache, while any harness
+  change mismatches the hash and pi correctly falls back to a full resend.
+  Idle prompt-cache warming (pi 1.5.1) similarly keeps the injected system
+  prefix warm between runs — no package change needed, both verified against
+  the pi-ai 1.5.2 source.
+- Dev dependencies bumped to `@earendil-works/pi-*` `^1.5.2` (runtime peers
+  stay `>=1.2.0`; nothing 1.5-only is imported at runtime).
+
+## [0.21.0] — 2026-11-07
+
+### Added
+
+- **CI on every push/PR** (`.github/workflows/ci.yml`): typecheck + lint +
+  tests with coverage + build, so breakage is caught before a release tag —
+  previously verification only ran at publish time in `release.yml`.
+- **Biome** for lint + format (`biome.json`, `npm run lint` / `npm run
+  format`), with `noExplicitAny` and unused-code checks on; the codebase is
+  clean against it (the one `Model<any>` in `refine.ts` became `Model<Api>`).
+- **Coverage measurement** (`npm run test:coverage`, `vitest.config.ts`):
+  v8 provider with thresholds — 95% statements package-wide, and 100% for the
+  pure policy modules (`select.ts`, `lessons.ts`, `cadence.ts`, `vmodel.ts`)
+  whose "pure, deterministic, unit-tested" property the README advertises.
+- **Provenance trust boundary**: every item now records who last wrote its
+  content. `harness_mutate` creates and content rewrites (plus all `/refine`
+  proposer writes) are stamped `provenance: "agent"` server-side; the model
+  can never set the field (smuggled values are stripped at the tool boundary,
+  and agent writes can only ever lose trust, never gain it). Absent provenance
+  means trusted, so owner-authored items, AGENTS.md imports, and existing
+  stores need no migration. Two on-by-default gates under
+  `harness.json { "provenance": { "label": true, "priority": true } }`:
+  **label** renders agent items as `(unverified: agent-authored)` in the
+  injected block (plus one defining intro line, paid only when such an item is
+  surfaced) and `(unverified)` chips in `/harness list` (both hidden by
+  `label: false`); **priority** fills each kind's item slots and the injection
+  budget with trusted items first, so an agent note can never crowd
+  an owner note out of the block (stores without agent items queue identically
+  to before). The durable file carries a `- provenance: agent` sub-line
+  (durable wins on import: hand-deleting the line trusts the item); legacy
+  files stay byte-identical. Stamping always happens — the gates only affect
+  presentation. Inspired by Protect-Context's forced agent trust level.
+  New tests: `test/provenance.test.ts` (22).
+- **`makePersist(pi)`** (store.ts): the one factory for the
+  `appendEntry("harness-state", …)` snapshot callback every mutation path
+  uses. The entry-type literal and persist closure were previously
+  copy-pasted at ~10 call sites — a typo in any one silently broke `/tree`
+  restore for that path.
+- **`validateDeltas`** boundary guard (tools.ts) plus `maxLength` caps on
+  `content`/`evidence`/`reason` in the tool schemas: a model could previously
+  create unbounded-size items that flowed verbatim into the durable files.
+- `test/entry.test.ts` pins the **turn_end registration order** (durable
+  sync's export before outcome/auto-refine) via the new exported
+  `TURN_END_CHAIN`; the invariant used to live only in a comment.
+- `test/hardening.test.ts` covers the new hardening behaviors (corrupt
+  snapshot coercion, ENOENT vs real read errors, flag validation, the
+  boundary guard).
+- **pi 1.5 conformance tests** (`test/schemas.test.ts`): pi 1.5 moved
+  tool-argument validation to `@earendil-works/pi-schema` (breaking change —
+  new coercion rules for JSON-Schema tools, new failure-message format). The
+  shipped hand-written schemas are now run through the same
+  `compile({ coerce: true })` path pi applies to tool arguments: well-formed
+  batches pass, loosely typed args coerce (`importance: "0.8"` → `0.8`,
+  `active: "true"` → `true`, a bare delta wraps into a one-item array), and
+  schema violations still reject after coercion (range/required/enum/
+  minItems/maxItems asserted by path+keyword, not message text).
+- **`CHANGELOG.md` is published** (added to npm `files`): pi ≥ 1.5 shows
+  users what changed after an extension update, reading the installed
+  package's changelog — which was previously never shipped. Timely, because
+  1.5 also fixed `-e npm:` extensions to actually update on start.
+- **`.gitattributes` pins LF** (`* text=auto eol=lf`): with
+  `core.autocrlf=true` on Windows, a fresh clone checks out CRLF while
+  biome.json enforces `lf`, so `npm run check` failed locally (50 format
+  errors) while Linux CI stayed green. New clones now check out LF.
+
+### Fixed
+
+- **Explicit-path `/harness import` now honors the path's layer scope**: the
+  `defaultScope` from `defaultScopeForPath` was computed and then never
+  threaded through `reconstructFromDurable`, so importing a project-dir file
+  by path silently defaulted untagged items to the global scope (contradicting
+  the documented behavior; surfaced by the new unused-variable lint).
+- Only `ENOENT` counts as "no durable file": a real read error (EACCES,
+  EISDIR, …) now surfaces as the import failure it is instead of the
+  misleading "No durable files — run /refine --commit" advice.
+- **Corrupt-snapshot field types are coerced at `reconstruct`** instead of
+  crashing far-away renders later (`importance: "high"` died at `toFixed(2)`,
+  an unknown `kind` at per-kind tallies).
+- The `session_start` durable auto-import is wrapped in the same soft-fail
+  try/catch as its `turn_end` counterpart — a throw can no longer escape the
+  session_start handler.
+- `/harness push-mem`, `prune`, `adopt`, `keep|drop`, `move`, `split`,
+  `lessons`, `import|export|export-corpus`, and `setup` now **warn on
+  invalid/extra arguments** instead of silently falling back (the rule
+  `/harness list` already documented): an invalid `--kind` used to quietly
+  push memories, a bad `--decay` to prune without decay — and, per the PR
+  review, a *misspelled* flag (`prune --decya 30`, `push-mem --knd skill`)
+  was still silently ignored. A grammar gate (`ARG_SPECS`/`checkRest`) now
+  rejects unknown flags, valueless value-flags, and extra positionals for
+  every subcommand before dispatch.
+- **Durable sync survives an unreadable layer** (PR review): a layer that
+  fails to read (EACCES, EISDIR, …) no longer crashes `syncDurableOnStart`
+  or blocks the healthy ones — it is skipped and reported **once per
+  session**, the readable layers import, and auto-export stays paused until
+  every layer reads again (an unread layer must never be overwritten by a
+  store that never saw it). The turn_end catch-up retries quietly and the
+  sync self-heals; previously every turn re-warned and even the healthy
+  global layer never exported. Manual `/harness import` still surfaces the
+  real error (unchanged).
+- `validateDeltas`' create branch now checks `importance` (number in [0,1])
+  and `scope` like the update branch (PR review: a non-pi host could send
+  `importance: "high"` past the guard); `clamp` in the store is NaN-safe as
+  defense in depth for direct-apply proposers; and a smuggled `ownerModel`
+  on a model-facing `harness_mutate` delta is stripped at the boundary
+  (same rule as `support` — creates always stamp to the active model).
+- Under `virtualBinding: "physical"`, a mid-run route change re-caches the
+  binding key at `context_with_system`, so `harness_mutate` creates stamp
+  with the same key injection renders (previously they could diverge until
+  the next agent start).
+- `loadConfig` is single-flight (concurrent cold callers share one read)
+  with an epoch guard, so a read that raced a cache reset can no longer
+  repopulate the cache with a stale result.
+
+### Changed
+
+- Internal consolidation, no behavior change: shared constants in
+  `types.ts` (`KIND_VALUES`/`KIND_ORDER`/`KIND_LABEL`, `KEEP_DROP_BUMP`) and
+  `schemas.ts` (`MAX_DELTAS`, which `ADOPT_BATCH_CAP` now derives from instead
+  of a hand-synced copy); `tally`/`AnyEntry`/`preview` deduplicated across
+  modules; the audit-trail walk extracted into one `walkAuditTrail` shared by
+  `status.ts` and `corpus.ts`; `layerPaths` exported as `defaultLayerPaths`
+  and reused; `runRefine`, `mergeParsed`, `handleSetup`, and the `/harness`
+  completions split into focused helpers; dead exports `registerHarness` /
+  `registerAutoRefine` removed.
+- README: the long per-key Configuration reference moved to
+  **[docs/CONFIG.md](docs/CONFIG.md)**; the README keeps the shape, a key
+  table, and the link. Status section updated to 0.20.x. ROADMAP phases
+  reordered chronologically (8 → 13).
+- `ProposeInput`'s optional fields are now explicitly `| undefined`-tolerant
+  (matches the package's `exactOptionalPropertyTypes` convention; type-level
+  only).
+- **Adopted pi 1.5 in the toolchain**: devDependencies
+  `@earendil-works/pi-ai` / `pi-coding-agent` `^1.3.0` → `^1.5.0` (+ explicit
+  `@earendil-works/pi-schema` devDependency for the conformance tests), so CI
+  runs against the validator pi 1.5 actually applies to tool arguments. No
+  runtime code changes were needed — the tool schemas have been plain JSON
+  Schema since the issue-#36 startup refactor, which is exactly what 1.5's
+  pi-schema migration validates — and `peerDependencies` stay `>=1.2.0`
+  because nothing 1.5-only is imported at runtime. README Status notes
+  tested-against-pi-1.5.
+- **Typed tool factories** (schemas.ts): `harnessListTool` /
+  `harnessMutateTool` now type their `execute` argument with the hand-written
+  `Static<>` params (a `ToolExecute<P>` derived from pi's own `execute`
+  signature, so rest/return types cannot drift), and the one cast back to
+  pi's `Static<TSchema>` slot lives inside the factories. The four
+  `params as Harness*Params` casts at the registration sites (entry.ts,
+  tools.ts) are gone. Type-level only — the emitted dist is byte-identical
+  (verified: the #36 startup graph and timings are unchanged).
+
+## [0.20.0] — 2026-10-21
+
+### Added
+
+- **Harness²-inspired harnessing-level recursion** (arXiv
+  [2610.14224](https://arxiv.org/abs/2610.14224)): the improvement process now
+  learns from what past improvement yielded, using only signals already on the
+  branch — no extra model calls.
+  - **Support counters** on every item: `citations` (the outcome loop saw the
+    agent cite `[h_xxxx]`), `keeps` / `drops` (`/harness keep|drop`). Dedupe
+    merges carry them onto the keeper; durable export/import round-trips them
+    via a `support:` sub-line; `/harness list -f` and the `harness_list` tool
+    show them.
+  - **Lessons digest** injected into the `/refine` steering prompt:
+    evidence-gated sections for items proven useful (cited/kept), rejected
+    signals (drops strictly outweighing later use — a drop followed by
+    re-citations is contested, not rejected), and recent refine-run
+    productivity. Never-cited items are never named (no signal ≠ negative
+    signal); the digest is scoped to the **active model's items** (per-model
+    isolation applies to what the improver is told). Visible
+    any time via the new **`/harness lessons`** command.
+  - **Scoped refine proposals**: the steering prompt classifies every create
+    as invariant (cross-domain agentic behavior → `scope: "global"`) or
+    domain-specific (project knowledge → `scope: "project"`).
+  - **History gate** for auto-refine: `autoRefine.refineNoOpSkip` (default 3,
+    `0` disables) skips a cadenced refine when the last N refine runs all
+    produced nothing durable. Runs before the classifier gate and costs
+    nothing; **bounded to one consecutive skip** so the gate can never latch
+    shut against later trajectory evidence; manual `/refine` bypasses it.
+- New exports for companion packages: `buildLessonsDigest`, `classifyRuns`,
+  `isEffectiveRun`, `recentIneffectiveRuns`, `mergeSupport`, `renderSupport`,
+  `parseSupport`, `buildSteeringPrompt`, `DEFAULT_REFINE_NOOP_SKIP`,
+  `HISTORY_GATE_MAX_CONSECUTIVE_SKIPS`, and the
+  `SupportInfo` type.
+- **`harness.schema.json`** — published JSON Schema for `harness.json`
+  (same pattern as pi ≥ 1.2's published config schemas). Both doc examples
+  now start with a `$schema` line pointing at the raw GitHub URL; the schema
+  also ships inside the npm package (`files`). The loader already ignores
+  unknown keys — `$schema` included — and `/harness setup` rewrites preserve
+  it; a new test pins both behaviors.
+
+### Changed
+
+- README: noted that codemode (pi ≥ 1.2) renders the harness tools' input
+  constraints as `@` tags on property comments (`@minimum 0 @maximum 1` on
+  `importance`, `@maxItems 20` on the batch cap) — already declared by the
+  tool schemas, so scripts see the limits for free.
+
+## [0.19.0] — 2026-10-16
+
+### Changed
+
+- **pi 1.2 adoption** — the peer floor moves from `>=0.99.0` to `>=1.2.0`.
+  - Every `pi.sendUserMessage` steering send now passes an explicit
+    `deliverAs`: `"steer"` for `/refine` (mid-run injection when busy) and
+    `"followUp"` for the auto-refine boundary fallback and the `/harness`
+    split/adopt/push-mem steering prompts (queued instead of throwing). Pi
+    1.2 counts the session as busy from run start, and a bare send throws
+    "Agent is already processing" in that window.
+  - Extension-triggered runs (`pi.sendMessage(..., { triggerTurn: true })`,
+    e.g. scheduled tasks) now fire `before_agent_start` with
+    `messageType: "custom"`, so the model-binding bridge — binding key,
+    orphan adoption, injection — covers them. Before pi 1.2 those runs ran
+    with an empty binding cache.
+
+## [0.18.0] — 2026-10-11
+
+### Changed
+
+- **Near-zero startup cost: thin entry + precompiled dist** (issue #36). Pi
+  loads extension entries sequentially and awaits every factory before
+  startup continues, so the old all-static TypeScript entry paid its whole
+  import graph (~230KB, jiti-transpiled) on every launch: **~0.8s marginal**
+  in the 2026-10-11 measurement (9.4s total with all 16 packages installed).
+  Measured now: **~30ms marginal** (bogus-provider fast-fail, issue's
+  acceptance target was ≤150ms).
+- **`pi.extensions` now points at `./dist/entry.js`** — a thin factory that
+  only registers hooks, commands, and tool schemas. Every feature module is
+  dynamic-imported inside its own handler (`session_start`, `turn_end`,
+  `before_agent_start`, `context_with_system`, command handlers, tool
+  `execute`), so nothing heavy evaluates until the relevant event fires.
+- **The package ships precompiled `dist/`** (`main: dist/index.js`, types
+  included): no per-startup jiti transpile, and companion packages get real
+  JavaScript + `.d.ts` instead of raw TS via `main`. `src/` is no longer part
+  of the npm tarball; `prepack` builds `dist/` and CI verifies it exists.
+- **Tool schemas are hand-written plain JSON Schema objects** (module
+  `src/schemas.ts`) instead of TypeBox builders: pi does not preload `typebox`
+  or `pi-ai` before extensions in the one-shot path, and importing either
+  costs ~0.4–1.0s cold. `test/schemas.test.ts` guards that the emitted JSON
+  is identical to the historical TypeBox output.
+- **No behavior change**: commands, tools, hooks, registration order, and the
+  public API are identical. The feature modules' `register*` functions remain
+  (tests use them); they now delegate to the same extracted handlers the thin
+  entry calls.
+
+### Notes for companion authors
+
+- `getArgumentCompletions` for `/harness` may now return a Promise (pi's API
+  allows `AutocompleteItem[] | null | Promise<AutocompleteItem[] | null>`);
+  sync values still work. Only relevant if you wrap the command.
+- Importing `pi-continual-harness` from a companion is now cheaper too: the
+  package root is precompiled JS, not jiti-transpiled TS.
+
+## [0.17.0] — 2026-10-11
+
+### Fixed
+
+- **Companion proposer registrations were silently invisible under pi's
+  extension loader** — pi gives every extension a fresh, module-cache-disabled
+  jiti instance, so a companion package's
+  `import { registerProposer } from "pi-continual-harness"` resolved to a
+  DIFFERENT copy of the module than the one whose `/refine` reads the
+  registry. `registerProposer` wrote to a private map, `getProposer` never saw
+  it, and `/refine --proposer <name>` silently fell back to `steering`.
+  Verified against the real loader (pi 1.1.0): after running the companion's
+  factory, `listProposers()` on the harness copy still showed only the
+  built-ins.
+- The registry is now backed by a **process-wide global**
+  (`Symbol.for("pi-continual-harness.proposers")`), which is shared across all
+  of pi's isolated module instances. `registerProposer` writes to it;
+  `getProposer` reads it first and falls back to the module-local built-ins
+  (`steering`, `dedupe`), so two harness copies never hand each other's
+  closures to `/refine`. Foreign entries without a `propose` function are
+  ignored defensively.
+- **No API change**: same `registerProposer` / `getProposer` / `listProposers`
+  signatures. Upgrading the harness alone also fixes companion packages that
+  were built against older versions (their private copy of
+  `registerProposer` now writes to the same shared registry).
+
+### Notes for companion authors
+
+- Companions that want a zero-import startup entry can skip importing this
+  package entirely and push a `DeltaProposer` (typically a lazy delegate that
+  dynamic-imports its implementation on first `propose()`) straight into
+  `globalThis[Symbol.for("pi-continual-harness.proposers")]`. The string key
+  `"pi-continual-harness.proposers"` is the stable public contract.
+
+## [0.16.1] — 2026-10-11
+
+Deep-review release: six correctness fixes (each found by a full code review,
+`review findings #1–#7` below) plus the simplifications that remove the drift
+surfaces the bugs grew on.
+
+### Fixed
+
+- **`/harness export-corpus` dropped the first snapshot's `created` events**
+  (review finding #1) — `buildCorpus`'s snapshot walk skipped the branch's
+  FIRST `harness-state` entry, while `/harness status` had the implicit
+  empty-baseline fix since review #27. A fresh session's entire first create
+  batch (often the auto-import) never landed in `lifecycle.jsonl`, and the
+  two reports disagreed on `created` counts for the same branch. The corpus
+  walk now diffs against `{ items: [] }` exactly like the status aggregator.
+- **Completions crashed on prototype-collision subcommands** (review finding
+  #2) — typing `/harness constructor --` (or `toString`, `valueOf`, …) hit
+  `sub in FLAGS` / `FLAGS[sub] ?? []`, which resolve `Function` through the
+  prototype chain: not nullish, so `.filter` threw. Both the condition and
+  the lookup now go through `Object.hasOwn` (same class as the review #26
+  `expandPreset` fix).
+- **No-op `/harness prune` appended a `harness-state` entry** (review finding
+  #3) — `decayAndPrune` persisted unconditionally. A prune that decayed and
+  removed nothing now persists nothing, matching the `mergeParsed` /
+  `adoptOrphans` idempotency contract (no `/tree` noise).
+- **Re-importing a durable file without an export in between duplicated
+  items** (review finding #4) — id-less bullets and foreign (non-`h_`) ids
+  never hit the id map, so every import created a fresh copy. Import now
+  falls back to a kind+content match: the re-import folds into the item the
+  first import created (and under `--prune`, content-matched items count as
+  "present in the file" — no delete+recreate id churn).
+- **One corrupt `harness-state` entry could break `session_start`** (review
+  finding #5) — `reconstruct` called `.map` on whatever `state.items`
+  happened to be. Non-array `items` and non-object entries are now filtered
+  out instead of throwing; a fully-corrupt snapshot degrades to an empty
+  store.
+- **Malformed `harness.json` silently reset every setting** (review finding
+  #6) — the loader fell back to defaults with zero feedback. `loadConfig`
+  now flags the parse failure (`configMalformed()`) and `session_start`
+  warns once per session: "not valid JSON — every setting is on its DEFAULT
+  until the file parses."
+- **Typo'd `/refine` flags and proposer names vanished silently** (review
+  finding #7) — `--comit` ran a plain no-commit refine; `--proposer dedupee`
+  silently fell back to steering. Unknown `--flags` and unknown proposer
+  names now produce a warning (the refine still runs).
+
+### Changed
+
+- **One shared turn-cadence counter** (new `src/cadence.ts`) backs
+  auto-refine, the `/refine` reminder, and the import-awareness reminder —
+  three hand-rolled copies of seed-on-first-completed-turn / count-completed
+  / reset-on-fire had already drifted once (review #26's turnIndex fix, and
+  issue #29 grew on that drift). `turnEndedBadly` moved to `cadence.ts`
+  (still re-exported from `auto-refine.ts`). Behavior is identical for every
+  consumer except one normalization: the import reminder now also treats
+  `everyTurns <= 0` as disabled (previously it fired every completed turn
+  until the reminder cap).
+- `durableLayer` is exported from `proposer.ts` and shared with `corpus.ts`
+  (the dedupe-pair layer key had to stay in sync by hand).
+- The split/adopt steering prompts render their item listings through one
+  shared `formatItemLines()` (adopt keeps full-precision importance — the
+  agent copies it verbatim; split rounds). The two formats had already
+  drifted once.
+- Status aggregation counts lifecycle events with an exhaustive `switch` —
+  a future `LifecycleEvent` falls to an explicit `default` instead of being
+  silently counted as `deleted`.
+## [0.16.0] — 2026-10-11
+
+### Added
+
+- **`/harness list [-f] [--kind <kind>] [--scope <global|project|all>]`**
+  (issue #31): the read view of the store in the TUI. What `/harness status`
+  counts, but with the actual item text: no agent turn and no trip to the
+  layer files required.
+  - **Compact rows by default**: id, kind, importance, scope, ~60-char
+    preview, one line per item, ranked importance-first (ties keep store
+    order, the same stable policy as injection selection). Inactive items
+    carry an `(inactive)` marker.
+  - **`-f`**: full text plus the evidence line, harness_list-style, extended
+    with owner model and scope in the parenthetical.
+  - **Scope filters mirror the durable layers**: default = global + the
+    active project; foreign-project items are hidden and counted in a
+    trailing note (empty results included) so they look hidden, never
+    missing. `--scope project` lists every project's items with the slug on
+    each row; `--scope all` lists everything.
+  - **Guidance over bare zeros**: an empty store gets zero-state first steps,
+    an empty filter result gets kind tallies of what the store holds, and
+    invalid `--kind`/`--scope` values or unexpected arguments warn instead of
+    silently listing unfiltered.
+  - **Autocomplete**: `list` in the subcommand menu, `-f`/`--kind`/`--scope`
+    flag rows (flag matching now also catches short `-` prefixes), and value
+    menus for both filters.
+  - **Read-only**: no store mutation, no durable writes, one notify. The
+    selection/rendering core is pure in `src/list.ts`
+    (`selectListItems`/`renderListReport`) and re-exported from the package
+    entry; `preview()` consolidated there.
+## [0.15.1] — 2026-10-11
+
+### Fixed
+
+- **`/refine` crash on plain-string message content** — pi messages carry
+  `content` as a plain string OR an array of content blocks depending on the
+  message source; both trajectory readers (`gatherEvidence` behind `/refine`,
+  and the opt-in `outcomeImportance` loop's `turn_end` scan) assumed blocks and
+  threw `((intermediate value) ?? []).map is not a function` the moment a
+  branch contained a string-content message. Both now flatten through one
+  shared pure helper, `messageText()` (re-exported from the package entry):
+  strings pass through, block arrays join on spaces, and any other shape
+  degrades to `""` instead of throwing. No behavior change otherwise —
+  citations, evidence lines, and cadences are untouched.
+
+## [0.15.0] — 2026-10-11
+
+The activation, visibility, and onboarding release: issues **#19–#22**
+(activation nudges, rich status, cross-model adoption, setup wizard) plus
+the pending 0.14.0 outcome-guard work.
+
+> **Fold note:** releases 0.11.0–0.14.0 shipped from this same accumulated
+> section without header cuts (see git tags / npm history), so their entries
+> are retained below verbatim. Per-release headers resume here.
+
+### Changed
+
+- **`remindRefine` defaults flipped: on, every 25 turns** (issue #19). Fresh
+  installs were silent, so the cheapest activation lever (a notify-only
+  nudge) never fired. A reminder mutates nothing, which keeps the "manual by
+  default" safety posture intact while the `/refine` habit gets built for
+  you. **Migration note for existing silent-by-default users:** if your
+  `harness.json` has no `remindRefine` key you will start seeing nudges
+  (first one at 25 completed turns). Restore the old silence with
+  `{ "remindRefine": { "enabled": false } }`. Explicit config keeps winning
+  in both directions, and the cadence still counts completed turns per the
+  aborted/error-inert semantics (seed on the first observed completed
+  `turn_end`, reset per fire and per session).
+
+### Added
+
+- **Tiered, rotating reminder content (`remindRefine.detailEvery`)** — every
+  4th fired reminder (default) escalates from the one-line nudge to a
+  detailed educational guide, rotating through 7 slots so repeat viewers
+  never see the same wall of text: how the improvement loop works (3
+  alternating descriptions), the `/refine` workflow, `keep`/`drop`/
+  `prune --decay <days>` hygiene, `push-mem` (pi-mem composition), `split`
+  (global vs project scopes), `export-corpus` (pi-reflex contract), and a
+  recommended starter config whose guidance is honest about autonomy (review
+  #28): with `autoImport` on, durable layers are already written on every
+  store change — `commit` only adds a refine-time flush when `autoImport` is
+  off — so the conservative start is `autoImport` off + manual
+  `/harness export`. Config: `"remindRefine": { "everyTurns": 25,
+  "detailEvery": 4 }` with `1` = every reminder detailed; non-integer/sub-1
+  values coerce to the default (spam guard). The short nudge is now
+  data-aware ("12 active item(s), 4 never cited since creation"; an empty
+  store gets first-run guidance instead), derived from `getState()` with no
+  new persisted state. Copy builders are pure and exported (`buildNudge`,
+  `buildDetailGuide`, `reminderState`, `ReminderState`) so the richer
+  `/harness status` (companion issue) can share the same copy source.
+
+- **Awareness reminders for durable sync (`importRemind`)** — with
+  `"autoImport": true`, silently-imported instructions now announce
+  themselves. The session-start import lists **what arrived** (item id, kind,
+  first words of content — bounded to 5 lines; an id present in both layers
+  is listed once, with its post-merge content), and a one-line `turn_end`
+  reminder re-surfaces the imported batch every `importRemind.everyTurns`
+  **completed** turns (default 25; aborted/error `turn_end`s are inert — they
+  neither seed nor fire, so they never consume one of the bounded notices,
+  and the count cannot be defeated by pi resetting `turnIndex` on every
+  `agent_start`). Both pointers are truthful (review #28): the overflow line
+  and the reminder point at the agent's `harness_list` tool (which actually
+  lists ids/content), not `/harness status` (counts only), and the advertised
+  kill-switch is valid, paste-able JSON. Bounded by design: at most 3
+  reminders per imported batch, then quiet until the next session — awareness
+  without nagging.
+  Config: `"importRemind": { "enabled": true, "everyTurns": 25 }`
+  (effective only with `autoImport`; kill-switch `enabled: false` keeps the
+  start-of-session listing). `DurableImportResult` now carries
+  `createdIds`/`updatedIds` (additive) so the sync knows exactly which items
+  to re-surface, and `imported` counts DISTINCT items — an id folded across
+  layers is one item, not one per copy (so the "imported N item(s)" notify
+  no longer double-counts collisions);
+  `evaluateImportReminder`/`registerImportReminder`/
+  `getImportedThisSession`/`summarizeImported` exported for tests and
+  companions.
+
+### Removed
+
+- **`durableScope` config key removed** (deprecated since 0.9.0 as a no-op):
+  items carry their own scope and durable I/O is always layered, so the key
+  switched nothing. The dead `resolveDurablePath()` helper is gone too (no
+  callers). Config files that still set `durableScope` load unchanged —
+  unknown keys are ignored; migration is the documented one-time
+  `/harness import` + `/harness move`/`split`.
+
+### Fixed
+
+- **Review #27 fixes (all unreleased features, amended in place)** — impact's
+  implicit empty baseline (first-snapshot `created 0`), per-model
+  update/merge attribution, status keying under `virtualBinding: "physical"`,
+  honest classifier-gate hint (names `classifier.model` AND `autoRefine.gate`),
+  and imported refs reconciled against the live store every `turn_end` (an
+  item deleted or deactivated after the import drops out of the reminders;
+  review pointers now target `harness_list`, which lists ids/content — status
+  intentionally stays aggregate-only).
+
+- **`harness_list` empty results are now diagnostic** — the bare
+  `"Harness state is empty."` collapsed three very different situations into
+  one opaque line, which users read as "the feature is broken": (1) a
+  genuinely empty store (a new session starts empty — durable sync is
+  opt-in), (2) everything owned by another model (per-model isolation hides
+  it from the default view), (3) a `kind` filter that matched nothing. Each
+  case now gets its own actionable text: zero-state guidance (`/refine`,
+  `harness_mutate`, `"autoImport": true`), an owner tally with a
+  `model:"*"` pointer, and a kind tally respectively. The diagnosis is
+  attributed from the store's actual contents (review #23): a kind miss for a
+  model that owns items is never reported as model isolation, and the
+  `model:"*"` pointer only appears when the requested kind actually exists
+  for another model. `structuredContent` is unchanged (stable schema); only
+  the model-facing text changed.
+
+### Added
+
+- **Rich `/harness status` (issue #20)** — the status report is now a
+  three-band, still read-only notify. **Impact**: derived from the session
+  branch's audit trail by reusing the corpus lifecycle classification
+  (`classifyTransition` now exported with item attribution): refine runs
+  (manual vs auto), items created / updated (direct-apply, a lower bound) /
+  kept / cited (config-aware bump) / dropped / pruned / deleted / merged
+  (dedupe merges), whole-store plus a per-active-model line (lifecycle events
+  AND direct-apply update/merge ops are owner-attributed; the key follows the
+  configured `virtualBinding` policy). The branch's first snapshot diffs
+  against an implicit empty baseline, so a fresh session's first create batch
+  counts its items. **Injection
+  stats**: renders that served items, items surfaced, last block's estimated
+  tokens vs `injection.maxTokens`, and selection-omitted counts
+  (`InjectionStats`, recorded at render time in `inject.ts`, reset on
+  `session_start`). **Zero-state guidance**: 0 active items → actionable
+  first steps (`/refine`, MANUAL Quick start) instead of bare zeros. **Hint**:
+  one rotating contextual one-liner per call (classifier gate, outcome loop,
+  `push-mem`, `remindRefine`, `split`), never repeating the previous call's
+  hint (`src/hints.ts`, shared copy source for #19's content library). The
+  report builder is pure and exported — `buildStatusReport` /
+  `renderStatusReport` — and `handleStatus` stays thin glue. No new persisted
+  state; no mutation.
+
+- **Cross-model adoption: `/harness adopt --from <provider/id> [--all]`**
+  (issue #21) — the audited, agent-filtered path for carrying **owned** items
+  across models (per-model isolation starts every new model id on a blank
+  harness; orphan adoption only covered *unowned* items). Steers the agent to
+  classify the source model's active items **generalizes** (model-agnostic:
+  engineering practices, user preferences, project facts) vs **stays** (that
+  model's quirks, formatting preferences, failure modes), then apply ONE
+  `harness_mutate` batch of create deltas — **copy, not move**: the source
+  harness is never touched, content is copied verbatim, evidence is annotated
+  `adopted from <provider/id>`, and because `ownerModel` is never
+  model-settable the creates stamp to the **active** model via the existing
+  create-stamping path (audited, `/tree`-rollback-able). `--all` adopts
+  everything without the filter. The batch is capped at 20 items (matching
+  `harness_mutate`'s per-call delta limit so the whole adoption fits one
+  batch), keeping the highest-importance items first and announcing any
+  truncation. Guards: missing `--from`, empty store, unknown model (warning
+  lists the owners present, with counts), self-adopt. `--from` values
+  complete from the model keys in the store. Overlaps afterwards are the
+  dedupe proposer's job: `/refine --proposer dedupe`. No automatic adoption
+  exists — explicit, manual, reviewable only. Review #25 hardening: the
+  self-adopt guard compares against the **resolved binding key**
+  (`virtualBinding`-aware, the same key create-stamping uses — a router
+  selection under `physical` adopts as the routed model); foreign-project
+  source items are skipped rather than re-stamped into the current
+  session's project layer (adopt them from a session in that project);
+  content the adopter already owns is skipped **before** the cap so repeated
+  adoption of a >20-item source progresses instead of re-selecting the same
+  top items; and importance is listed at **full precision** so an adopted
+  copy keeps its exact ranking. `buildAdoptPrompt`,
+  `selectAdoptSource`, and `ADOPT_BATCH_CAP` re-exported from the package
+  entry.
+
+- **`/harness setup` — guided configuration wizard (presets, reviewed
+  harness.json write)** — every opt-in feature used to require hand-editing
+  `~/.pi/agent/harness.json` with exact key spellings; the wizard replaces
+  that with presets, per-feature confirms, and one safe write. Flow: show
+  the current effective config (file merged over defaults) + durable-layer
+  paths; choose `quiet` (pin the shipped defaults), `recommended`
+  (`autoImport` + `importRemind` on, with a gate-readiness note), or `power`
+  (`recommended` + `autoRefine`); confirm each implied delta (autonomous
+  switches get their own explicit "mutates state on a cadence" confirm
+  regardless of preset); then write via the new `saveConfig` — timestamped
+  backup (`harness.json.bak-<timestamp>`), atomic same-dir write, unknown
+  keys preserved, and a reload that round-trips through the loader's
+  coercion path so the printed effective config is exactly what pi reads.
+  Scripted form: `/harness setup --preset recommended [--yes]` (`--yes` is
+  the scripted consent and skips every prompt). Nothing is written on
+  unknown input, a cancelled preset menu, or a declined final write;
+  declining an individual feature only skips that feature. The wizard
+  touches config files only — never harness state. Preset values derive
+  from `DEFAULT_CONFIG` (not hardcoded), so wizard and loader cannot drift.
+  Presets are pure data: `PRESETS` / `expandPreset` / `planWrite` / `setPath`
+  / `saveConfig` exported for tests and companions; subcommand +
+  `--preset`/`--yes` flags autocomplete in the TUI.
+
+- **Awareness reminders for durable sync (`importRemind`)** — with
+  `"autoImport": true`, silently-imported instructions now announce
+  themselves. The session-start import lists **what arrived** (item id, kind,
+  first words of content — bounded to 5 lines), and a one-line `turn_end`
+  reminder re-surfaces the imported batch every `importRemind.everyTurns`
+  turns (default 25). Bounded by design: at most 3 reminders per imported
+  batch, then quiet until the next session — awareness without nagging.
+  Config: `"importRemind": { "enabled": true, "everyTurns": 25 }`
+  (effective only with `autoImport`; kill-switch `enabled: false` keeps the
+  start-of-session listing). `DurableImportResult` now carries
+  `createdIds`/`updatedIds` (additive) so the sync knows exactly which items
+  to re-surface; `evaluateImportReminder`/`registerImportReminder`/
+  `getImportedThisSession`/`summarizeImported` exported for tests and
+  companions.
+
+- **Aborted/error turns are inert (pi `turn_end` `BoundaryState.outcome`)** —
+  a `turn_end` whose outcome is `"aborted"` or `"error"` no longer counts
+  toward the auto-refine or reminder cadence: both windows now count
+  *completed* turns (never raw turn indices, so an aborted turn in between
+  cannot shorten a window). The outcome loop seeds its scan cursor on the
+  first observed `turn_end` regardless of outcome, then defers an aborted
+  turn's partial assistant text to the next completed turn — a refine can no
+  longer fire, and the classifier gate no longer judges, a trajectory that
+  was cut off. A missing outcome (synthetic events, earliest 0.99.x) is
+  treated as completed. Durable auto-export deliberately still exports on
+  aborted turns (committed entries must not be lost). Pure `turnEndedBadly()`
+  re-exported from the package entry; `evaluateAutoRefine`/`evaluateReminder`
+  accept an optional `outcome` argument (the dead `turnIndex` parameter was
+  dropped — the count replaced the index arithmetic).
+- **pi 1.1.0 classifier catalog documented** — `classifier.model` accepts the
+  new entries with no code change: OpenAI's GPT-6 Luna (Decisions API, e.g.
+  `openai/gpt-6-luna`, needs `OPENAI_API_KEY`) and the native llama.cpp
+  decision models (Julia-1, Laya, Kev, lev, OpenJev through `/v1/systemone`,
+  llama.cpp ≥ 0.6.0 — classifier-only listings, a free local gate). README +
+  MANUAL updated; no minimum-pi change (the APIs used still ship by 0.99.0).
+
+### Removed
+
+- **`durableScope` config key removed** (deprecated since 0.9.0 as a no-op):
+  items carry their own scope and durable I/O is always layered, so the key
+  switched nothing. The dead `resolveDurablePath()` helper is gone too (no
+  callers). Config files that still set `durableScope` load unchanged —
+  unknown keys are ignored; migration is the documented one-time
+  `/harness import` + `/harness move`/`split`.
+
+### Fixed
+
+- **`harness_list` empty results are now diagnostic** — the bare
+  `"Harness state is empty."` collapsed three very different situations into
+  one opaque line, which users read as "the feature is broken": (1) a
+  genuinely empty store (a new session starts empty — durable sync is
+  opt-in), (2) everything owned by another model (per-model isolation hides
+  it from the default view), (3) a `kind` filter that matched nothing. Each
+  case now gets its own actionable text: zero-state guidance (`/refine`,
+  `harness_mutate`, `"autoImport": true`), an owner tally with a
+  `model:"*"` pointer, and a kind tally respectively. The diagnosis is
+  attributed from the store's actual contents (review #23): a kind miss for a
+  model that owns items is never reported as model isolation, and the
+  `model:"*"` pointer only appears when the requested kind actually exists
+  for another model. `structuredContent` is unchanged (stable schema); only
+  the model-facing text changed.
+- **`harness_list`'s `model:"*"` pointer also holds when the model owns
+  nothing (review #26)** — requesting a kind that exists for NO model used
+  to still show the pointer (which returns nothing with the same kind
+  filter); that case now says "no `<kind>` items for this model or any other
+  model" with an honest kind tally, and the pointer only appears when the
+  kind exists elsewhere.
+- **Late `autoImport` enable can no longer clobber the durable layers
+  (review #26)** — enabling `autoImport` mid-session (wizard or hand-edit)
+  used to make the very next `turn_end` auto-export overwrite the
+  global/project durable files with the never-imported live store (the
+  session-start import had been skipped, so saved refinements were lost).
+  The export hook now runs the layered import FIRST when the session's
+  start-sync never happened; a failing catch-up import defers the export
+  to the next turn.
+- **Cadences count `turn_end` events, not pi's `turnIndex` (review #26)** —
+  pi resets `turnIndex` to 0 on every `agent_start` (each user prompt), so
+  the import-reminder (and the older `/refine` reminder) cadences could
+  never accumulate across prompts: 25 separate prompts never fired a
+  reminder. Both reminders now count completed turn_end events
+  (session-stable ordinal; resets on session_start as before).
+- **`saveConfig` is safe under concurrency (review #26)** — the temp file is
+  unique per call (UUID + exclusive `wx` create), so two concurrent writes
+  (two pi sessions) can never truncate or rename each other's temp file;
+  the final rename retries briefly on Windows' transient `EPERM` (target
+  just replaced).
+- **`planWrite` merges like `saveConfig` (review #26)** — the wizard's
+  reviewed JSON preview previously dropped nested unknown keys (e.g. a
+  future `importRemind.<key>`), which the write then re-added from disk, so
+  the written file could differ from the confirmed preview. Deltas now
+  apply with the same two-level deep-merge: the preview equals the file.
+- **`expandPreset` no longer leaks `Object.prototype` (review #26)** —
+  `--preset constructor` (or `toString`/`__proto__`) passed validation and
+  crashed; inherited names now report `Unknown preset` and nothing is
+  written.
+- **The import-reminder's disable hint is now valid JSON (review #26)** —
+  the suggested snippet used single quotes; pasting it broke the whole
+  config file (all settings fell back to defaults). It now reads
+  `"importRemind": { "enabled": false }`.
+- **Global/project id collisions list once (review #26)** — an id created
+  by the global layer then updated by the project layer appeared twice in
+  the "what arrived" listing and inflated the reminder counts; the batch
+  is now de-duplicated.
+
+### Added
+
+- **Stale-draft hygiene for auto-refine (pi 0.87 context edits)** — every
+  boundary delivery now also appends `context_edit` drafts omitting each LIVE
+  prior `harness.auto-refine-request` from future provider context, so at most
+  ONE auto-refine request (the newest) is ever model-visible in long sessions.
+  Already-omitted drafts are skipped (idempotent — never stacks edits); raw
+  history, usage, and UI history are untouched, so `/tree` rollback and the
+  HTML export still show every draft. Kill-switch:
+  `"autoRefine": { "omitStaleDrafts": false }` (default `true`).
+  `buildOmissionDrafts` exported for reuse.
+
+### Added (0.12.0 — pi 0.87/0.99 adoption)
+
+- **Live re-injection via `context_with_system` (pi 0.87)** — the harness block
+  is now rendered on EVERY provider request (full-transcript system-message
+  transformation), not baked into the base prompt once per agent run. A
+  `harness_mutate` that fixes a stale note mid-run shows up on the very next
+  request. `before_agent_start` remains the model-binding bridge (key cache +
+  orphan adoption) but no longer rewrites the prompt; when there is nothing to
+  inject the extension does not own the transcript at all.
+- **Virtual-model binding policy (pi 0.99)** — `ctx.model` names the *virtual*
+  model when a router extension is selected, which silently split the harness
+  per router. New config `"virtualBinding": "virtual" | "physical"` (default
+  `virtual`, the previous behavior): `physical` keys items by the *physical*
+  model behind the latest successful response on the branch, so notes
+  accumulated under `anthropic/claude-x` keep injecting through a router that
+  routes there; before the first response the binding is unknown (creates stay
+  orphans, adopted on first contact). Pure helpers (`isVirtualModel`,
+  `physicalKeyFromBranch`, `resolveBindingKey`) re-exported from the package
+  entry.
+- **Classifier integration (pi 0.99)** — `ctx.modelRegistry.classify()` behind
+  a minimal structural `ClassifyFn` seam (`ProposeInput.classify`, re-exported):
+  - `"classifier": { "model": "typesafe/jev-latest" }` (or any classifier
+    catalog entry, e.g. a local llama.cpp classifier) enables both paths.
+  - **Classifier-confirmed dedupe**: the `dedupe` proposer recall-widens its
+    candidate pass (threshold − 0.15, floor 0.35) and confirms each pair with
+    ONE batched yes/no call (≤ 20 pairs). Only confirmed pairs merge; a
+    classifier error falls back to the plain rule-based plan — the classifier
+    can narrow merges, never block them. Telemetry (`modelCall`) recorded in
+    the audit entry. `planDedupePairs` / `deltasFromGroups` / `confirmGroups` /
+    `buildPairQuestions` exported for reuse.
+  - **Auto-refine gate**: `"autoRefine": { "gate": true }` asks one yes/no
+    question over the recent trajectory before spending a refine pass;
+    "no durable correction" skips it. Errors fall back to the plain cadence.
+- **Structured tool results (pi 0.99)** — `harness_list` and `harness_mutate`
+  declare `outputSchema` and return `structuredContent` (items array / applied
+  counts), so codemode scripts and `ctx.executeTool()` callers consume the
+  harness programmatically; the model still sees the text content.
+- **Boundary delivery for auto-refine (pi 0.87)** — the steering prompt is no
+  longer sent as a synthetic user message: `runRefine` (with the new
+  `delivery: "boundary"`) returns it undelivered and the `turn_end` handler
+  persists it as a structural `harness.auto-refine-request` custom-message
+  draft with `{ entries, continue: true }` — one guaranteed next provider
+  request with no steering-queue or follow-up-scheduling side effects. Falls
+  back to `sendUserMessage` when the boundary cannot continue. Manual `/refine`
+  still steers (it may run while idle).
+
+### Changed
+
+- **Minimum pi version is now 0.99.0** (peer + dev dependencies). All adopted
+  APIs ship by 0.99.0 (`context_with_system`, actionable `turn_end`
+  boundaries, classifier `classify()`, `outputSchema`/`structuredContent`,
+  virtual models).
+
+### Added (earlier in this release)
+
+- **`/harness export-corpus [path]`** — the calibration corpus exporter for
+  the pi-reflex consumer contract (§4, issue #12). Reconstructs two JSONL corpora
+  from the session branch's own audit trail: `dedupe-pairs.jsonl` (merged
+  pairs as ground-truth `dup` records parsed from delete reasons; same
+  key-field non-merged pairs with informative overlap as `needs_review`
+  `not_dup` candidates) and `lifecycle.jsonl` (`created` / `cited` / `kept` /
+  `dropped` / `pruned` / `deleted`, classified from consecutive snapshot
+  diffs). Pure `buildCorpus()` core in `src/corpus.ts` (+
+  `parseDedupeDelete`), re-exported from the package entry. Default output
+  `./harness-corpus/<yyyy-mm-dd>/`; local file writes only — nothing leaves
+  the machine.
+
+- **Review fixes (PR #14 feedback)** — three correctness issues in the first
+  cut: (1) the dedupe audit entry now records the full `appliedDeltas` list
+  (incl. delete reasons) alongside the legacy `applied` count — without it,
+  dup pairs were unreconstructable and the exporter crashed on the count-only
+  legacy shape; (2) `not_dup` candidates now emit from the CURRENT state — a
+  no-merge dedupe run writes no snapshot, so the previous two-snapshot walk
+  read a stale state; (3) citation classification is config-aware
+  (`buildCorpus(entries, { citeBump })`, wired to `outcomeImportance.bump`,
+  default 0.03) instead of a hardcoded `(0, 0.06]` band; keep/drop (±0.1) are
+  checked first, so a configured bump of exactly 0.1 classifies as keep.
+
+## [0.10.0] — 2026-09-20
+
+The merge-capable dedupe proposer: fuzzy-corrections take 1. Spec and research
+grounding in [docs/PLAN-dedupe-merge.md](docs/PLAN-dedupe-merge.md).
+
+### Added
+
+- **`dedupe` proposer merges instead of deleting** — two active items sharing
+  the key fields (kind, owner model, durable layer: scope + project slug) with
+  token overlap ≥ the threshold merge into the higher-importance keeper: one
+  audited `update` (evidence = line-wise union, capped at 2000 chars) + one
+  `delete` per duplicate (`merged into h_x (overlap …)`). The keeper's content
+  is never prose-merged (ACE); injection is content-only, so the prompt block
+  is unchanged. Identical evidence degenerates to a plain delete.
+- **Config keys** `dedupe: { "threshold": 0.6, "merge": true }` in
+  `harness.json` — threshold valid in `(0,1]` (bad values degrade to `0.6`),
+  `merge: false` restores the pre-0.10 delete-only behavior.
+- **`/refine --threshold <t>`** — one-shot threshold override for the run
+  (affects the `dedupe` proposer; invalid values are ignored with a warning).
+- **`ProposeInput.config`** — `runRefine` now threads the loaded `harness.json`
+  into every proposer (optional, additive), so proposers read tuned knobs
+  without file I/O.
+- **Public API**: `planDedupe(state, opts)` (the pure planner), `DedupeOptions`
+  (with a `similarity?` seam for the future semantic upgrade), `DEFAULT_DEDUPE`,
+  `EVIDENCE_MERGE_CAP`, `unionEvidence`, `DEDUPE_THRESHOLD` re-exported from
+  the package entry.
+- **`SimilarityResult` abstain seam** — `DedupeOptions.similarity` may return
+  `{ score, abstain }` instead of a plain number: an abstaining pair is treated
+  as NOT duplicates (keep both), so a semantic engine with conformal-style
+  uncertainty (e.g. pi-reflex, formerly pi-jev — local-only for now) can decline to
+  merge on uncertainty. `SimilarityResult` is re-exported from the package
+  entry; plain numeric comparators keep working unchanged.
+
+### Changed
+
+- The `dedupe` proposer's default behavior (was: delete-only, hardcoded 0.6).
+  Rollback path: set `"dedupe": { "merge": false }`.
+
+## [0.9.0] — 2026-09-17
+
+The project-scope split (issue #7). Scope becomes a property of each item, the
+durable file becomes durable **layers**, and one opt-in flag makes `/refine`
+output survive into new sessions without export/import ceremony.
+
+### Added
+
+- **Per-item durable scope** — `HarnessItem.scope: "global" | "project"`
+  (+ `project` slug). Scope decides which durable layer an item is exported to
+  / imported from; it never filters per-turn injection.
+  - **`/harness move <id> <global|project>`** — flip an item's layer
+    (audited update delta, `/tree`-rollback-able; `project` stamps the current
+    session's slug). Autocompletes ids then scope values.
+  - **`/harness split`** — the interactive migration helper: steers the agent
+    to classify every active item global-vs-project and apply the result as one
+    `harness_mutate` batch of scope-only updates (visible, audited,
+    rollback-able — the push-mem pattern).
+  - **Layered durable I/O** — `/harness export` (no path) partitions items
+    into `~/.pi/agent/harness-state.md` + `harness-state/<slug>.md`;
+    `/harness import` (no path) merges global first then the current project's
+    file (project wins id collisions; `--prune` is union-scoped across
+    layers). Explicit paths keep classic single-file semantics. Project items
+    carry a `scope: project (<slug>)` sub-line so any copy round-trips.
+    `/refine --commit` now exports the layers too. `/harness status` shows
+    both layers + the scope split.
+  - **`scope` on `harness_mutate` create/update deltas** — server-side slug
+    stamping from the session cwd (the tool never sees raw slugs).
+- **Opt-in durable sync: `"autoImport": true`** (`src/durable.ts`) — bundles
+  both directions: `session_start` layered auto-import (loss-free merge,
+  silent when nothing changes — imports are now idempotent and skip the
+  persist when the live store already matches the files) + `turn_end` layered
+  auto-export whenever the store version changed since the last export. Every
+  action is visible and uses the same `harness-state` entries (`/tree`
+  rollback covers them).
+
+### Changed
+
+- **`durableScope` is deprecated** (no-op): durable I/O is always layered on
+  per-item scope now. The key still parses so existing configs keep loading;
+  migration is one layered `/harness import` + `/harness move`/`split`.
+- Import merge is **idempotent**: an import that changes nothing persists
+  nothing (no session-tree noise from repeated or auto imports).
+- Layered import handles the same id in **both** layers (project copy wins,
+  no duplicate items).
+
+[0.15.1]: https://github.com/pungggi/pi-continual-harness/compare/v0.15.0...v0.15.1
+[0.15.0]: https://github.com/pungggi/pi-continual-harness/compare/v0.13.0...v0.15.0
+[0.9.0]: https://github.com/pungggi/pi-continual-harness/compare/v0.8.1...v0.9.0
+
+## [0.8.1] — 2026-09-13
+
+The completions release. `/harness` now registers `getArgumentCompletions`, so
+subcommands stop being one long crammed command description and become a
+filtered autocomplete menu instead. Handler logic is unchanged — purely UX.
+
+### Added
+
+- **`/harness` argument autocomplete** (`src/harness.ts`) — two levels:
+  - `/harness <partial>` lists the seven subcommands (import, export, status,
+    prune, keep, drop, push-mem), each with a one-line description, filtered
+    case-insensitively as you type (matching the handler's `toLowerCase()`
+    tolerance).
+  - `/harness <sub> …` completes what comes next per subcommand: flags
+    (`--prune`, `--decay`, `--all`, `--kind`, `--model` — already-used flags
+    are not re-offered), `--kind` values (`prompt|memory|skill|subagent`),
+    `--model` values (`active` plus the distinct owner models in the store),
+    and `keep`/`drop` item ids straight from the live store with a
+    `kind · content-preview` description row.
+  - Path/number/free-text arguments return no menu, leaving the editor's own
+    completion alone.
+- Completion rows carry the full replacement text (pi replaces the whole
+  argument string on selection), so multi-token completion round-trips exactly.
+- The `/harness` command description is now a compact one-liner instead of the
+  full subcommand + flag grammar.
+
+## [0.8.0] — 2026-08-10
+
+The bounded-injection release. The harness ACCUMULATES notes, but the system
+prompt is finite — so selection is now ON BY DEFAULT: injected items are
+importance-ordered, capped per kind, and bounded by a total token budget. The
+store itself is unchanged (nothing is ever lost — only what is *surfaced*
+changes), and the whole policy is opt-out via `injection.enabled: false`.
+
+### Added
+
+- **Injection selection policy (on by default)** — `src/select.ts` decides
+  WHICH active items for the active model get surfaced each turn, and in what
+  order. Pure and fully unit-tested; `inject.ts` is now thin glue over it.
+  Policy: (1) filter to active + owner-model items (strict per-model isolation,
+  unchanged); (2) order by importance desc, ties stable on store index; (3) cap
+  via `maxPerKind` (balanced sections — no single kind drowns the block) then
+  `maxTokens` (total budget, filled round-robin across kinds by importance rank
+  so one kind can't starve the others; an item that doesn't fit is *skipped*, not
+  a hard stop, so a large item never blocks smaller higher-priority ones).
+- **Config: `injection`** in `harness.json` — `{ enabled, maxTokens, maxPerKind,
+  charsPerToken }`, always resolved by `loadConfig`. Shipped defaults: `enabled:
+  true`, `maxTokens: 1500`, `maxPerKind: 10`, `charsPerToken: 4` — generous
+  enough to be a NO-OP for small stores (nothing trimmed) and protective as the
+  harness accumulates. Opt out with `injection.enabled: false` → legacy "all
+  items, in store order".
+- **Transparency footer** — when the policy drops items, the injected block ends
+  with a one-line `_(N item(s) not shown — below the injection budget…)_` note,
+  so a bounded block is never silently truncated.
+- **Public API** — `selectForInjection`, `normalizeInjection`, `estimateTokens`,
+  `DEFAULT_INJECTION`, and the `InjectionConfig` / `NormalizedInjection` types
+  are re-exported from the package entry for companion packages and tests.
+
+### Changed
+
+- `renderHarnessBlock(ownerKey?, cfg?)` now renders the selected subset (defaults
+  apply when `cfg` is omitted, so direct callers — including existing tests —
+  get the new policy). `before_agent_start` reads `injection` from config and
+  passes it through.
+- Default injection is now importance-ordered. This reorders (and, for large
+  stores, trims) the supplemental block, but changes no data: items remain in the
+  store, `/tree` rollback is unaffected, and the durable round-trip is
+  unchanged. Set `injection.enabled: false` to restore the pre-0.8 block exactly.
+
+### Docs
+
+- README: new "Injection selection (on by default)" section + `injection` in the
+  config block; Status updated. MANUAL: injection-selection section. ROADMAP:
+  Phase 7. 25 new tests (`test/select.test.ts` + injection/config/integration
+  coverage); 137 total, typecheck clean.
+
+## [0.7.0] — 2026-08-09
+
+The per-model isolation release. Every item is bound to an exact `provider/id`
+and injected only for the model it belongs to — a brand-new model id starts from
+a blank harness, and one model's notes never leak into another's context.
+
+### Added
+
+- **Per-model isolation (`ownerModel`).** Every item now carries an
+  `ownerModel` (`"provider/id"`, or `""` for an orphan) and is injected only for
+  the model it belongs to. Binding is at the exact id by design — a new version
+  is a clean slate.
+  - Creates are stamped automatically: `before_agent_start` caches the active
+    model (the model-facing tools receive no `ctx`), then `harness_mutate` and
+    direct-apply proposers stamp creates from it.
+  - **Orphan adoption** is the migration path: items with no owner (legacy
+    session snapshots, old durable files, or created while the model was
+    unknown) are adopted by the active model on first contact — persisted as a
+    normal `harness-state` entry, so `/tree` rollback covers it.
+  - `harness_list({ model? })` — defaults to the active model's items; `"*"`
+    returns every model; an explicit `"provider/id"` filters.
+- **`/harness push-mem --model <provider/id|active>`** — scope a pi-mem push to
+  one model's items (`active` resolves to the model driving the command).
+
+### Changed
+
+- **Durable round-trip preserves owner** via a per-item `model:` line; an
+  untagged item degrades to an orphan and is adopted on import/first contact.
+- Injection, `harness_list`, and the outcome loop are model-scoped; the `dedupe`
+  proposer no longer compares items across models.
+- `/harness status` shows whole-store kind counts, annotated with the active
+  model's share.
+
+### Fixed
+
+- **`harness_mutate` isolation** (PR review): `update`/`delete` are now scoped
+  to the active model too — an agent on model A can no longer mutate model B's
+  item by id (atomic rollback with a clear error). Cross-model maintenance paths
+  (`dedupe`, `/harness keep|drop|prune`) pass no actor and are unaffected.
+- **Durable owner semantics** (PR review): an absent `model:` tag on an existing
+  item now orphans it (→ adopted by the active model) instead of silently
+  keeping the old owner — "durable wins" now covers owner uniformly.
+- `session_start` resets the cached active-model key across fork/resume.
+
+### Docs
+
+- README + MANUAL model-binding sections; MANUAL updated for the review fixes
+  (`harness_mutate` actor scoping, model-aware `dedupe`, model-scoped outcome,
+  whole-store `status`); ROADMAP Phase 6; stale `0.5.x` version strings
+  corrected; this CHANGELOG introduced.
+- Cross-linked the [pi-harness-model-proposer](https://github.com/pungggi/pi-harness-model-proposer)
+  companion.
+
+### Internal
+
+- 19 files changed (+876/−52 over 0.6.2). **112 tests** (+25), typecheck clean;
+  new `test/model-binding.test.ts`. Durable format and tool schemas extended
+  backward-compatibly (missing `ownerModel` → orphan → adopted).