pi-continual-harness 0.6.2 → 0.8.0

package/README.md

@@ -64,7 +64,7 @@ Durable I/O (round-trip with pi-reflect):
 /harness prune [--decay <days>]  # drop items below the importance floor
 /harness keep <id>               # nudge importance up (+0.1)
 /harness drop <id>               # nudge importance down (−0.1)
-/harness push-mem [--all|--kind <kind>]  # persist active items to pi-mem (save_memory)
+/harness push-mem [--all|--kind <kind>|--model <provider/id|active>]  # persist active items to pi-mem (save_memory)
 ```
 
 `import` reconciles the file into the live store: items whose id matches an
@@ -79,9 +79,12 @@ preserved). Point pi-reflect at the same file to refine it offline:
 
 The model-facing tools:
 
-- `harness_list [kind]` — read current state (optionally filtered by kind).
+- `harness_list({ kind?, model? })` — read current state. `model` defaults to
+  the active model's items (what gets injected this turn); `"*"` returns every
+  model.
 - `harness_mutate { deltas: [...] }` — apply a batch of `create` / `update` /
-  `delete` deltas. Every `create` requires `evidence`.
+  `delete` deltas. Every `create` requires `evidence`. New items are stamped
+  automatically with the active model (see [Model binding](#model-binding-per-model-isolation)).
 
 Active items are injected into the system prompt each turn as a structured
 block, appended to (never replacing) the base prompt.
@@ -100,9 +103,10 @@ pi install npm:pi-mem        # optional companion
 ```
 
 By default only **memory**-kind items are pushed (the clean 1:1 mapping); use
-`--all` for every active item or `--kind prompt|skill|subagent` for a specific
-kind. The harness store itself is unchanged by a push — pi-mem gets a separate
-copy.
+`--all` for every active item, `--kind prompt|skill|subagent` for a specific
+kind, or `--model <provider/id|active>` to scope the push to one model's items
+(`--model active` = the model driving the command). The harness store itself is
+unchanged by a push — pi-mem gets a separate copy.
 
 ## Configuration
 
@@ -112,6 +116,7 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
 {
   "durableScope": "global",
   "proposer": "steering",
+  "injection": { "enabled": true, "maxTokens": 1500, "maxPerKind": 10, "charsPerToken": 4 },
   "remindRefine": { "enabled": false, "everyTurns": 50 },
   "autoRefine": { "enabled": false, "everyTurns": 100, "commit": false },
   "outcomeImportance": { "enabled": false, "bump": 0.03 }
@@ -122,6 +127,11 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
   `~/.pi/agent/harness-state.md`; `"project"` writes to
   `~/.pi/agent/harness-state/<slug>.md` (slug derived from `cwd`) so each
   project keeps separate state for pi-reflect.
+- **`injection`** — the selection policy for WHAT gets surfaced in the system
+  prompt each turn (see [Injection selection](#injection-selection-on-by-default)).
+  ON by default: items are importance-ordered, capped at `maxPerKind` (default
+  10) per kind and `maxTokens` (default 1500) total. Set `enabled: false` to
+  restore the legacy "inject all items, in store order" behaviour.
 - **`proposer`** — which delta proposer `/refine` and auto-refine use. Defaults
   to `steering` (the agent reasons via a steering message). `dedupe` applies a
   rule-based dedupe directly. See [Proposers](#proposers).
@@ -154,13 +164,93 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
 3. The agent calls the tools (steering path); each accepted delta updates the
    in-memory state, which is snapshotted to the session via
    `appendEntry("harness-state", ...)`. Direct-apply proposers snapshot the
-   same way.
+   same way. New items are stamped with the active model (see
+   [Model binding](#model-binding-per-model-isolation)).
 4. Because pi's session tree branches at any entry, `/tree` navigation gives
    rollback to any pre-refinement point for free — no bespoke snapshot system.
 
 This reuses the existing agent loop (no nested/hidden model calls), is
 model-agnostic, and keeps every delta visible and reviewable in the transcript.
 
+## Model binding (per-model isolation)
+
+Every item is bound to exactly one model as `ownerModel` (`"provider/id"`). An
+item is **only injected for the model it belongs to** — so switching to a
+brand-new model id starts from a **blank harness**, and one model's notes never
+leak into another's context. Binding is at the *exact* model id (not family or
+vendor): a new version id is a clean slate, by design.
+
+How the binding is set and respected:
+
+- **Created items are stamped automatically** with the model driving the turn.
+  The model-facing tools cannot read the active model, so `before_agent_start`
+  (which always fires first in a turn, with the model) caches it; `harness_mutate`
+  stamps creates from that cache, and direct-apply proposers stamp from their
+  `ctx.model`. You never name the model yourself.
+- **Injection filters by owner.** Only items whose `ownerModel` matches the
+  active model are appended to the system prompt. An unknown model injects
+  nothing.
+- **`harness_list` defaults to the active model** (pass `model: "*"` for every
+  model, or an explicit `"provider/id"`).
+- **Orphan adoption.** Items with no owner — from a legacy session snapshot, an
+  old durable file, or created while the model was unknown — are adopted by the
+  active model on first contact (the next `before_agent_start`). This is the
+  migration path: existing harnesses transition cleanly with no manual steps,
+  and it's persisted as a normal `harness-state` entry (so `/tree` rollback
+  covers it).
+- **Durable round-trip preserves owner.** `/harness export` tags each item with
+  `model: provider/id`; `/harness import` restores it. An item whose tag
+  pi-reflect stripped becomes an orphan and is adopted by the active model.
+
+Manual commands (`export`, `import`, `keep`, `drop`, `prune`, `push-mem`,
+`status`) operate on the **whole store** by design — they are explicit human
+actions with full control. Isolation is enforced only where pollution would
+leak automatically: injection, listing, create-stamping, and the outcome loop.
+In particular, `/harness push-mem` pushes *every* model's active items into
+pi-mem by default (which can yield near-duplicate memories across models); pass
+`--model <provider/id|active>` to scope it to one model.
+
+## Injection selection (on by default)
+
+The harness ACCUMULATES notes (create / refine / auto-refine / outcome-promotion),
+but the system prompt is finite. So since 0.8 the block appended each turn is the
+result of a **selection policy**, not the whole store — and it is **on by
+default**. The store itself is never changed by selection (nothing is lost);
+only what is *surfaced* changes.
+
+The policy (pure, deterministic; `src/select.ts`):
+
+1. **Filter** — only active items bound to the active model (strict per-model
+   isolation, unchanged).
+2. **Order** — importance desc; ties keep store/insertion order (stable). The
+   highest-fitness notes lead each section.
+3. **Cap** — `maxPerKind` (default 10: balanced sections, no single kind drowns
+   the block), then `maxTokens` (default 1500: total budget). The budget is
+   filled **round-robin across kinds by importance rank**, so one kind cannot
+   starve the others; within that order an item that doesn't fit is **skipped**
+   (not a hard stop), so a large item never blocks smaller higher-priority ones.
+
+The defaults are deliberately generous — a **no-op for small stores** (nothing
+trimmed) and protective as the harness grows. When the policy drops items, the
+block ends with a one-line transparency note:
+
+```
+_(3 item(s) not shown — below the injection budget. Raise `injection.maxTokens`/`maxPerKind` in harness.json or run `/harness prune`.)_
+```
+
+Tune or disable it in `harness.json`:
+
+```json
+{ "injection": { "maxTokens": 3000, "maxPerKind": 20 } }   // raise the ceiling
+{ "injection": { "maxPerKind": 5 } }                        // trim harder, per kind
+{ "injection": { "enabled": false } }                       // opt out: legacy "all, in order"
+```
+
+Selection is factored into a pure function (`selectForInjection`) and
+re-exported from the package entry, so a companion package can layer richer
+policies (e.g. relevance to the current turn, via the shared `tokenize` /
+`tokenOverlap` helpers) without touching `inject.ts`.
+
 ## Proposers
 
 `/refine` is split into two stages: **propose** (given evidence + state, decide
@@ -186,7 +276,8 @@ available, `/refine` injects a one-shot `complete(prompt, opts?)` into
 `ProposeInput` and records any `modelCall` telemetry a proposer returns
 (model, tokens, latency, ok/error) in the `harness-refinement` audit entry —
 so a companion package can ship a dedicated-model proposer whose spend stays
-**audited, not hidden**. Both `complete` and `modelCall` are optional;
+**audited, not hidden**. One ships as a companion: **[pi-harness-model-proposer](https://github.com/pungggi/pi-harness-model-proposer)**
+(`pi install npm:pi-harness-model-proposer`). Both `complete` and `modelCall` are optional;
 `steering` and `dedupe` ignore them, so the default behavior is unchanged.
 
 Register your own proposer from another extension (the registry is re-exported
@@ -219,14 +310,14 @@ Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
 
 ## Status
 
-0.5.x. Implemented:
+0.8.x. Implemented:
 
 - Unified harness-state store with branch-local snapshots (`/tree` rollback).
 - Online `/refine` + `harness_mutate` / `harness_list` tools.
 - Two-way durable round-trip with pi-reflect (`/harness import|export|status`).
 - Importance hygiene: `/harness prune [--decay <days>]` and `/harness keep|drop
   <id>`.
-- **pi-mem composition**: `/harness push-mem [--all|--kind]` steers the agent
+- **pi-mem composition**: `/harness push-mem [--all|--kind|--model]` steers the agent
   to persist active items into pi-mem (soft-fail; no dependency).
 - Optional config (`~/.pi/agent/harness.json`): project-local durable scope, an
   opt-in `turn_end` reminder, opt-in `turn_end` auto-refine, and an opt-in
@@ -234,6 +325,14 @@ Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
   paths (both off by default).
 - **Pluggable delta proposers** with a registry: `steering` (default) and
   `dedupe` (rule-based) shipped; `registerProposer()` for custom ones.
+- **Per-model isolation**: every item is bound to a `provider/id` and injected
+  only for that model; new items are stamped automatically and orphans adopted
+  on first contact. A new model id starts from a blank harness, and the durable
+  round-trip preserves the owner tag.
+- **Bounded injection (on by default)**: the supplemental block is
+  importance-ordered and capped per kind + by a total token budget, so a growing
+  harness never balloons the system prompt. Tunable / opt-out via the `injection`
+  config key; the store is never changed by selection.
 
 Open extension points (see `docs/ROADMAP.md`):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-continual-harness",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "Online self-improvement layer for pi. A unified, in-trajectory harness-state store (prompt notes, memory, skill descriptions, sub-agent specs) with a manual /refine that proposes evidence-backed structured CRUD deltas. Composes with pi-reflect (offline) and pi-mem (storage); owns only the online optimizer layer. Inspired by Continual Harness (arXiv 2605.09998) and ACE (arXiv 2510.04618).",
   "keywords": [
     "pi-package",

package/src/config.ts

@@ -14,6 +14,7 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { DEFAULT_DURABLE_PATH } from "./store.js";
+import { DEFAULT_INJECTION, normalizeInjection, type NormalizedInjection } from "./select.js";
 
 export const DEFAULT_EVERY_TURNS = 50;
 export const DEFAULT_AUTO_EVERY_TURNS = 100;
@@ -39,6 +40,9 @@ export interface HarnessConfig {
     enabled?: boolean;
     bump?: number;
   };
+  /** Injection selection policy (on by default). Resolved by loadConfig, so the
+   *  value here is always fully-populated. See src/select.ts. */
+  injection?: NormalizedInjection;
 }
 
 export const DEFAULT_CONFIG: HarnessConfig = {
@@ -47,6 +51,10 @@ export const DEFAULT_CONFIG: HarnessConfig = {
   autoRefine: { enabled: false, everyTurns: DEFAULT_AUTO_EVERY_TURNS, commit: false },
   proposer: "steering",
   outcomeImportance: { enabled: false, bump: DEFAULT_REF_BUMP },
+  // ON by default: importance-ordered, maxPerKind 10, maxTokens 1500. A no-op
+  // for small stores; protective as the harness accumulates. Opt out with
+  // `injection.enabled: false`. See src/select.ts.
+  injection: DEFAULT_INJECTION,
 };
 
 export const CONFIG_PATH = join(homedir(), ".pi", "agent", "harness.json");
@@ -71,6 +79,10 @@ function mergeConfig(over: Partial<HarnessConfig>): HarnessConfig {
       enabled: over.outcomeImportance?.enabled ?? false,
       bump: coerceBump(over.outcomeImportance?.bump),
     },
+    // normalizeInjection is defensive (bad types → defaults), so a partial or
+    // malformed `injection` object degrades to the shipped defaults rather than
+    // corrupting the block sizing arithmetic.
+    injection: normalizeInjection(over.injection as Partial<{ enabled: boolean; maxTokens: number; maxPerKind: number; charsPerToken: number }> | undefined),
   };
 }
 

package/src/harness.ts

@@ -19,6 +19,7 @@ import {
   decayAndPrune,
   exportDurable,
   getState,
+  modelKey,
   reconstructFromDurable,
 } from "./store.js";
 import { loadConfig, resolveDurablePath } from "./config.js";
@@ -30,7 +31,7 @@ export function registerHarness(pi: ExtensionAPI): void {
       "Durable harness-state I/O + importance hygiene. Subcommands: " +
       "import [--prune] [path] · export [path] · status [path] · " +
       "prune [--decay <days>] · keep <id> · drop <id> · " +
-      "push-mem [--all|--kind <kind>] (persist active items to pi-mem).",
+      "push-mem [--all|--kind <kind>|--model <provider/id|active>] (persist active items to pi-mem).",
     handler: async (args, ctx) => {
       const parts = args.trim().split(/\s+/).filter(Boolean);
       const sub = (parts[0] ?? "status").toLowerCase();
@@ -202,27 +203,44 @@ async function handlePushMem(
     const k = rest[kindIdx + 1]!;
     if (k === "prompt" || k === "memory" || k === "skill" || k === "subagent") kind = k;
   }
+  // --model scopes the push to one owner model (default: every model). "active"
+  // resolves to the model driving this command, so you don't have to name it.
+  const modelIdx = rest.indexOf("--model");
+  let modelFilter: string | undefined;
+  if (modelIdx >= 0 && modelIdx + 1 < rest.length) {
+    const m = rest[modelIdx + 1]!;
+    modelFilter = m === "active" ? (modelKey(ctx.model) ?? "") : m;
+  }
   // Default: memory kind (the clean 1:1 mapping). --all or --kind override.
-  const items = getState().items.filter((i) =>
-    i.active && (all || (kind ? i.kind === kind : i.kind === "memory")),
+  const items = getState().items.filter(
+    (i) =>
+      i.active &&
+      (all || (kind ? i.kind === kind : i.kind === "memory")) &&
+      (modelFilter === undefined || i.ownerModel === modelFilter),
   );
   if (items.length === 0) {
     ctx.ui.notify(
-      "No active items to push (default: memory kind; use --all or --kind <kind>).",
+      "No active items to push (default: memory kind; use --all, --kind <kind>, or --model <provider/id|active>).",
       "warning",
     );
     return;
   }
   const scope = all ? "item(s)" : `${kind ?? "memory"} item(s)`;
+  const modelNote = modelFilter !== undefined ? ` [model ${modelFilter || "(orphan)"}]` : "";
   const msg = buildPushMemPrompt(items, scope);
   pi.sendUserMessage(msg);
-  ctx.ui.notify(`Steering agent to persist ${items.length} ${scope} to pi-mem.`, "info");
+  ctx.ui.notify(`Steering agent to persist ${items.length} ${scope}${modelNote} to pi-mem.`, "info");
 }
 
 async function handleStatus(ctx: ExtensionCommandContext, rest: string[]): Promise<void> {
   const path = await resolvePath(rest, ctx);
   const items = getState().items;
   const active = items.filter((i) => i.active);
+  const key = modelKey(ctx.model);
+  const models = [...new Set(active.map((i) => i.ownerModel).filter(Boolean))];
+  const mine = key ? active.filter((i) => i.ownerModel === key).length : active.length;
+  // Status is a whole-store view: kind counts span every model. Annotate with
+  // the current model's share so the per-model picture is still visible.
   const counts: Record<ComponentKind, number> = { prompt: 0, memory: 0, skill: 0, subagent: 0 };
   for (const i of active) counts[i.kind] += 1;
   let fileState: string;
@@ -235,8 +253,9 @@ async function handleStatus(ctx: ExtensionCommandContext, rest: string[]): Promi
   ctx.ui.setStatus("harness", undefined);
   ctx.ui.notify(
     `Harness: ${active.length} active / ${items.length} total — ` +
-      `prompt ${counts.prompt}, memory ${counts.memory}, skill ${counts.skill}, subagent ${counts.subagent}. ` +
-      `Durable: ${fileState}.`,
+      `prompt ${counts.prompt}, memory ${counts.memory}, skill ${counts.skill}, subagent ${counts.subagent}.` +
+      (key ? ` ${mine} active for [${key}] across ${models.length} model(s).` : "") +
+      ` Durable: ${fileState}.`,
     "info",
   );
 }

package/src/index.ts

@@ -14,7 +14,7 @@ import { registerTools } from "./tools.js";
 import { registerReminder, resetReminder } from "./remind.js";
 import { registerAutoRefine, resetAutoRefine } from "./auto-refine.js";
 import { registerOutcome, resetOutcome } from "./outcome.js";
-import { getState, reconstruct, STATE_ENTRY } from "./store.js";
+import { getState, reconstruct, setActiveModelKey, STATE_ENTRY } from "./store.js";
 
 export default function continualHarness(pi: ExtensionAPI): void {
   // Rebuild in-memory state from the current branch on every session start /
@@ -26,6 +26,9 @@ export default function continualHarness(pi: ExtensionAPI): void {
     resetAutoRefine();
     resetReminder();
     resetOutcome();
+    // Drop any stale active-model key from the previous session: the next
+    // before_agent_start re-caches it before any tool can run.
+    setActiveModelKey(undefined);
     reconstruct(ctx.sessionManager.getBranch() as Iterable<unknown>);
     const n = getState().items.length;
     if (n > 0) {
@@ -71,3 +74,16 @@ export {
   type ProposedDelta,
   type ProposeResult,
 } from "./proposer.js";
+
+// Injection selection policy (on by default). Re-exported so companion packages
+// and tests can reuse the pure selection/normalization without reaching into
+// internal paths.
+export {
+  DEFAULT_INJECTION,
+  estimateTokens,
+  normalizeInjection,
+  selectForInjection,
+  type InjectionConfig,
+  type NormalizedInjection,
+  type SelectionResult,
+} from "./select.js";

package/src/inject.ts

@@ -1,13 +1,25 @@
 // before_agent_start: inject the active harness state as a structured block
 // appended to the base system prompt. Never rewrites or replaces the base —
 // only appends, matching Continual Harness's "immutable base + supplemental".
+//
+// This handler is also the model-binding bridge. The model-facing tools
+// (harness_list / harness_mutate) receive NO ctx, so they cannot read the
+// active model at execute time. before_agent_start always fires first in a turn
+// WITH ctx.model, so it: (1) caches the active model key for the tools,
+// (2) adopts any orphan items to the active model (the migration policy), and
+// (3) renders ONLY items bound to the active model — strict per-model isolation.
+//
+// WHAT gets rendered is decided by the selection policy in select.ts (on by
+// default): importance-ordered, capped per kind and by a total token budget, so
+// the block stays bounded as the harness accumulates. Configurable / opt-out via
+// harness.json `injection`; the legacy "all items, in order" mode is a toggle.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { getState } from "./store.js";
+import { adoptOrphans, getState, modelKey, setActiveModelKey } from "./store.js";
+import { KIND_ORDER, selectForInjection, type InjectionConfig } from "./select.js";
+import { loadConfig } from "./config.js";
 import type { ComponentKind } from "./types.js";
 
-const ORDER: ComponentKind[] = ["prompt", "memory", "skill", "subagent"];
-
 const TITLES: Record<ComponentKind, string> = {
   prompt: "Self-improved prompt notes",
   memory: "Remembered facts",
@@ -15,34 +27,66 @@ const TITLES: Record<ComponentKind, string> = {
   subagent: "Reusable sub-agent specs",
 };
 
-export function renderHarnessBlock(): string {
-  const state = getState();
-  if (state.items.length === 0) return "";
+/**
+ * Render the harness block for a single model. Selection (`cfg`) defaults to the
+ * shipped policy when omitted — importance-ordered, capped per kind and by a
+ * total token budget (see select.ts). Only active items whose ownerModel ===
+ * ownerKey are ever considered. An undefined ownerKey (no active model) renders
+ * nothing — isolation is strict: unknown model → inject nothing.
+ */
+export function renderHarnessBlock(ownerKey?: string, cfg?: InjectionConfig): string {
+  if (ownerKey === undefined) return "";
+  const items = getState().items;
+  if (items.length === 0) return "";
+
+  const { selected, omitted } = selectForInjection(items, ownerKey, cfg);
+  if (selected.length === 0) return "";
 
   const sections: string[] = [];
-  for (const kind of ORDER) {
-    const items = state.items.filter((i) => i.kind === kind && i.active);
-    if (items.length === 0) continue;
-    const bullets = items
-      .map((i) => `- [${i.id}] ${i.content}`)
-      .join("\n");
+  for (const kind of KIND_ORDER) {
+    const forKind = selected.filter((i) => i.kind === kind);
+    if (forKind.length === 0) continue;
+    const bullets = forKind.map((i) => `- [${i.id}] ${i.content}`).join("\n");
     sections.push(`### ${TITLES[kind]}\n${bullets}`);
   }
   if (sections.length === 0) return "";
 
-  return [
+  const lines = [
     "",
     "## Continual Harness state",
     "Self-improved notes accumulated from past trajectories via /refine.",
     "Treat these as durable working context. Update them with the harness_mutate tool when they are wrong or stale.",
     "",
     sections.join("\n\n"),
-  ].join("\n");
+  ];
+  // Transparency: when the selection policy dropped items, say so — the block is
+  // bounded on purpose, and the user should know the store has more than shows.
+  if (omitted > 0) {
+    lines.push(
+      "",
+      `_(${omitted} item(s) not shown — below the injection budget. Raise \`injection.maxTokens\`/\`maxPerKind\` in harness.json or run \`/harness prune\`.)_`,
+    );
+  }
+  return lines.join("\n");
 }
 
 export function registerInjection(pi: ExtensionAPI): void {
-  pi.on("before_agent_start", async (event) => {
-    const block = renderHarnessBlock();
+  pi.on("before_agent_start", async (event, ctx) => {
+    const key = modelKey(ctx.model);
+    // Cache for the model-facing tools (they have no ctx of their own).
+    setActiveModelKey(key);
+    // Adopt any orphans to the active model (legacy/import migration). No-op —
+    // and no persist — when there is nothing to adopt.
+    if (key) {
+      adoptOrphans(key, (snapshot, ver) => {
+        pi.appendEntry("harness-state", { state: snapshot, version: ver });
+      });
+    }
+    // Read the injection policy from config (cached; tolerant). The default is
+    // ON — importance-ordered + bounded — so a growing harness never balloons
+    // the system prompt. Opt out via harness.json `injection.enabled: false`.
+    const { injection } = await loadConfig();
+    const block = renderHarnessBlock(key, injection);
     if (!block) return;
     return { systemPrompt: event.systemPrompt + "\n" + block };
   });

package/src/outcome.ts

@@ -24,7 +24,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_REF_BUMP, type HarnessConfig, loadConfig } from "./config.js";
-import { bumpImportance, getState } from "./store.js";
+import { bumpImportance, getState, modelKey } from "./store.js";
 
 // Minimal entry shape; kept loose to avoid coupling to pi's internal types.
 type AnyEntry = {
@@ -83,7 +83,14 @@ export function registerOutcome(pi: ExtensionAPI): void {
       .join("\n");
     if (!text.trim()) return;
 
-    const activeIds = new Set(getState().items.filter((i) => i.active).map((i) => i.id));
+    // Only the active model's items are injected, so only those can be cited.
+    // Filter accordingly; an unknown model → no candidates → no bumps.
+    const key = modelKey(ctx.model);
+    const activeIds = new Set(
+      key === undefined
+        ? []
+        : getState().items.filter((i) => i.active && i.ownerModel === key).map((i) => i.id),
+    );
     const refs = findReferences(text, activeIds);
     if (refs.length === 0) return;
 

package/src/proposer.ts

@@ -175,6 +175,9 @@ export const dedupeProposer: DeltaProposer = {
       let best = 0;
       for (const k of keepers) {
         if (k.kind !== cand.kind) continue;
+        // Per-model isolation: each model keeps its own copy, so two near-
+        // identical items bound to different models are NOT duplicates.
+        if (k.ownerModel !== cand.ownerModel) continue;
         const sim = tokenOverlap(k.content, cand.content);
         if (sim >= DEDUPE_THRESHOLD && sim > best) {
           best = sim;

package/src/refine.ts

@@ -19,7 +19,7 @@
 
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Context, Model, TextContent } from "@earendil-works/pi-ai";
-import { applyDeltas, exportDurable, REFINE_ENTRY, snapshotState } from "./store.js";
+import { applyDeltas, exportDurable, modelKey, REFINE_ENTRY, snapshotState } from "./store.js";
 import { getProposer } from "./proposer.js";
 import type { CompleteOptions, CompleteResult } from "./proposer.js";
 
@@ -96,6 +96,11 @@ export async function runRefine(
     ...(complete ? { complete } : {}),
   });
   const proposedDeltas = result.deltas ?? [];
+  // Stamp direct-apply create deltas with the active model so proposer-authored
+  // notes bind to the model driving the turn (the steering path is stamped in
+  // the harness_mutate tool instead). Orphans result only when the model is
+  // unknown; before_agent_start adopts them on the next turn.
+  const ownerKey = modelKey(ctx.model);
 
   let applied = 0;
   let applyError: string | undefined;
@@ -108,7 +113,12 @@ export async function runRefine(
     // so we surface the failure as an audited no-op rather than crashing /refine.
     try {
       const appliedDeltas = applyDeltas(
-        proposedDeltas.map((d) => d.delta),
+        proposedDeltas.map((d) => {
+          const delta = d.delta;
+          return ownerKey !== undefined && delta.op === "create"
+            ? { ...delta, ownerModel: ownerKey }
+            : delta;
+        }),
         (snapshot, ver) => pi.appendEntry("harness-state", { state: snapshot, version: ver }),
       );
       applied = appliedDeltas.length;

package/src/select.ts

@@ -0,0 +1,184 @@
+// Injection selection policy: WHICH active items for the active model get
+// surfaced in the system-prompt block, and in what order.
+//
+// The harness ACCUMULATES notes (create / refine / auto-refine /
+// outcome-promotion), but the system prompt is a finite resource. Without
+// selection, every active item for the model is injected every turn, unbounded —
+// so a long-running session's prompt grows without limit and the most valuable
+// notes compete with the least for attention. Selection is ON BY DEFAULT with
+// conservative knobs that are a NO-OP for small stores (nothing trimmed) and
+// protective for large ones. Opt out entirely with `injection.enabled = false`
+// → legacy "all items, in store order".
+//
+// Policy (pure, deterministic, unit-tested in test/select.test.ts):
+//   1. FILTER — active items bound to the active model (strict per-model
+//      isolation, same rule inject.ts always enforced).
+//   2. ORDER  — importance desc; ties keep store/insertion order (stable), so
+//      the highest-fitness notes lead each section.
+//   3. CAP    — `maxPerKind` (balanced sections: no single kind drowns the
+//      block), then `maxTokens` (total budget). The budget is filled
+//      round-robin across kinds by importance rank, so one kind cannot starve
+//      the others; within that order an item that does not fit is *skipped*
+//      (not a hard stop), so a single large item never blocks smaller
+//      higher-priority ones after it.
+//
+// Kept pure + side-effect-free on purpose: inject.ts is thin glue over this, and
+// the decision is fully unit-testable without a live pi runtime (the same
+// factoring pattern remind.ts / auto-refine.ts / outcome.ts use).
+
+import type { ComponentKind, HarnessItem } from "./types.js";
+
+/** Canonical kind order (shared with inject.ts so there is one source of truth). */
+export const KIND_ORDER: ComponentKind[] = ["prompt", "memory", "skill", "subagent"];
+
+/** User-facing injection config (all optional; defaults applied on read). */
+export interface InjectionConfig {
+  /** Master switch. `false` → selection disabled (legacy: inject all, in store
+   *  order). Default `true`. */
+  enabled?: boolean;
+  /** Max total tokens (≈ chars / charsPerToken) for the rendered block,
+   *  including the intro + section headers + items. Default 1500. */
+  maxTokens?: number;
+  /** Max items surfaced per kind. Default 10. */
+  maxPerKind?: number;
+  /** Token estimate: characters per token. Default 4. */
+  charsPerToken?: number;
+}
+
+/** Fully-resolved injection config (post-defaults; what loadConfig returns). */
+export interface NormalizedInjection {
+  enabled: boolean;
+  maxTokens: number;
+  maxPerKind: number;
+  charsPerToken: number;
+}
+
+/** The shipped defaults — ON, but generous enough to never trim a small store. */
+export const DEFAULT_INJECTION: NormalizedInjection = {
+  enabled: true,
+  maxTokens: 1500,
+  maxPerKind: 10,
+  charsPerToken: 4,
+};
+
+// Token-overhead estimates for the parts of the rendered block that are not item
+// text, so the budget reflects the real appended size (see inject.ts). These are
+// deliberately rough heuristics; the goal is a meaningful ceiling, not exactness.
+const INTRO_TOKENS = 55; // "## Continual Harness state" + the two description lines
+const SECTION_HEADER_TOKENS = 8; // "### <title>" per present section
+const FOOTER_TOKENS = 18; // the omitted-count footer, when it renders
+
+/** Resolve a (possibly partial / absent / malformed) config against the defaults.
+ *  Defensive: bad types fall back to defaults, never throws. */
+export function normalizeInjection(cfg?: Partial<InjectionConfig>): NormalizedInjection {
+  const num = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v) && v > 0;
+  return {
+    enabled: typeof cfg?.enabled === "boolean" ? cfg.enabled : DEFAULT_INJECTION.enabled,
+    maxTokens: num(cfg?.maxTokens) ? cfg.maxTokens : DEFAULT_INJECTION.maxTokens,
+    maxPerKind: num(cfg?.maxPerKind) ? cfg.maxPerKind : DEFAULT_INJECTION.maxPerKind,
+    charsPerToken: num(cfg?.charsPerToken) ? cfg.charsPerToken : DEFAULT_INJECTION.charsPerToken,
+  };
+}
+
+/** Rough token estimate for a string. Exported for tests/companions. */
+export function estimateTokens(text: string, charsPerToken = DEFAULT_INJECTION.charsPerToken): number {
+  return Math.ceil(text.length / charsPerToken);
+}
+
+export interface SelectionResult {
+  /** Chosen items, grouped by KIND_ORDER, importance-desc within each group. */
+  selected: HarnessItem[];
+  /** Active items for the model that did NOT make the cut (per-kind + budget). */
+  omitted: number;
+  /** True when any item was dropped (drives the transparency footer). */
+  truncated: boolean;
+}
+
+interface Ranked {
+  item: HarnessItem;
+  index: number; // store position, for a stable tie-break on equal importance
+}
+
+/** importance desc, then store index asc (stable). */
+function byImportance(a: Ranked, b: Ranked): number {
+  if (b.item.importance !== a.item.importance) return b.item.importance - a.item.importance;
+  return a.index - b.index;
+}
+
+/**
+ * Select the items to inject for `ownerKey`. Pure: takes a snapshot, returns a
+ * decision. See the module doc for the policy.
+ *
+ * `items` is read-only here — callers (inject.ts) pass `getState().items` plus
+ * the active model key; nothing is mutated.
+ */
+export function selectForInjection(
+  items: HarnessItem[],
+  ownerKey: string,
+  cfg?: Partial<InjectionConfig>,
+): SelectionResult {
+  const n = normalizeInjection(cfg);
+
+  // 1. FILTER: group active items bound to the active model, per kind, in
+  //    store order. (Importance ranking happens below, only when enabled.)
+  const groups = new Map<ComponentKind, Ranked[]>();
+  for (const kind of KIND_ORDER) groups.set(kind, []);
+  items.forEach((item, index) => {
+    if (item.active && item.ownerModel === ownerKey) {
+      groups.get(item.kind)!.push({ item, index });
+    }
+  });
+  if (!n.enabled) {
+    // Legacy opt-out: every active item for the model, grouped by kind, in
+    // STORE (insertion) order — deliberately NOT importance-sorted. Returning to
+    // the pre-selection behaviour is the whole point of `enabled: false`.
+    const selected = KIND_ORDER.flatMap((kind) => groups.get(kind)!.map((r) => r.item));
+    return { selected, omitted: 0, truncated: false };
+  }
+
+  // Importance desc, stable on store index (ties keep insertion order).
+  for (const arr of groups.values()) arr.sort(byImportance);
+
+  // 2a. CAP per kind (maxPerKind): drop the lowest-importance tail of each kind.
+  let omitted = 0;
+  const capped = new Map<ComponentKind, Ranked[]>();
+  for (const kind of KIND_ORDER) {
+    const arr = groups.get(kind)!;
+    const kept = arr.slice(0, n.maxPerKind);
+    omitted += arr.length - kept.length;
+    capped.set(kind, kept);
+  }
+
+  // 2b. CAP total (maxTokens): flatten round-robin (rank-major, kind order
+  // within a rank) so importance is prioritized across kinds fairly, then take
+  // greedily while the budget allows — skipping (not stopping on) an item that
+  // does not fit, so a large item never blocks smaller higher-priority ones.
+  const presentKinds = KIND_ORDER.filter((k) => capped.get(k)!.length > 0);
+  const maxRank = presentKinds.reduce((m, k) => Math.max(m, capped.get(k)!.length), 0);
+  const queue: Ranked[] = [];
+  for (let rank = 0; rank < maxRank; rank++) {
+    for (const kind of presentKinds) {
+      const r = capped.get(kind)![rank];
+      if (r) queue.push(r);
+    }
+  }
+
+  const overhead = INTRO_TOKENS + presentKinds.length * SECTION_HEADER_TOKENS + FOOTER_TOKENS;
+  let remaining = Math.max(0, n.maxTokens - overhead);
+  const taken: Ranked[] = [];
+  for (const r of queue) {
+    const cost = estimateTokens(`- [${r.item.id}] ${r.item.content}`, n.charsPerToken);
+    if (cost <= remaining) {
+      remaining -= cost;
+      taken.push(r);
+    }
+  }
+  omitted += queue.length - taken.length;
+
+  // Re-group the survivors into KIND_ORDER sections (importance-desc within each).
+  const selected = KIND_ORDER.flatMap((kind) =>
+    taken.filter((r) => r.item.kind === kind).map((r) => r.item),
+  );
+
+  return { selected, omitted, truncated: omitted > 0 };
+}

package/src/store.ts

@@ -28,6 +28,32 @@ const IMPORTANCE_FLOOR = 0.3;
 let state: HarnessState = { items: [] };
 let version = 0;
 
+// ---- model binding -------------------------------------------------------
+//
+// Items are strictly per-model (ownerModel = "provider/id"). The model-facing
+// tools (harness_list / harness_mutate) receive NO ctx, so they cannot read
+// the active model at execute time. before_agent_start always fires first in a
+// turn WITH ctx.model, so it caches the active key here; the tools then read
+// the cache to stamp/filter. Undefined cache (no turn started) is treated as
+// "model unknown" — tools fall back gracefully (create orphans, list all).
+let activeModelKey: string | undefined;
+
+/** Canonical owner key for a model: "provider/id". Accepts the structural
+ *  shape of pi-ai's Model (provider + id) without importing the type. */
+export function modelKey(m?: { provider: string; id: string }): string | undefined {
+  return m ? `${m.provider}/${m.id}` : undefined;
+}
+
+/** Cache the active model key (called from before_agent_start). */
+export function setActiveModelKey(key: string | undefined): void {
+  activeModelKey = key;
+}
+
+/** Read the cached active model key (called from the model-facing tools). */
+export function getActiveModelKey(): string | undefined {
+  return activeModelKey;
+}
+
 export function getState(): HarnessState {
   return state;
 }
@@ -51,8 +77,10 @@ function clamp(n: number): number {
   return Math.max(0, Math.min(1, n));
 }
 
-/** Apply a single delta against the in-memory state. Does not persist. */
-function applyOne(delta: Delta): AppliedDelta {
+/** Apply a single delta against the in-memory state. Does not persist.
+ *  `actorModel`, when set, stamps creates and restricts update/delete to that
+ *  model's items (per-model isolation at the model-facing tool boundary). */
+function applyOne(delta: Delta, actorModel?: string): AppliedDelta {
   if (delta.op === "create") {
     const now = Date.now();
     const item: HarnessItem = {
@@ -62,6 +90,9 @@ function applyOne(delta: Delta): AppliedDelta {
       evidence: delta.evidence,
       importance: clamp(delta.importance ?? 0.5),
       active: true,
+      // Owner: explicit delta wins; else the actor model; else orphan (""),
+      // adopted by the active model on first contact.
+      ownerModel: delta.ownerModel ?? actorModel ?? "",
       createdAt: now,
       updatedAt: now,
     };
@@ -73,12 +104,17 @@ function applyOne(delta: Delta): AppliedDelta {
     const idx = state.items.findIndex((i) => i.id === delta.id);
     if (idx < 0) throw new Error(`update: no item with id ${delta.id}`);
     const before = state.items[idx]!;
+    // Per-model isolation: when an actor model is known, a mutation may only
+    // touch that model's items. Cross-model maintenance paths (the dedupe
+    // proposer, /harness keep|drop|prune) call applyDeltas with no actor.
+    assertOwnsItem("update", delta.id, before, actorModel);
     const after: HarnessItem = {
       ...before,
       content: delta.content ?? before.content,
       evidence: delta.evidence ?? before.evidence,
       importance: clamp(delta.importance ?? before.importance),
       active: delta.active ?? before.active,
+      ownerModel: delta.ownerModel ?? before.ownerModel,
       updatedAt: Date.now(),
     };
     state.items[idx] = after;
@@ -88,10 +124,28 @@ function applyOne(delta: Delta): AppliedDelta {
   // delete
   const idx = state.items.findIndex((i) => i.id === delta.id);
   if (idx < 0) throw new Error(`delete: no item with id ${delta.id}`);
+  assertOwnsItem("delete", delta.id, state.items[idx]!, actorModel);
   state.items.splice(idx, 1);
   return { op: "delete", id: delta.id, reason: delta.reason };
 }
 
+/** Enforce that `actorModel` owns `item`; no-op when the actor is unknown
+ *  (manual / cross-model paths). Throws an audited, rollback-triggering error
+ *  otherwise. */
+function assertOwnsItem(
+  op: "update" | "delete",
+  id: string,
+  item: HarnessItem,
+  actorModel?: string,
+): void {
+  if (actorModel === undefined) return;
+  if (item.ownerModel !== actorModel) {
+    throw new Error(
+      `${op}: item ${id} is owned by ${item.ownerModel || "(orphan)"}, not the active model ${actorModel}`,
+    );
+  }
+}
+
 /**
  * Apply a batch of deltas. All-or-nothing: if any delta throws, nothing is
  * applied. Returns the applied deltas and the new version.
@@ -99,11 +153,12 @@ function applyOne(delta: Delta): AppliedDelta {
 export function applyDeltas(
   deltas: Delta[],
   persist: (snapshot: HarnessState, version: number) => void,
+  actorModel?: string,
 ): AppliedDelta[] {
   const snapshotBefore = { items: state.items.map((i) => ({ ...i })) };
   const applied: AppliedDelta[] = [];
   try {
-    for (const d of deltas) applied.push(applyOne(d));
+    for (const d of deltas) applied.push(applyOne(d, actorModel));
   } catch (err) {
     // Roll back in-memory state on failure.
     state = snapshotBefore;
@@ -123,7 +178,11 @@ export function reconstruct(entries: Iterable<unknown>): void {
       last = entry.data.state;
     }
   }
-  state = last ? { items: last.items.map((i) => ({ ...i })) } : { items: [] };
+  // Normalize legacy snapshots that predate ownerModel: missing → orphan (""),
+  // adopted by the active model on first contact (see adoptOrphans).
+  state = last
+    ? { items: last.items.map((i) => ({ ...i, ownerModel: i.ownerModel ?? "" })) }
+    : { items: [] };
   version = 0;
 }
 
@@ -172,6 +231,28 @@ export function bumpImportance(
   return item;
 }
 
+/** Adopt every orphan item (ownerModel === "") to the given model key. This is
+ *  the migration policy for legacy snapshots / durable imports / items created
+ *  while the active model was unknown: they become owned by the first model to
+ *  claim them. Idempotent: a no-op (no persist) when there are no orphans. */
+export function adoptOrphans(
+  key: string,
+  persist: (snapshot: HarnessState, version: number) => void,
+): number {
+  let adopted = 0;
+  for (const i of state.items) {
+    if (i.ownerModel === "") {
+      i.ownerModel = key;
+      adopted += 1;
+    }
+  }
+  if (adopted > 0) {
+    version += 1;
+    persist(state, version);
+  }
+  return adopted;
+}
+
 export { STATE_ENTRY, REFINE_ENTRY, IMPORTANCE_FLOOR };
 
 // ---- Durable export (composition seam with pi-reflect / pi-mem) -------------
@@ -186,6 +267,7 @@ export async function exportDurable(path = DEFAULT_DURABLE_PATH): Promise<string
     for (const i of items) {
       lines.push(`- **[${i.id}]** (importance ${i.importance.toFixed(2)}) ${i.content}`);
       lines.push(`  - evidence: ${i.evidence}`);
+      if (i.ownerModel) lines.push(`  - model: ${i.ownerModel}`);
     }
     lines.push("");
   }
@@ -241,6 +323,7 @@ interface ParsedItem {
   importance: number;
   content: string;
   evidence: string;
+  ownerModel?: string;
 }
 
 // Section title → kind. Exact export titles first, then tolerant keyword
@@ -265,6 +348,7 @@ const RE_H2 = /^##\s+(.*)$/;
 const RE_ID_BULLET = /^-\s+\*\*\[([^\]]+)\]\*\*\s*\(importance\s+([\d.]+)\)\s*(.*)$/;
 const RE_PLAIN_BULLET = /^-\s+(.+)$/;
 const RE_EVIDENCE = /^\s+-\s+evidence:\s*(.*)$/i;
+const RE_MODEL = /^\s+-\s+model:\s*(.*)$/i;
 
 /** Parse a durable markdown export into items. Tolerant of pi-reflect's edits. */
 export function parseDurable(text: string): ParsedItem[] {
@@ -296,6 +380,12 @@ export function parseDurable(text: string): ParsedItem[] {
       continue;
     }
 
+    const mdl = line.match(RE_MODEL);
+    if (mdl) {
+      if (pending) pending.ownerModel = mdl[1]!.trim();
+      continue;
+    }
+
     const idm = line.match(RE_ID_BULLET);
     if (idm) {
       flush();
@@ -361,6 +451,10 @@ export async function reconstructFromDurable(
       existing.evidence = p.evidence;
       existing.importance = clamp(p.importance);
       existing.active = true;
+      // Durable wins on owner too: a present tag sets the owner; an absent tag
+      // (e.g. pi-reflect stripped it) orphans the item so it's adopted by the
+      // active model on first contact — matching the documented round-trip.
+      existing.ownerModel = p.ownerModel ?? "";
       existing.updatedAt = now;
       updated += 1;
     } else {
@@ -372,6 +466,7 @@ export async function reconstructFromDurable(
         evidence: p.evidence,
         importance: clamp(p.importance),
         active: true,
+        ownerModel: p.ownerModel ?? "",
         createdAt: now,
         updatedAt: now,
       });

package/src/tools.ts

@@ -8,7 +8,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
-import { applyDeltas, getState, listItems } from "./store.js";
+import { applyDeltas, getActiveModelKey, getState, listItems } from "./store.js";
 import type { AppliedDelta, ComponentKind, Delta } from "./types.js";
 
 const KIND_VALUES = ["prompt", "memory", "skill", "subagent"] as const;
@@ -21,6 +21,9 @@ const CreateShape = Type.Object({
     description: "Why this belongs in the harness state, grounded in trajectory evidence.",
   }),
   importance: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+  // ownerModel is intentionally NOT exposed to the model: it is stamped
+  // server-side from the active model so items bind to the model driving the
+  // turn without the agent having to (or being able to) name it.
 });
 
 const UpdateShape = Type.Object({
@@ -52,10 +55,26 @@ export function registerTools(pi: ExtensionAPI): void {
     ],
     parameters: Type.Object({
       kind: Type.Optional(StringEnum(KIND_VALUES)),
+      model: Type.Optional(
+        Type.String({
+          description:
+            "Filter by owner model as provider/id. Omit = the active model items; use * for all models.",
+        }),
+      ),
     }),
     async execute(_toolCallId, params) {
       const kind = params.kind as ComponentKind | undefined;
-      const items = listItems(kind);
+      const modelFilter = params.model as string | undefined;
+      // Default scope = the active model's items (what gets injected this turn).
+      // "*" = every model; an explicit id = that model. When no active model is
+      // known (no turn started) and no filter is given, return all so the agent
+      // is never silently shown an empty store during setup.
+      const ownerKey =
+        modelFilter === "*"
+          ? undefined
+          : modelFilter ?? getActiveModelKey();
+      let items = listItems(kind);
+      if (ownerKey !== undefined) items = items.filter((i) => i.ownerModel === ownerKey);
       return {
         content: [
           {
@@ -66,7 +85,7 @@ export function registerTools(pi: ExtensionAPI): void {
                 : items
                     .map(
                       (i) =>
-                        `[${i.id}] (${i.kind}, importance ${i.importance.toFixed(2)}, ${i.active ? "active" : "inactive"}) ${i.content}\n  evidence: ${i.evidence}`,
+                        `[${i.id}] (${i.kind}, importance ${i.importance.toFixed(2)}, ${i.active ? "active" : "inactive"}, model ${i.ownerModel || "(orphan)"}) ${i.content}\n  evidence: ${i.evidence}`,
                     )
                     .join("\n"),
           },
@@ -89,10 +108,18 @@ export function registerTools(pi: ExtensionAPI): void {
       deltas: Type.Array(DeltaShape, { minItems: 1, maxItems: 20 }),
     }),
     async execute(_toolCallId, params) {
-      const deltas = params.deltas as Delta[];
-      const applied: AppliedDelta[] = applyDeltas(deltas, (snapshot, ver) => {
-        pi.appendEntry("harness-state", { state: snapshot, version: ver });
-      });
+      const incoming = params.deltas as Delta[];
+      // The active model is the ACTOR: creates bind to it, and update/delete are
+      // scoped to it (per-model isolation). When the active model is unknown (no
+      // turn started) there is no actor — creates become orphans, adopted next
+      // turn, and update/delete are unscoped (graceful fallback).
+      const applied: AppliedDelta[] = applyDeltas(
+        incoming,
+        (snapshot, ver) => {
+          pi.appendEntry("harness-state", { state: snapshot, version: ver });
+        },
+        getActiveModelKey(),
+      );
       const summary = summarize(applied);
       return {
         content: [{ type: "text", text: summary }],

package/src/types.ts

@@ -25,6 +25,14 @@ export interface HarnessItem {
   importance: number;
   /** Whether the item is injected into the system prompt each turn. */
   active: boolean;
+  /**
+   * The model this item is bound to, as "provider/id". Empty string = orphan
+   * (not yet adopted by any model). Model binding is STRICT per-model: an item
+   * is only injected for the exact model it belongs to, so a brand-new model
+   * id starts from a blank harness and never inherits another model's notes.
+   * Orphans are adopted by the active model on first contact (see store.ts).
+   */
+  ownerModel: string;
   createdAt: number;
   updatedAt: number;
 }
@@ -41,6 +49,9 @@ export type Delta =
       content: string;
       evidence: string;
       importance?: number;
+      /** Owner "provider/id". Stamped server-side from the active model when the
+       *  agent omits it; set explicitly by direct-apply proposers. Absent → orphan. */
+      ownerModel?: string;
     }
   | {
       op: "update";
@@ -49,6 +60,8 @@ export type Delta =
       evidence?: string;
       importance?: number;
       active?: boolean;
+      /** Reassign ownership (rare; used by migration/import). Absent → keep current. */
+      ownerModel?: string;
     }
   | { op: "delete"; id: string; reason: string };