@xingular/harness 2.1.2 → 3.0.0

package/dist/terminal-pi.js

@@ -18,7 +18,7 @@ function connectionFromEnv(env = process.env) {
   if (!socket || !token) throw new SocketError("not_configured", `This command only works inside a terminal session the harness started (${SOCKET_ENV} and ${TOKEN_ENV} are not set).`);
   return { socket, token };
 }
-function request(connection, body2, what, timeoutMs) {
+function request(connection, body, what, timeoutMs) {
   return new Promise((resolve, reject) => {
     const stream = createConnection(connection.socket);
     let buffer = "";
@@ -34,7 +34,7 @@ function request(connection, body2, what, timeoutMs) {
       stream.destroy();
       finish(() => reject(new SocketError("timeout", `The harness did not answer ${what}.`)));
     }, timeoutMs);
-    stream.on("connect", () => stream.write(`${JSON.stringify({ token: connection.token, ...body2 })}
+    stream.on("connect", () => stream.write(`${JSON.stringify({ token: connection.token, ...body })}
 `));
     stream.on("data", (chunk) => {
       buffer += chunk.toString("utf8");
@@ -278,16 +278,16 @@ async function followLogin(ui, call, accountId, loginId) {
   const deadline = Date.now() + LOGIN_TIMEOUT_MS;
   let shownRevision = -1;
   for (; ; ) {
-    const snapshot2 = await call("accounts.loginStatus", { accountId });
-    if (!snapshot2 || snapshot2.loginId !== loginId) return;
-    if (snapshot2.status !== "running") return reportLogin(ui, snapshot2);
-    if (snapshot2.prompt) {
-      await answerPrompt(ui, call, loginId, snapshot2.prompt);
+    const snapshot = await call("accounts.loginStatus", { accountId });
+    if (!snapshot || snapshot.loginId !== loginId) return;
+    if (snapshot.status !== "running") return reportLogin(ui, snapshot);
+    if (snapshot.prompt) {
+      await answerPrompt(ui, call, loginId, snapshot.prompt);
       continue;
     }
-    const step = [...snapshot2.events].reverse().map(loginStep).find((text3) => text3 !== null);
-    if (step && snapshot2.revision !== shownRevision) {
-      shownRevision = snapshot2.revision;
+    const step = [...snapshot.events].reverse().map(loginStep).find((text3) => text3 !== null);
+    if (step && snapshot.revision !== shownRevision) {
+      shownRevision = snapshot.revision;
       const choice = await ui.select(`${step}
 
 Finish in your browser, then choose Check status.`, [CHECK_STATUS, CANCEL_SIGN_IN]);
@@ -306,10 +306,10 @@ Finish in your browser, then choose Check status.`, [CHECK_STATUS, CANCEL_SIGN_I
     await new Promise((resolve) => setTimeout(resolve, POLL_MS));
   }
 }
-function reportLogin(ui, snapshot2) {
-  if (snapshot2.status === "completed") ui.notify("Signed in.", "info");
-  else if (snapshot2.status === "cancelled") ui.notify("Sign-in was cancelled.", "warning");
-  else ui.notify(snapshot2.error ?? "Sign-in failed.", "error");
+function reportLogin(ui, snapshot) {
+  if (snapshot.status === "completed") ui.notify("Signed in.", "info");
+  else if (snapshot.status === "cancelled") ui.notify("Sign-in was cancelled.", "warning");
+  else ui.notify(snapshot.error ?? "Sign-in failed.", "error");
 }
 async function answerPrompt(ui, call, loginId, prompt) {
   const promptId = String(prompt.promptId ?? "");
@@ -764,7 +764,9 @@ var runRecordSchema = z.object({
   handoffId: text,
   accountId: text,
   agentId: text,
-  trigger: text
+  trigger: text,
+  harnessScope: text.optional(),
+  harnessVersion: text.optional()
 });
 
 // src/core/index.ts
@@ -851,18 +853,11 @@ function askUserTool(run2) {
 // src/core/frontmatter.ts
 import { parse as parseYaml, stringify } from "yaml";
 
-// src/memory/store.ts
-import { stringify as stringify2 } from "yaml";
-
-// src/skills/registry.ts
-var MAX_SKILL_IMPORT_BYTES = 10 * 1024 * 1024;
-
 // src/prompt/compile.ts
-var SECTION_ORDER = { blocks: 30, rules: 40, references: 50, skills: 60, knowledge: 80, tools: 90 };
+var SECTION_ORDER = { system: 25, guardrails: 40, memory: 45, references: 50, subagents: 64, scripts: 66, wiki: 80, tools: 90 };
 var BUILT_IN_DYNAMIC = [
-  { id: "blocks", order: SECTION_ORDER.blocks },
   { id: "references", order: SECTION_ORDER.references },
-  { id: "knowledge", order: SECTION_ORDER.knowledge }
+  { id: "wiki", order: SECTION_ORDER.wiki }
 ];
 
 // src/sessions/planMode.ts

package/docs/terminal-tui.md

@@ -1,6 +1,6 @@
 # Harness terminal frontend
 
-Status: implemented in the 2.1.2 release candidate; publication follows the tagged CI workflow. Last updated: 2026-10-19.
+Status: published as `@xingular/harness` 2.1.2. Last updated: 2026-10-19.
 Decision: [ADR-0001](decisions/ADR-0001-owned-terminal.md).
 
 ## Native subagents (2026-10-18)
@@ -148,11 +148,17 @@ Full upstream copyright and MIT permission notices are in [NOTICE.md](../NOTICE.
 ## Runtime compatibility adapter
 
 Most integration uses public Pi exports. [`piAdapter.ts`](../src/terminal/tui/piAdapter.ts)
-contains the remaining implementation dependencies and requires exactly Pi **1.2.0** before
-loading them:
+contains the remaining presentation dependencies and requires exactly Pi **1.2.0** before
+loading them. The shared [`runtime.ts`](../src/pi/runtime.ts) loader imports Pi first, then invokes
+the same HTTP dispatcher hook as Pi's CLI before any Harness Pi runtime is used. This reapplies
+the process `HTTP_PROXY`, `HTTPS_PROXY` and `NO_PROXY` settings after Pi's bundled Undici has
+loaded. Account and model checks, sessions, maintenance, plugin discovery and installation,
+pricing, and the standalone terminal all use this loader. It is process-wide and coalesces
+concurrent initialization.
 
 | Internal dependency | Reason |
 |---|---|
+| `dist/bundle/chunks/chunk-TJXZSVTD.js:configureHttpDispatcher` | Restore Pi's environment-aware HTTP proxy dispatcher after the SDK import |
 | `dist/extensions/index.js` builtin inventory | Preserve selected `llama.cpp`, `codemode`, `tool-search` and MCP builtins with the CLI's replacement semantics |
 | `dist/modes/interactive/theme/theme.js:setThemeInstance` | Keep public native rich components on the same active theme as the Harness screen |
 | `dist/core/tools/renderers/index.js:withBuiltInRenderers` | Preserve existing read/edit/bash/write formatting without replacing tool execution |
@@ -160,7 +166,20 @@ loading them:
 
 The adapter is initialized once; its global theme setter and renderer lookup are synchronous
 thereafter. A Pi dependency upgrade must update this adapter deliberately and rerun the
-terminal compatibility tests. These module imports do not instantiate `InteractiveMode`.
+terminal compatibility tests. The dispatcher compatibility check also pins the private Pi bundle
+chunk and fails with a clear error if that hook moves or disappears. A local proxy fixture test
+checks that a Pi HTTP request reaches the configured proxy without contacting an external host.
+These module imports do not instantiate `InteractiveMode`.
+
+## Clipboard image paste
+
+The standalone terminal reads Finder-copied file paths before checking clipboard image pixels.
+On macOS, `.heic` and `.heif` files are converted with `/usr/bin/sips` to private temporary PNGs,
+preserving the copied path order and leaving the originals untouched. The temporary files are
+removed when the terminal shuts down. A failed or invalid conversion reports an error and leaves
+the composer unchanged. Clipboard image pixels continue through Pi's native adapter, which reads
+PNG/TIFF on macOS and normalizes TIFF to PNG. This path is terminal-emulator independent; direct
+Warp clipboard acceptance still requires a manual check in Warp.
 
 ## Accounts, history and resource trust
 
@@ -324,9 +343,10 @@ a successful response or tool execution. Harness persisted the failed run and re
 terminal; the source sign-in file was unchanged and the disposable credentials were deleted.
 The [live report and capture](evidence/terminal-2026-10-17-followup/live-codex/README.md) retain
 this quota failure explicitly. Successful live streaming/tool acceptance remains open until
-account capacity is available. GitHub gist publication, actual OS clipboard/image transfer,
-Windows behavior and every terminal emulator remain unverified. Rich image/diff rendering and clipboard adapters have
-focused compatibility tests; that does not establish OS interaction. These changes shipped in
+account capacity is available. GitHub gist publication, actual OS clipboard pixel transfer,
+Windows behavior and every terminal emulator remain unverified. HEIC/HEIF file staging has focused
+conversion tests; that does not establish Finder or Warp OS interaction. Rich image/diff rendering
+and clipboard adapters have focused compatibility tests; that does not establish OS interaction. These changes shipped in
 `@xingular/harness` 2.0.0 (commit `44471bc`), while the complete plan's acceptance remains
 open pending the required integration and provider evidence.
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@xingular/harness",
-  "version": "2.1.2",
+  "version": "3.0.0",
   "type": "module",
-  "description": "Xingular Harness — a Pi agent harness with multi-account sign-in, a compiled system prompt, a memory lifecycle (Wiki), tools, MCP, and skills",
+  "description": "Xingular Harness — a Pi agent harness built on recursive harnessing (Harness²): versioned eight-component harness trees, refinement from evidence, multi-account sessions, a compiled prompt, project notes, tools, and MCP",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tanntnny/xingular-harness.git"

package/src/accounts/accounts.ts

@@ -10,6 +10,7 @@ import type { ModelRuntime } from '@earendil-works/pi-coding-agent'
 import { log, type Bus } from '../core/bus'
 import { HarnessError, invalid } from '../core/errors'
 import { atomicWrite, now, readJson, safeId } from '../core/fs'
+import { loadPi } from '../pi/runtime'
 import type { RunEvent, RunRecord } from '../sessions/contracts'
 import * as env from './env'
 import { secretKey, type SecretStore } from './secrets'
@@ -222,7 +223,7 @@ export class Accounts {
   }
 
   private async loadInstallationDeviceId(): Promise<string> {
-    const { SettingsManager } = await import('@earendil-works/pi-coding-agent')
+    const { SettingsManager } = await loadPi()
     const settings = SettingsManager.create(process.cwd(), env.ensureSharedDir(this.dir))
     const deviceId = settings.getOrCreateDeviceId()
     await settings.flush()
@@ -237,7 +238,7 @@ export class Accounts {
     let runtime = this.runtimes.get(id)
     if (!runtime) {
       const configDir = 'configDir' in account ? account.configDir : env.ensureHome(this.dir, account)
-      runtime = import('@earendil-works/pi-coding-agent')
+      runtime = loadPi()
         .then(({ ModelRuntime }) => ModelRuntime.create({ credentials: this.credentialStore(id) as never, modelsPath: join(configDir, 'models.json') }))
         .catch((error: unknown) => {
           this.runtimes.delete(id)
@@ -275,7 +276,7 @@ export class Accounts {
 
   /** Providers Pi can sign in to (OAuth) or take a key for, independent of any account. */
   async providers(): Promise<{ id: string; name: string; oauth: boolean; oauthLabel: string | null; subscription: boolean; apiKey: boolean }[]> {
-    const { ModelRuntime } = await import('@earendil-works/pi-coding-agent')
+    const { ModelRuntime } = await loadPi()
     const none = { read: async () => undefined, list: async () => [], modify: async () => undefined, delete: async () => undefined }
     const runtime = await ModelRuntime.create({ credentials: none, modelsPath: null, refreshOnCreate: false })
     return runtime

package/src/capabilities/api.ts

@@ -2,7 +2,7 @@
 // stores remain the source of truth; this module gives hosts one capability-shaped contract.
 import { invalid } from '../core/errors'
 import type { Harness } from '../harness'
-import type { CallerContext } from '../memory/caller'
+import type { CallerContext } from '../core/caller'
 import type { Launch } from '../prompt/compile'
 import * as pluginApi from '../plugins/api'
 import type { Plugin } from '../plugins/types'

package/src/cli.ts

@@ -4,7 +4,8 @@
 //   xingular-harness serve --state <dir> [--data <dir>] [--name <product>] [--builtins <dir>]…
 //                          [--host-secrets] [--host-policy] [--host-tools] [--host-directory]
 //       Serves the harness to a host process over stdin/stdout (newline-delimited JSON).
-//   xingular-harness wiki <command>     Memory and Wiki, from inside a terminal session.
+//   xingular-harness wiki <command>     Project notes, skills and history, from inside a terminal session.
+//   xingular-harness refine <command>   Refine a harness tree from evidence (refine demo needs no model).
 //   xingular-harness mcp <command>      Connected apps, from inside a terminal session.
 //   xingular-harness plugins <command>  List, install, switch and trust plugins.
 import { resolve } from 'node:path'
@@ -13,6 +14,7 @@ import { log } from './core/bus'
 import { createHarness, type HarnessOptions } from './harness'
 import { runPluginsCli, terminalAsk } from './plugins/cli'
 import { runHubCli } from './hub/cli'
+import { runRefineCli } from './refine/cli'
 import { remoteDirectory, remotePolicy, remoteSecrets, remoteTools } from './server/remote'
 import { RpcPeer, stdioTransport } from './server/rpc'
 import { attach } from './server/serve'
@@ -20,17 +22,18 @@ import { runAppsCli, runWikiCli } from './terminal/cli'
 import { runStandaloneTerminal, standaloneArguments } from './terminal/standalone'
 
 const USAGE = `Usage: xingular-harness [--data <dir>] [--state <dir>]
-       xingular-harness <terminal | serve | wiki | mcp | plugins | hub> [arguments]
+       xingular-harness <terminal | serve | wiki | mcp | plugins | hub | refine> [arguments]
 
   (no command)       Start the interactive Harness terminal
   terminal           Start the interactive Harness terminal
   serve --state <dir> [--data <dir>] [--name <product>] [--builtins <dir>]
         [--host-secrets] [--host-policy] [--host-tools] [--host-directory]
                      Serve the harness over newline-delimited JSON
-  wiki <command>     Memory and Wiki commands for a terminal session
+  wiki <command>     Wiki, skill and history commands for a terminal session
   mcp <command>      Connected-app commands for a terminal session
   plugins <command>  List, install, switch and trust plugins (plugins help)
   hub <command>      Browse and install curated items (hub help)
+  refine <command>   Refine a harness from evidence (refine demo, refine run)
 
 Standalone terminal options:
   --data <dir>       Data directory (default: ~/.xingular-harness/data)
@@ -105,6 +108,7 @@ async function main(): Promise<number> {
   if (command === 'mcp') return runAppsCli(rest)
   if (command === 'plugins') return runPluginsCli(rest, { ask: terminalAsk() })
   if (command === 'hub') return runHubCli(rest)
+  if (command === 'refine') return runRefineCli(rest)
   process.stdout.write(USAGE)
   return command ? 2 : 0
 }

package/src/core/caller.ts

@@ -0,0 +1,34 @@
+// Who a session works as. The embedding application supplies this when a session starts; the
+// harness never looks an agent up by itself. The ids are opaque to the harness.
+import { findProject, type Project } from './projects'
+
+export interface CallerContext {
+  /** Opaque, host-owned policy data frozen when this session starts. The harness only forwards it to the embedding app's tool policy. */
+  policyContext?: unknown
+  runId?: string | null
+  sessionId?: string | null
+  projectId?: string | null
+  /** The caller: decides which plugins and connectors reach it, and whose history it recalls. */
+  agentId?: string | null
+  /** Callers whose conversations this one may not recall (opaque ids from the embedding host). */
+  recallExcludeAgents?: string[] | null
+  /** The caller's name, recorded on what it writes. */
+  agentName?: string | null
+  /** `Chat` for an agent's own conversation, `Code` for a session in a project. */
+  actor?: string | null
+  /** `cli` when the caller reaches the harness through a terminal command. */
+  surface?: string | null
+}
+
+export const isSession = (context: CallerContext): boolean => context.actor === 'Code'
+export const actorOf = (context: CallerContext): string => (isSession(context) ? 'Code' : 'Chat')
+export const usesCli = (context: CallerContext): boolean => context.surface === 'cli'
+
+export function projectOf(root: string, context: CallerContext): Project | null {
+  if (!context.projectId) return null
+  try {
+    return findProject(root, context.projectId)
+  } catch {
+    return null
+  }
+}

package/src/core/fs.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto'
-import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs'
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeSync } from 'node:fs'
 import { basename, dirname, isAbsolute, join, normalize, sep } from 'node:path'
 
 import { HarnessError, invalid } from './errors'
@@ -90,3 +90,19 @@ export function now(): string {
 export function newId(): string {
   return randomUUID()
 }
+
+export function isDir(path: string): boolean {
+  try {
+    return statSync(path).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export function isFile(path: string): boolean {
+  try {
+    return statSync(path).isFile()
+  } catch {
+    return false
+  }
+}

package/src/harness.ts

@@ -1,6 +1,7 @@
-// The harness, assembled: Pi sessions on isolated accounts, a compiled prompt, a memory
-// lifecycle, tools, connected apps, and skills. An application embeds one of these and adds
-// its own prompt sections, tools, and policy; nothing here knows what that application is.
+// The harness, assembled: Pi sessions on isolated accounts, versioned harness trees that shape
+// them, refinement that improves those trees from evidence, a compiled prompt, project notes,
+// tools, and connected apps. An application embeds one of these and adds its own prompt
+// sections, tools, and policy; nothing here knows what that application is.
 import { Subagents } from './sessions/subagentService'
 import { mkdirSync } from 'node:fs'
 import { join } from 'node:path'
@@ -15,18 +16,15 @@ import { DEFAULT_PRODUCT_NAME, EMPTY_DIRECTORY, type Directory, type HarnessEnv
 import { HarnessError } from './core/errors'
 import { readJsonOr } from './core/fs'
 import { closeIndex } from './core/index'
-import { projectsOrNone } from './core/projects'
 import { ConnectedApps } from './mcp/service'
 import type { AppOAuthClients } from './mcp/types'
 import { migrateConnectionScopes } from './mcp/scopeMigration'
-import type { MaintainerFactory } from './memory/maintainer'
-import { Maintenance } from './memory/maintenance'
-import * as migrate from './memory/migrate'
-import { writeIndex } from './memory/proposals'
-import * as recall from './memory/recall'
-import * as store from './memory/store'
-import { countPages } from './memory/wiki'
-import * as wikiIndex from './memory/wikiIndex'
+import * as recall from './history/recall'
+import type { RefineHost } from './refine/host'
+import { Refinements } from './refine/service'
+import { configureBuiltins } from './tree/components'
+import { TreeTrust } from './tree/trust'
+import * as notes from './wiki/notes'
 import * as pluginApi from './plugins/api'
 import * as attachments from './plugins/attachments'
 import { HARNESS_PLUGINS } from './plugins/builtin'
@@ -40,7 +38,6 @@ import { RunRegistry } from './sessions/registry'
 import { markInterruptedRuns } from './sessions/runStore'
 import type { SessionFactory } from './sessions/runner'
 import { Sessions } from './sessions/sessions'
-import * as registry from './skills/registry'
 import { Terminals, type TerminalAssets } from './terminal/terminals'
 
 export interface HarnessOptions {
@@ -57,19 +54,13 @@ export interface HarnessOptions {
   policy?: ToolPolicy
   /** Replaces Pi, for tests. */
   sessionFactory?: SessionFactory
-  maintainerFactory?: MaintainerFactory
-  /** Delegate maintenance execution to the embedding host through durable requests. */
-  externalMaintenance?: boolean
-  maintenanceExcludedTriggers?: string[]
-  /** Queue consolidation after every settled run (the default). False leaves memory to explicit proposals and scheduled merges. */
-  maintenanceRunTrigger?: boolean
-  /** How long the maintenance queue stays empty before full memory blocks are condensed. */
-  idleMs?: number
+  /** Where refinement executions work and with what; without it, a temporary copy of the task's source and Pi's own tools. */
+  refineHost?: RefineHost
   /** Where the built commands a terminal session runs are, when they are not beside this package. */
   assets?: TerminalAssets
   /** Optional legacy executable override. The default is the Harness-owned terminal frontend. */
   piProgram?: () => string | null
-  /** Folders of built-in skills, prompts, and rules, each laid out like `registry/`. */
+  /** Folders of built-in skills, prompts, and rules for the component library, each laid out like `registry/`. */
   builtins?: string[]
   /**
    * The application's own parts, described as plugins: which tools, prompt sections and tool
@@ -90,7 +81,10 @@ export interface HarnessOptions {
 /** What starting on a data root found and repaired. */
 export interface Recovery {
   interruptedRuns: number
+  /** Notes in the Wiki. */
   reindexedPages: number
+  /** Where an earlier Wiki's memory, facts and revisions were moved, when they were. */
+  legacyWiki?: string | null
   /** Set when the storage migration failed; the old data is left as it was. */
   migrationError: string | null
 }
@@ -133,7 +127,11 @@ export class Harness {
   applicationPlugins: ReadonlySet<string> = new Set()
   readonly subagents: Subagents
   readonly sessions: Sessions
-  readonly maintenance: Maintenance
+  /** Which plugin code in harness trees a person trusted. */
+  readonly trust: TreeTrust
+  /** Refinement: improving a harness tree from evidence of how it ran. */
+  readonly refine: Refinements
+  refineHost: RefineHost | null
   readonly terminals: Terminals
   /** Resolves when what was loaded in the background at construction is in place. */
   readonly ready: Promise<void>
@@ -147,7 +145,9 @@ export class Harness {
     this.env = new Env(options.dataRoot || null, options.directory ?? EMPTY_DIRECTORY, options.productName ?? DEFAULT_PRODUCT_NAME, this.bus)
     this.hub = new Hub(this, options.hub)
     this.policy = options.policy ?? {}
-    registry.configureBuiltins(options.builtins ?? [])
+    configureBuiltins(options.builtins ?? [])
+    this.trust = new TreeTrust(this.stateDir)
+    this.refineHost = options.refineHost ?? null
     const secrets = options.secrets ?? fileSecretStore(join(this.stateDir, 'secrets.json'))
     this.accounts = new Accounts({ dir: join(this.stateDir, 'accounts'), secrets, bus: this.bus })
     this.approvals = new Approvals(this.stateDir, this.bus)
@@ -200,10 +200,11 @@ export class Harness {
       broker: this.apps,
       plugins: this.plugins,
       resolveCapabilities: (caller, tools, cwd) => capabilities.resolve(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, cwd, tools }),
-      factory: options.sessionFactory
+      factory: options.sessionFactory,
+      trust: this.trust
     })
-    this.maintenance = new Maintenance({ env: this.env, bus: this.bus, accounts: this.accounts, factory: options.maintainerFactory, idleMs: options.idleMs, external: options.externalMaintenance, excludedTriggers: options.maintenanceExcludedTriggers, runTrigger: options.maintenanceRunTrigger })
-    this.terminals = new Terminals({ subagents: this.subagents, resolveCapabilities: (caller, tools, cwd) => capabilities.resolve(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, cwd, tools }), env: this.env, stateDir: this.stateDir, accounts: this.accounts, runs: this.runs, approvals: this.approvals, apps: this.apps, policy: this.policy, bus: this.bus, plugins: this.plugins, pluginControl: { list: (scope) => pluginApi.list(this, scope), attach: (params, on) => pluginApi.attach(this, params, on), trust: (scope) => pluginApi.trust(this, scope), untrust: (scope) => pluginApi.untrust(this, scope) }, assets: options.assets, program: options.piProgram, hub: this.hub })
+    this.refine = new Refinements({ root: () => this.env.root, bus: this.bus, trust: this.trust, host: () => this.refineHost, runtime: { root: () => this.env.root, runs: this.runs, run: (input) => this.sessions.run(input) } })
+    this.terminals = new Terminals({ trust: this.trust, subagents: this.subagents, resolveCapabilities: (caller, tools, cwd) => capabilities.resolve(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, cwd, tools }), env: this.env, stateDir: this.stateDir, accounts: this.accounts, runs: this.runs, approvals: this.approvals, apps: this.apps, policy: this.policy, bus: this.bus, plugins: this.plugins, pluginControl: { list: (scope) => pluginApi.list(this, scope), attach: (params, on) => pluginApi.attach(this, params, on), trust: (scope) => pluginApi.trust(this, scope), untrust: (scope) => pluginApi.untrust(this, scope) }, assets: options.assets, program: options.piProgram, hub: this.hub })
     this.ready = this.apps.start().catch((error) => log('connected apps', error instanceof Error ? error.message : String(error)))
     this.runs.listen((event, run) => {
       this.accounts.onRunEvent(event, run)
@@ -212,8 +213,6 @@ export class Harness {
       if ((event.type === 'completed' || event.type === 'failed') && run) {
         this.hooks.emit({ type: 'history.run.ended', runId: run.id, sessionId: run.sessionId, status: run.status, goal: run.goal ?? null, agentId: run.agentId ?? null, projectId: run.projectId ?? null, startedAt: run.startedAt, endedAt: run.endedAt ?? null, at: event.timestamp })
       }
-      if (event.type === 'completed' || event.type === 'failed' || (event.type === 'status.changed' && (event.payload as { status?: string }).status === 'interrupted')) this.maintenance.finishRun(event.runId, event.type !== 'completed')
-      this.maintenance.onRunEvent(event)
     })
   }
 
@@ -230,27 +229,28 @@ export class Harness {
   }
 
   /**
-   * Opens a data root: brings its Wiki to the current layout, settles runs that never ended,
-   * and refreshes the index. `agentIds` are the agents that get their own memory blocks when an
-   * older Wiki is migrated.
+   * Opens a data root: moves an earlier Wiki's memory and facts aside (once), lays out the Wiki,
+   * settles runs that never ended, and refreshes the history index. `agentIds` is accepted for
+   * hosts written against earlier versions and is not used.
    */
-  open(dataRoot: string, agentIds: readonly string[] = []): Recovery {
+  open(dataRoot: string, _agentIds: readonly string[] = []): Recovery {
     if (this.hub.busy && this.env.dataRoot !== dataRoot) throw new HarnessError('hub_busy', 'Wait for the hub installation before changing the data location.')
     if (this.env.dataRoot && this.env.dataRoot !== dataRoot) closeIndex(this.env.dataRoot)
     this.env.dataRoot = dataRoot
     this.hub.watch(dataRoot)
     const root = dataRoot
-    this.hooks.watch(store.wikiDir(root))
+    this.hooks.watch(notes.wikiDir(root))
     void this.hooks.reload()
-    for (const folder of ['registry/skills', 'registry/prompts', 'registry/rules', 'config', 'runs']) mkdirSync(join(root, folder), { recursive: true })
+    for (const folder of ['registry/skills', 'registry/prompts', 'registry/rules', 'config', 'runs', 'harnesses']) mkdirSync(join(root, folder), { recursive: true })
     let migrationError: string | null = null
-    let wikiMigrationError: string | null = null
+    let legacyWiki: string | null = null
     try {
-      if (migrate.run(this.env, agentIds)) log(`started Wiki storage version ${migrate.WIKI_VERSION}; the earlier Wiki is kept as a backup in the data root`)
+      legacyWiki = notes.moveLegacy(root)
+      if (legacyWiki) log(`moved the earlier Wiki's memory, facts and revisions to ${legacyWiki}`)
+      notes.ensureLayout(root, this.env.productName)
     } catch (error) {
       migrationError = error instanceof Error ? error.message : String(error)
-      wikiMigrationError = migrationError
-      log('Wiki migration failed', migrationError)
+      log('Wiki layout', migrationError)
     }
     try {
       migrateConnectionScopes(root, this.stateDir)
@@ -259,55 +259,36 @@ export class Harness {
       migrationError = migrationError ? `${migrationError}; connector scope migration: ${detail}` : detail
       log('connector scope migration failed', detail)
     }
-    if (!wikiMigrationError) {
-      try {
-        store.ensureLayout(root, this.env.productName)
-        // Every project has its fixed pages, and the generated indexes match the files.
-        for (const project of projectsOrNone(root)) store.ensureProjectNamespace(root, project.slug, project.name)
-        writeIndex(store.wikiDir(root))
-      } catch (error) {
-        log('Wiki layout', error instanceof Error ? error.message : String(error))
-      }
-    }
     let interruptedRuns = 0
     try {
       interruptedRuns = markInterruptedRuns(root, `${this.env.productName} stopped before the run settled.`)
     } catch (error) {
       log('run recovery', error instanceof Error ? error.message : String(error))
     }
-    let reindexedPages: number
-    try {
-      reindexedPages = wikiIndex.ensure(root)
-    } catch (error) {
-      log('index', error instanceof Error ? error.message : String(error))
-      reindexedPages = countPages(root)
-    }
     try {
-      // Runs recorded while nothing was running, or before recall existed, become searchable.
+      // Runs recorded while nothing was running become searchable.
       recall.sync(root)
     } catch (error) {
       log('recall', error instanceof Error ? error.message : String(error))
     }
-    this.recovery = { interruptedRuns, reindexedPages, migrationError }
-    this.maintenance.start()
+    this.recovery = { interruptedRuns, reindexedPages: safeCount(root), migrationError, legacyWiki }
     return this.recovery
   }
 
-  /** Deletes the index and rebuilds it from the files. Returns the pages indexed. */
+  /** Rebuilds the history index from the run records. Returns the notes in the Wiki. */
   rebuildIndex(): number {
-    const pages = wikiIndex.rebuild(this.env.root)
     recall.sync(this.env.root)
-    this.recovery = { ...this.recovery, reindexedPages: pages }
-    return pages
+    const count = safeCount(this.env.root)
+    this.recovery = { ...this.recovery, reindexedPages: count }
+    return count
   }
 
-  /** Stops live runs and releases the index. */
+  /** Stops live runs and refinements and releases the index. */
   async close(): Promise<void> {
     this.hub.close()
-    this.maintenance.stop()
+    await this.refine.close()
     await this.terminals.close()
     await this.runs.interruptAll()
-    await this.maintenance.settled()
     await this.hooks.settled().catch(() => undefined)
     this.hooks.close()
     await this.apps.close()
@@ -315,6 +296,14 @@ export class Harness {
   }
 }
 
+function safeCount(root: string): number {
+  try {
+    return notes.paths(root).length
+  } catch {
+    return 0
+  }
+}
+
 export function createHarness(options: HarnessOptions): Harness {
   const harness = new Harness(options)
   if (options.dataRoot) harness.open(options.dataRoot)

package/src/{memory → history}/recall.test.ts

@@ -9,7 +9,7 @@ import { newId, writeJson } from '../core/fs'
 import { closeIndex } from '../core/index'
 import { runRecordSchema, type RunRecord } from '../sessions/contracts'
 import { parseEvent } from '../sessions/runStore'
-import type { CallerContext } from './caller'
+import type { CallerContext } from '../core/caller'
 import { passages, read, readTool, search, searchTool, sync } from './recall'
 
 const run = (id: string, mode: string, session: string, project: string | null, goal: string): RunRecord =>

package/src/{memory → history}/recall.ts

@@ -12,7 +12,7 @@ import { charCount, takeChars } from '../core/text'
 import type { RunEvent, RunRecord } from '../sessions/contracts'
 import { readAllRuns } from '../sessions/runIndex'
 import { findRun, readEvents } from '../sessions/runStore'
-import { isSession, projectOf, type CallerContext } from './caller'
+import { isSession, projectOf, type CallerContext } from '../core/caller'
 
 const PASSAGE_LIMIT = 6000
 const READ_LIMIT = 12_000

package/src/{memory → history}/trajectory.test.ts

@@ -8,9 +8,9 @@ import { closeIndex } from '../core/index'
 import { writeJson } from '../core/fs'
 import { runRecordSchema, type RunEvent, type RunRecord } from '../sessions/contracts'
 import { appendEvent, saveRun } from '../sessions/runStore'
-import { WIKI_AGENT_TOOLS } from '../tools/definitions'
-import type { CallerContext } from './caller'
-import { dispatch } from './dispatch'
+import { HARNESS_TOOLS } from '../tools/definitions'
+import type { CallerContext } from '../core/caller'
+import { dispatch } from '../tools/dispatch'
 import { readTool, searchTool } from './trajectory'
 
 const roots: string[] = []
@@ -170,7 +170,7 @@ test('trajectory calls reject malformed filters and missing current runs', () =>
 test('the model tool registry exposes both trajectory calls through Wiki dispatch', () => {
   const { root, env } = setup()
   save(root, run('registered-run'))
-  const calls = WIKI_AGENT_TOOLS.map((tool) => tool.call)
+  const calls = HARNESS_TOOLS.map((tool) => tool.call)
   expect(calls).toContain('trajectory.search')
   expect(calls).toContain('trajectory.read')
   expect(JSON.parse(dispatch(env, agent, 'trajectory.search', {})).runs[0].id).toBe('registered-run')

package/src/{memory → history}/trajectory.ts

@@ -8,7 +8,7 @@ import { scrubSensitive } from '../mcp/connections'
 import { isActiveStatus, runStatusSchema, type RunEvent, type RunRecord } from '../sessions/contracts'
 import { readAllRuns } from '../sessions/runIndex'
 import { findRun, snapshot } from '../sessions/runStore'
-import type { CallerContext } from './caller'
+import type { CallerContext } from '../core/caller'
 
 const SEARCH_DEFAULT = 10
 const SEARCH_MAX = 30