pi-continual-harness 0.6.2 → 0.7.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
 
@@ -154,13 +158,52 @@ 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.
+
 ## Proposers
 
 `/refine` is split into two stages: **propose** (given evidence + state, decide
@@ -186,7 +229,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 +263,14 @@ Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
 
 ## Status
 
-0.5.x. Implemented:
+0.7.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 +278,10 @@ 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.
 
 Open extension points (see `docs/ROADMAP.md`):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-continual-harness",
-  "version": "0.6.2",
+  "version": "0.7.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/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) {

package/src/inject.ts

@@ -1,9 +1,16 @@
 // 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.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { getState } from "./store.js";
+import { adoptOrphans, getState, modelKey, setActiveModelKey } from "./store.js";
 import type { ComponentKind } from "./types.js";
 
 const ORDER: ComponentKind[] = ["prompt", "memory", "skill", "subagent"];
@@ -15,13 +22,19 @@ const TITLES: Record<ComponentKind, string> = {
   subagent: "Reusable sub-agent specs",
 };
 
-export function renderHarnessBlock(): string {
+/**
+ * Render the harness block for a single model. Only active items whose
+ * ownerModel === ownerKey are included. An undefined ownerKey (no active model)
+ * renders nothing — isolation is strict: unknown model → inject nothing.
+ */
+export function renderHarnessBlock(ownerKey?: string): string {
+  if (ownerKey === undefined) return "";
   const state = getState();
   if (state.items.length === 0) return "";
 
   const sections: string[] = [];
   for (const kind of ORDER) {
-    const items = state.items.filter((i) => i.kind === kind && i.active);
+    const items = state.items.filter((i) => i.kind === kind && i.active && i.ownerModel === ownerKey);
     if (items.length === 0) continue;
     const bullets = items
       .map((i) => `- [${i.id}] ${i.content}`)
@@ -41,8 +54,18 @@ export function renderHarnessBlock(): string {
 }
 
 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 });
+      });
+    }
+    const block = renderHarnessBlock(key);
     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/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 };