pi-continual-harness 0.4.0 → 0.5.0

package/README.md

@@ -16,8 +16,9 @@ with:
 The durable markdown file (`.pi/harness-state.md`) is the composition seam,
 and it is **two-way**: `/refine --commit` and `/harness export` write it;
 `/harness import` parses it back and merges into the live store (offline edits
-win on conflict), so refinements pi-reflect makes flow back online. pi-mem
-ingestion is a future/manual step.
+win on conflict), so refinements pi-reflect makes flow back online. `/harness push-mem`
+pushes active items into pi-mem's semantic store (see
+[Composing with pi-mem](#composing-with-pi-mem)).
 
 ## Why
 
@@ -40,7 +41,7 @@ leaving offline and storage to the packages that already do them well.
 ## Install
 
 ```
-pi install git:github.com/<owner>/pi-continual-harness
+pi install npm:pi-continual-harness
 ```
 
 Or drop `src/index.ts` into `~/.pi/agent/extensions/`.
@@ -63,6 +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)
 ```
 
 `import` reconciles the file into the live store: items whose id matches an
@@ -84,6 +86,24 @@ The model-facing tools:
 Active items are injected into the system prompt each turn as a structured
 block, appended to (never replacing) the base prompt.
 
+## Composing with pi-mem
+
+`/harness push-mem` copies active harness items into
+[pi-mem](https://github.com/georgebashi/pi-mem)'s semantic memory store, so they
+become searchable across sessions. It works by **steering** the agent to call
+pi-mem's `save_memory` tool — there is **no dependency** on pi-mem: it is a
+soft-fail composition. If pi-mem (or any memory tool) is not installed, the
+agent tells you so rather than fabricating one.
+
+```
+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.
+
 ## Configuration
 
 Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults):
@@ -93,7 +113,8 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
   "durableScope": "global",
   "proposer": "steering",
   "remindRefine": { "enabled": false, "everyTurns": 50 },
-  "autoRefine": { "enabled": false, "everyTurns": 100, "commit": false }
+  "autoRefine": { "enabled": false, "everyTurns": 100, "commit": false },
+  "outcomeImportance": { "enabled": false, "bump": 0.03 }
 }
 ```
 
@@ -109,10 +130,19 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
   informational only — it never mutates state.
 - **`autoRefine`** — opt-in autonomous self-improvement (**off by default**).
   When `enabled`, the agent runs `/refine` itself every `everyTurns` turns
-  (default 100). This is the package's one autonomous-self-mutation path: it
-  reuses the exact `/refine` routine (audited `REFINE_ENTRY` tagged
-  `source: "auto"`, branch-local, `/tree` rollback) and notifies before firing.
-  `commit: true` also flushes durable state on each run.
+  (default 100). It is one of the package's opt-in autonomous paths: it reuses
+  the exact `/refine` routine (audited `REFINE_ENTRY` tagged `source: "auto"`,
+  branch-local, `/tree` rollback) and notifies before firing. `commit: true`
+  also flushes durable state on each run.
+- **`outcomeImportance`** — opt-in autonomous **promotion** loop (**off by
+  default**). When `enabled`, a `turn_end` hook bumps (+`bump`, default 0.03)
+  the importance of any active item the agent cited by its `[h_xxxx]` tag in the
+  turn's output. Referenced items gain importance and get their `updatedAt`
+  touched (so they survive time-based decay); ignored items keep decaying. This
+  is the package's second opt-in autonomous path — promotion only, never
+  deletes, persisted/branchable like `harness_mutate`. Autonomous demotion from
+  outcomes is intentionally NOT done (high false-positive); use `/harness drop`,
+  `prune --decay`, or the `dedupe` proposer for that.
 
 ## How it works
 
@@ -180,16 +210,19 @@ Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
 
 ## Status
 
-0.3.x. Implemented:
+0.5.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
+  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, and opt-in `turn_end` auto-refine (the one
-  autonomous-self-mutation path; off by default).
+  opt-in `turn_end` reminder, opt-in `turn_end` auto-refine, and an opt-in
+  `turn_end` outcome-importance loop — the package's two opt-in autonomous
+  paths (both off by default).
 - **Pluggable delta proposers** with a registry: `steering` (default) and
   `dedupe` (rule-based) shipped; `registerProposer()` for custom ones.
 
@@ -197,8 +230,10 @@ Open extension points (see `docs/ROADMAP.md`):
 
 - A dedicated-model proposer (interface ready; the hidden-model-spend tradeoff
   is a separate decision).
-- pi-mem ingestion of the durable export.
-- Outcome-driven importance (currently model-set + manual nudges).
+- Correction-side outcome signals (promotion is shipped; autonomous demotion
+  is high-false-positive, so it is served by `/harness drop`, `prune --decay`,
+  and the `dedupe` proposer — a fuzzy `corrections` proposer is the natural
+  future extension).
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-continual-harness",
-  "version": "0.4.0",
+  "version": "0.5.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

@@ -17,6 +17,8 @@ import { DEFAULT_DURABLE_PATH } from "./store.js";
 
 export const DEFAULT_EVERY_TURNS = 50;
 export const DEFAULT_AUTO_EVERY_TURNS = 100;
+/** Default per-reference importance bump for the opt-in outcome loop. */
+export const DEFAULT_REF_BUMP = 0.03;
 
 export interface HarnessConfig {
   durableScope?: "global" | "project";
@@ -31,6 +33,12 @@ export interface HarnessConfig {
   };
   /** Delta proposer name (see proposer.ts registry). Defaults to "steering". */
   proposer?: string;
+  /** Opt-in turn_end outcome loop: promote importance of items the agent
+   *  references by their [h_xxxx] tag. Off by default (autonomous mutation). */
+  outcomeImportance?: {
+    enabled?: boolean;
+    bump?: number;
+  };
 }
 
 export const DEFAULT_CONFIG: HarnessConfig = {
@@ -38,6 +46,7 @@ export const DEFAULT_CONFIG: HarnessConfig = {
   remindRefine: { enabled: false, everyTurns: DEFAULT_EVERY_TURNS },
   autoRefine: { enabled: false, everyTurns: DEFAULT_AUTO_EVERY_TURNS, commit: false },
   proposer: "steering",
+  outcomeImportance: { enabled: false, bump: DEFAULT_REF_BUMP },
 };
 
 export const CONFIG_PATH = join(homedir(), ".pi", "agent", "harness.json");
@@ -58,6 +67,10 @@ function mergeConfig(over: Partial<HarnessConfig>): HarnessConfig {
       commit: over.autoRefine?.commit ?? false,
     },
     proposer: over.proposer ?? "steering",
+    outcomeImportance: {
+      enabled: over.outcomeImportance?.enabled ?? false,
+      bump: over.outcomeImportance?.bump ?? DEFAULT_REF_BUMP,
+    },
   };
 }
 

package/src/harness.ts

@@ -22,14 +22,15 @@ import {
   reconstructFromDurable,
 } from "./store.js";
 import { loadConfig, resolveDurablePath } from "./config.js";
-import type { ComponentKind } from "./types.js";
+import type { ComponentKind, HarnessItem } from "./types.js";
 
 export function registerHarness(pi: ExtensionAPI): void {
   pi.registerCommand("harness", {
     description:
       "Durable harness-state I/O + importance hygiene. Subcommands: " +
       "import [--prune] [path] · export [path] · status [path] · " +
-      "prune [--decay <days>] · keep <id> · drop <id>.",
+      "prune [--decay <days>] · keep <id> · drop <id> · " +
+      "push-mem [--all|--kind <kind>] (persist active items to pi-mem).",
     handler: async (args, ctx) => {
       const parts = args.trim().split(/\s+/).filter(Boolean);
       const sub = (parts[0] ?? "status").toLowerCase();
@@ -50,6 +51,9 @@ export function registerHarness(pi: ExtensionAPI): void {
         case "drop":
           await handleBump(pi, ctx, rest, -0.1, "drop");
           return;
+        case "push-mem":
+          await handlePushMem(pi, ctx, rest);
+          return;
         case "status":
         default:
           await handleStatus(ctx, rest);
@@ -160,6 +164,61 @@ async function handleBump(
   ctx.ui.notify(`${label}: "${preview}" → importance ${item.importance.toFixed(2)}`, "info");
 }
 
+/** Compose a steering message that asks the agent to persist the given active
+ *  items to long-term memory via a memory tool (pi-mem's save_memory).
+ *  Tool-agnostic: if no memory tool is present the agent says so; we never
+ *  fabricate one. No dependency on pi-mem — soft-fail composition. */
+function buildPushMemPrompt(items: HarnessItem[], scope: string): string {
+  const lines = [
+    `/harness push-mem — persist ${items.length} Continual Harness ${scope} to long-term memory`,
+    "",
+    "For EACH item below, call your memory tool (pi-mem exposes `save_memory`) once, mapping it as shown. This copies harness state into the semantic memory store so it is searchable across sessions.",
+    "",
+    "If you do NOT have a memory tool, do not fabricate one: tell the user to install pi-mem (`pi install npm:pi-mem`) and stop.",
+    "",
+  ];
+  items.forEach((i, n) => {
+    const title = `${i.id} ${i.content.slice(0, 48)}`;
+    const text = `${i.content} (evidence: ${i.evidence})`;
+    lines.push(
+      `${n + 1}. [${i.id}] ${i.content}`,
+      `   evidence: ${i.evidence}`,
+      `   → save_memory({ title: ${JSON.stringify(title)}, text: ${JSON.stringify(text)}, concepts: ["${i.kind}", "continual-harness"] })`,
+      "",
+    );
+  });
+  return lines.join("\n");
+}
+
+async function handlePushMem(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  rest: string[],
+): Promise<void> {
+  const all = rest.includes("--all");
+  const kindIdx = rest.indexOf("--kind");
+  let kind: ComponentKind | undefined;
+  if (kindIdx >= 0 && kindIdx + 1 < rest.length) {
+    const k = rest[kindIdx + 1]!;
+    if (k === "prompt" || k === "memory" || k === "skill" || k === "subagent") kind = k;
+  }
+  // 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")),
+  );
+  if (items.length === 0) {
+    ctx.ui.notify(
+      "No active items to push (default: memory kind; use --all or --kind <kind>).",
+      "warning",
+    );
+    return;
+  }
+  const scope = all ? "item(s)" : `${kind ?? "memory"} item(s)`;
+  const msg = buildPushMemPrompt(items, scope);
+  pi.sendUserMessage(msg);
+  ctx.ui.notify(`Steering agent to persist ${items.length} ${scope} to pi-mem.`, "info");
+}
+
 async function handleStatus(ctx: ExtensionCommandContext, rest: string[]): Promise<void> {
   const path = await resolvePath(rest, ctx);
   const items = getState().items;

package/src/index.ts

@@ -13,6 +13,7 @@ import { registerRefine } from "./refine.js";
 import { registerTools } from "./tools.js";
 import { registerReminder } from "./remind.js";
 import { registerAutoRefine } from "./auto-refine.js";
+import { registerOutcome } from "./outcome.js";
 import { getState, reconstruct, STATE_ENTRY } from "./store.js";
 
 export default function continualHarness(pi: ExtensionAPI): void {
@@ -32,6 +33,10 @@ export default function continualHarness(pi: ExtensionAPI): void {
   registerRefine(pi);
   registerHarness(pi);
   registerReminder(pi);
+  // Register outcome BEFORE auto-refine: the test fake overwrites turn_end on
+  // each registration (Map.set), and the auto-refine integration tests assume
+  // auto-refine is the surviving handler. In production pi, all three run.
+  registerOutcome(pi);
   registerAutoRefine(pi);
 }
 

package/src/outcome.ts

@@ -0,0 +1,104 @@
+// turn_end outcome loop (Phase 5 / limit B-phase-2). The package's SECOND
+// autonomous-mutation path (after auto-refine), so — like auto-refine — it is
+// locked behind an explicit opt-in:
+//
+//   ~/.pi/agent/harness.json
+//   { "outcomeImportance": { "enabled": true, "bump": 0.03 } }
+//
+// What it does: when the agent's own output cites an injected item by its
+// [h_xxxx] tag, that is unambiguous POSITIVE evidence the item was useful, so
+// we nudge its importance up (+bump). This closes the outcome half of the
+// fitness loop that manual /harness keep|drop (B-phase-1) and /harness prune
+// --decay (A) started: useful items gain importance AND get their updatedAt
+// touched (so they survive time-based decay); ignored items keep decaying.
+//
+// Hard scope cut — CORRECTION/demotion from outcomes is genuinely fuzzy and
+// high-false-positive, so it is intentionally NOT autonomized here. Demotion is
+// served by the existing audited, reviewable primitives: /harness drop,
+// /harness prune --decay, and the dedupe proposer. (See ROADMAP.md.)
+//
+// Safety properties (promotion only, never deletes): clamped to [0,1]; persisted
+// via the same harness-state entries as harness_mutate (branch-local, /tree
+// rollback); visible (notify per turn). Pure reference extraction is factored
+// into findReferences() so it is unit-testable without a live pi runtime.
+
+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";
+
+// Minimal entry shape; kept loose to avoid coupling to pi's internal types.
+type AnyEntry = {
+  type?: string;
+  message?: {
+    role?: string;
+    content?: Array<{ type?: string; text?: string }>;
+  };
+};
+
+// Matches [h_xxxx] citation tags (the same form inject.ts emits).
+const REF_RE = /\[(h_[a-z0-9_]+)\]/gi;
+
+/**
+ * Extract distinct harness-item ids the agent cited by their [h_xxxx] tag,
+ * keeping only those that are currently known (active or not). Pure.
+ */
+export function findReferences(text: string, knownIds: Set<string>): string[] {
+  const found = new Set<string>();
+  for (const m of text.matchAll(REF_RE)) {
+    const id = m[1]!.toLowerCase();
+    if (knownIds.has(id)) found.add(id);
+  }
+  return [...found];
+}
+
+// Number of assistant message-entries already consumed. -1 = unseen; the first
+// observed turn_end seeds the cursor (so enabling mid-session never bumps
+// retroactively for the whole history).
+let scannedMessages = -1;
+
+/** Test hook: reset internal cursor. */
+export function resetOutcome(): void {
+  scannedMessages = -1;
+}
+
+/** Subscribe to turn_end and promote importance of referenced items (opt-in). */
+export function registerOutcome(pi: ExtensionAPI): void {
+  pi.on("turn_end", async (_event, ctx) => {
+    const config = await loadConfig();
+    if (!config.outcomeImportance?.enabled) return;
+    const bump = config.outcomeImportance.bump ?? DEFAULT_REF_BUMP;
+    if (bump <= 0) return;
+
+    const entries = ctx.sessionManager.getBranch() as AnyEntry[];
+    const asst = entries.filter((e) => e.type === "message" && e.message?.role === "assistant");
+    if (scannedMessages < 0) {
+      scannedMessages = asst.length; // seed: no retroactive bump
+      return;
+    }
+    const fresh = asst.slice(scannedMessages);
+    scannedMessages = asst.length;
+
+    const text = fresh
+      .map((e) => (e.message?.content ?? []).map((c) => c.text ?? "").join(" "))
+      .join("\n");
+    if (!text.trim()) return;
+
+    const activeIds = new Set(getState().items.filter((i) => i.active).map((i) => i.id));
+    const refs = findReferences(text, activeIds);
+    if (refs.length === 0) return;
+
+    let bumped = 0;
+    for (const id of refs) {
+      const item = bumpImportance(id, bump, (snapshot, ver) => {
+        pi.appendEntry("harness-state", { state: snapshot, version: ver });
+      });
+      if (item) bumped += 1;
+    }
+    if (bumped > 0) {
+      ctx.ui.notify(
+        `Outcome: +${bump} importance for ${bumped} referenced item(s): ${refs.join(", ")}`,
+        "info",
+      );
+    }
+  });
+}