@xingular/harness 2.1.2 → 3.0.0

package/src/hub/hub.test.ts

@@ -6,7 +6,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import { Bus } from '../core/bus'
 import { Harness } from '../harness'
 import { memorySecretStore } from '../accounts/secrets'
-import * as registry from '../skills/registry'
+import * as registry from '../tree/components'
 import { Hub } from './hub'
 import { hubCatalogSchema, hubEntrySchema, type HubEntry } from './schema'
 import { runHubMenu } from '../terminal/hubMenu'
@@ -47,7 +47,7 @@ describe('Hub installation', () => {
     const { hub, root } = fixture([entry('registry', skill())])
     const receipt = await hub.install('example/review', '1.0.0')
     expect(receipt.resourceIds).toEqual(['skills/review'])
-    expect(registry.enabledFor(root, null)).toEqual([])
+    expect(registry.list(root).map((item) => item.id)).toContain('skills/review')
     const content = readFileSync(join(root, 'registry', 'skills', 'review', 'SKILL.md'), 'utf8')
     const collision = { ...entry('registry', skill()), id: 'other/review' }
     const another = new Hub(({ dataRoot: root, env: { root }, stateDir: join(root, 'state'), bus: new Bus() }) as Harness, { catalog: { schemaVersion: 1, entries: [collision] } })
@@ -67,7 +67,7 @@ describe('Hub installation', () => {
       const { hub, root } = fixture([item])
       await hub.install(item.id, item.version)
       expect(readFileSync(join(root, 'registry', kind, 'review.md'), 'utf8')).toContain('Read evidence')
-      expect(registry.enabledFor(root, null)).toEqual([])
+      expect(registry.list(root).map((entry) => entry.id)).toContain(`${kind}/review`)
     }
   })
   it('does not commit a download with the wrong digest', async () => {
@@ -140,12 +140,11 @@ describe('Hub installation', () => {
   it('can reinstall deleted resources and clears stale attachment grants', async () => {
     const { hub, root } = fixture([entry('registry', skill())])
     await hub.install('example/review', '1.0.0')
-    registry.setEnabled(root, null, ['skills/review'])
     rmSync(join(root, 'registry', 'skills', 'review'), { recursive: true })
     expect((await hub.list()).installed[0]).toMatchObject({ state: 'incomplete' })
     await hub.uninstall('example/review', '1.0.0')
     await hub.install('example/review', '1.0.0')
-    expect(registry.enabledFor(root, null)).toEqual([])
+    expect(registry.list(root).map((entry) => entry.id)).toEqual(['skills/review'])
     expect((await hub.list()).installed).toHaveLength(1)
   })
   it('preserves corrupt installation records rather than overwriting them', async () => {

package/src/hub/hub.ts

@@ -8,7 +8,7 @@ import { atomicWrite, now, readJson, readJsonOr, writeJson } from '../core/fs'
 import type { Harness } from '../harness'
 import * as pluginApi from '../plugins/api'
 import * as packages from '../plugins/install'
-import * as registry from '../skills/registry'
+import * as registry from '../tree/components'
 import * as attachments from '../plugins/attachments'
 import { version as harnessVersion } from '../../package.json'
 import bundled from './catalog.json'
@@ -244,7 +244,7 @@ export class Hub {
           const payload = JSON.parse(text)
           const previous = new Set(registry.list(root).map((item) => item.id))
           const imported = registry.importItems(root, delivery.registryKind, payload.items)
-          receipt.resourceIds = imported.items.filter((item) => !previous.has(item.id)).map((item) => item.id)
+          receipt.resourceIds = imported.filter((item) => !previous.has(item.id)).map((item) => item.id)
           const choices = structuredClone(choicesBefore)
           const ids = new Set(receipt.resourceIds)
           for (const scope of [choices.global, ...Object.values(choices.agents), ...Object.values(choices.projects)]) {

package/src/index.ts

@@ -1,11 +1,13 @@
-// @xingular/harness: a Pi agent harness. Multi-account Pi sessions, a compiled system prompt
-// with stable-prefix delivery, a memory lifecycle (Wiki, blocks, facts, recall, sleep-time
-// consolidation), tools with a gate and standing approvals, connected apps over MCP, and
-// skills (a person's own and built-in).
+// @xingular/harness: a Pi agent harness built on recursive harnessing (Harness², Apache-2.0,
+// Google LLC). Each agent runs on a versioned harness tree of eight components (system prompt,
+// guardrails, memory, tool guidance, subagents, skills, scripts, plugins); refinement improves a
+// tree from evidence through Propose–Probe–Compose, blind selection and an experience library.
+// Around it: multi-account Pi sessions, a compiled prompt with stable-prefix delivery, project
+// notes (the Wiki), history, tools with a gate and standing approvals, and connected apps.
 //
 // An application embeds it with `createHarness` and extends it through prompt sections, tool
-// providers, a tool policy, a secret store, a directory of its own names, and a description of
-// its own parts as plugins. Everything else is reachable by path, e.g. `@xingular/harness/memory/wiki`.
+// providers, a tool policy, a secret store, a directory of its own names, a description of its
+// own parts as plugins, and a refinement host. Everything else is reachable by path.
 export { createHarness, Harness, type HarnessOptions, type Recovery } from './harness'
 export { hubCatalogSchema, hubEntrySchema, hubOverviewSchema, hubReceiptSchema, type HubCatalog, type HubEntry, type HubOverview, type HubReceipt } from './hub/schema'
 
@@ -20,8 +22,8 @@ export type { AccountLoginSnapshot, ModelOption } from './accounts/accounts'
 export type { Capability, CapabilityCatalogue, CapabilityKind, CapabilityScope, CapabilitySet } from './capabilities/types'
 export type { RunCapabilitySnapshot } from './capabilities/runSnapshot'
 
-export type { CallerContext } from './memory/caller'
-export { dispatch as memoryCall } from './memory/dispatch'
+export type { CallerContext } from './core/caller'
+export { dispatch as harnessCall } from './tools/dispatch'
 
 export {
   compile,
@@ -30,7 +32,6 @@ export {
   CONTEXT_MESSAGE_TYPE,
   CONTEXT_SNAPSHOT_KEY,
   type ContextPack,
-  type ContextProfile,
   type HostSection,
   type HostToolGroup,
   type Launch,
@@ -45,19 +46,32 @@ export type { ActiveRun, ApprovalDecision, ApprovalInput, QuestionAnswer, Questi
 export type { RunFields, SessionRunInput } from './sessions/sessions'
 export type { Effort } from './sessions/runner'
 
-export { describeTool, WIKI_TOOLS, WIKI_TOOL_NAMES, type WikiCall, type WikiToolDefinition } from './tools/definitions'
+export { describeTool, HARNESS_TOOLS, DEFAULT_TOOL_NAMES, WIKI_WRITE, type HarnessCall, type HarnessToolDefinition } from './tools/definitions'
 export type { ToolProvider, ToolResult, ToolSession, ToolSpec } from './tools/types'
 export { SPAWN_SUBAGENT, SUBAGENT_RELATION } from './tools/spawnSubagent'
-export { maintenanceTools, MAINTENANCE_PLUGIN, MAINTENANCE_TOOL_NAMES } from './tools/maintenance'
-export type { CurationJob } from './memory/curation'
 export { webTools, WEB_PLUGIN, WEB_SEARCH_KEY, type WebToolOptions } from './web/tools'
-export { registryTools, REGISTRY_WRITE, PLUGIN_WRITE, REGISTRY_WRITE_PLUGIN, type RegistryToolOptions } from './tools/registryWrite'
 export { safeRequest, type WebRequest, type WebResponse } from './web/safeRequest'
 
 export type { BrokeredTools, BrokerSession, BrokerTool } from './mcp/service'
 export type { Connection, ConnectionInput, AppOAuthClients } from './mcp/types'
 
-export { configureBuiltins, type RegistryItem, type RegistryState, type SkillBundleInput } from './skills/registry'
+export { configureBuiltins, type ComponentItem, type SkillBundleInput } from './tree/components'
+
+// The harness tree and refinement.
+export { PI_SURFACE, componentOf, type ComponentGroup, type ComponentId, type ComponentInfo, type SurfaceSpec, type Tree } from './tree/surface'
+export { validate as validateTree, autotrigger, diffSummary, TreeError, type TreeCensus, type TreeDiff } from './tree/tree'
+export { fingerprint, type Head, type VersionRecord, type VersionSource } from './tree/store'
+export { materialise, type HarnessChoice, type Materialised } from './tree/materialise'
+export { seedTree, type SeedInput } from './tree/seed'
+export type { TrustedPlugin } from './tree/trust'
+export { DEFAULT_REFINE_HOST, defaultDeliverable, type RefineHost, type RolloutSession, type RolloutWorkspace } from './refine/host'
+export { PROBE_TRIGGER, IMPROVER_TRIGGER, type ImproverSettings } from './refine/pi'
+export type { CandidateView, StartInput as RefineStartInput } from './refine/service'
+export type { RefineEvent, RefineStatus, RefineSummary } from './refine/runner'
+export type { Executor, Improver, RecursionMode, RefineTask, Rollout } from './refine/types'
+export type { WorkPrompts } from './refine/prompts'
+export type { Experience } from './refine/library'
+export type { Note, NoteSummary } from './wiki/notes'
 
 export type { TerminalAssets, TerminalLaunch, TerminalPrepareInput } from './terminal/terminals'
 

package/src/mcp/connections.ts

@@ -8,7 +8,7 @@ import type { Bus } from '../core/bus'
 import { HarnessError, invalid, notFound } from '../core/errors'
 import { newId, readJson, safeId, writeJson } from '../core/fs'
 import { findBinary, pathVariableName, searchPath } from '../core/path'
-import { isDir } from '../memory/store'
+import { isDir } from '../core/fs'
 import type { RunEvent } from '../sessions/contracts'
 import * as attachments from '../plugins/attachments'
 import { connectionScopeMigrationComplete } from './scopeMigration'

package/src/mcp/service.ts

@@ -11,7 +11,7 @@ import { HarnessError, invalid, notFound } from '../core/errors'
 import { newId, now, readJson, writeJson } from '../core/fs'
 import { charCount, takeChars } from '../core/text'
 import type { CapabilitySet } from '../capabilities/types'
-import type { CallerContext } from '../memory/caller'
+import type { CallerContext } from '../core/caller'
 import type { ToolPolicy } from '../sessions/policy'
 import type { ActiveRun, RunRegistry } from '../sessions/registry'
 import { findRun, runDir } from '../sessions/runStore'

package/src/pi/proxy.test.ts

@@ -0,0 +1,68 @@
+import { execFile } from 'node:child_process'
+import { createServer } from 'node:http'
+import { promisify } from 'node:util'
+import { afterEach, expect, it } from 'vitest'
+
+const execFileAsync = promisify(execFile)
+const servers: ReturnType<typeof createServer>[] = []
+afterEach(async () => {
+  for (const server of servers.splice(0)) await new Promise<void>((resolve, reject) => server.close(error => error ? reject(error) : resolve()))
+})
+
+it('routes Pi HTTP requests through the process proxy environment', async () => {
+  const requests: Array<{ url: string | undefined; host: string | undefined; tunnel: boolean }> = []
+  const proxy = createServer((request, response) => {
+    requests.push({ url: request.url, host: request.headers.host, tunnel: false })
+    response.writeHead(200, { 'content-type': 'text/plain' })
+    response.end('served by local proxy')
+  })
+  proxy.on('connect', (request, socket, head) => {
+    requests.push({ url: request.url, host: request.headers.host, tunnel: true })
+    socket.write('HTTP/1.1 200 Connection Established\r\n\r\n')
+    let received = head.toString('utf8')
+    const respond = (): void => {
+      if (!received.includes('\r\n\r\n')) return
+      const body = 'served by local proxy'
+      socket.end(`HTTP/1.1 200 OK\r\nContent-Length: ${Buffer.byteLength(body)}\r\nConnection: close\r\n\r\n${body}`)
+    }
+    socket.on('data', chunk => {
+      received += chunk.toString('utf8')
+      respond()
+    })
+    respond()
+  })
+  servers.push(proxy)
+  await new Promise<void>((resolve, reject) => {
+    proxy.once('error', reject)
+    proxy.listen(0, '127.0.0.1', resolve)
+  })
+
+  const address = proxy.address()
+  if (!address || typeof address === 'string') throw new Error('The local proxy did not bind to a TCP port.')
+  const proxyUrl = `http://127.0.0.1:${address.port}`
+  const script = `
+    import { join } from 'node:path'
+    import { pathToFileURL } from 'node:url'
+
+    const pi = await import('@earendil-works/pi-coding-agent')
+    const dispatcherUrl = pathToFileURL(join(pi.getPackageDir(), 'dist/bundle/chunks/chunk-TJXZSVTD.js')).href
+    const { configureHttpDispatcher } = await import(dispatcherUrl)
+    configureHttpDispatcher()
+    const response = await fetch('http://127.0.0.2/dispatcher-check')
+    if (response.status !== 200 || await response.text() !== 'served by local proxy') throw new Error('Pi did not receive the local proxy response')
+  `
+  const env: NodeJS.ProcessEnv = {
+    ...(process.env.PATH ? { PATH: process.env.PATH } : {}),
+    HTTP_PROXY: proxyUrl,
+    HTTPS_PROXY: proxyUrl,
+    NO_PROXY: 'localhost,127.0.0.1'
+  }
+
+  await execFileAsync(process.execPath, ['--input-type=module', '-e', script], {
+    cwd: process.cwd(),
+    env,
+    timeout: 10_000
+  })
+
+  expect(requests).toEqual([{ url: '127.0.0.2:80', host: '127.0.0.2', tunnel: true }])
+})

package/src/pi/runtime.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { createPiLoader } from './runtime'
+
+describe('Pi runtime initialization', () => {
+  it('configures Pi networking before returning the module and shares concurrent initialization', async () => {
+    const events: string[] = []
+    const pi = { VERSION: '1.2.0', getPackageDir: () => '/pinned/pi' }
+    const load = createPiLoader(
+      async () => {
+        events.push('import Pi')
+        return pi
+      },
+      async (packageDir) => {
+        events.push(`load dispatcher from ${packageDir}`)
+        return { configureHttpDispatcher: () => events.push('configure dispatcher') }
+      }
+    )
+
+    const [first, second] = await Promise.all([load(), load()])
+
+    expect(first).toBe(pi)
+    expect(second).toBe(pi)
+    expect(events).toEqual(['import Pi', 'load dispatcher from /pinned/pi', 'configure dispatcher'])
+  })
+
+  it('rejects a Pi version change before loading its private dispatcher', async () => {
+    const loadDispatcher = vi.fn(async () => ({ configureHttpDispatcher: vi.fn() }))
+    const load = createPiLoader(async () => ({ VERSION: '1.3.0', getPackageDir: () => '/other/pi' }), loadDispatcher)
+
+    await expect(load()).rejects.toThrow('requires Pi 1.2.0')
+    expect(loadDispatcher).not.toHaveBeenCalled()
+  })
+
+  it('reports when Pi no longer exposes its private dispatcher hook', async () => {
+    const load = createPiLoader(
+      async () => ({ VERSION: '1.2.0', getPackageDir: () => '/pinned/pi' }),
+      async () => ({})
+    )
+
+    await expect(load()).rejects.toThrow('pinned Pi 1.2.0 HTTP dispatcher hook')
+  })
+
+  it('can retry initialization after a transient dispatcher load failure', async () => {
+    const configure = vi.fn()
+    let attempts = 0
+    const load = createPiLoader(
+      async () => ({ VERSION: '1.2.0', getPackageDir: () => '/pinned/pi' }),
+      async () => {
+        attempts++
+        if (attempts === 1) throw new Error('temporary import failure')
+        return { configureHttpDispatcher: configure }
+      }
+    )
+
+    await expect(load()).rejects.toThrow('temporary import failure')
+    await expect(load()).resolves.toMatchObject({ VERSION: '1.2.0' })
+    expect(attempts).toBe(2)
+    expect(configure).toHaveBeenCalledOnce()
+  })
+})

package/src/pi/runtime.ts

@@ -0,0 +1,50 @@
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+export const PINNED_PI_VERSION = '1.2.0'
+const HTTP_DISPATCHER_CHUNK = 'dist/bundle/chunks/chunk-TJXZSVTD.js'
+
+type PiRuntimeModule = {
+  VERSION: string
+  getPackageDir(): string
+}
+
+type PiDispatcherModule = {
+  configureHttpDispatcher?: unknown
+}
+
+export function assertPiRuntimeVersion(version: string): void {
+  if (version !== PINNED_PI_VERSION) throw new Error(`The Harness Pi runtime requires Pi ${PINNED_PI_VERSION}; found ${version}. Install the Harness package's pinned dependencies.`)
+}
+
+/** Builds a cached Pi loader so initialization order and compatibility behavior can be verified. */
+export function createPiLoader<T extends PiRuntimeModule>(
+  importPi: () => Promise<T>,
+  importDispatcher: (packageDir: string) => Promise<PiDispatcherModule>
+): () => Promise<T> {
+  let loading: Promise<T> | undefined
+
+  return () => {
+    if (!loading) {
+      loading = (async () => {
+        const pi = await importPi()
+        assertPiRuntimeVersion(pi.VERSION)
+        const dispatcher = await importDispatcher(pi.getPackageDir())
+        if (typeof dispatcher.configureHttpDispatcher !== 'function') {
+          throw new Error(`The Harness requires the pinned Pi ${PINNED_PI_VERSION} HTTP dispatcher hook; install the Harness package's pinned dependencies.`)
+        }
+        dispatcher.configureHttpDispatcher()
+        return pi
+      })().catch((error: unknown) => {
+        loading = undefined
+        throw error
+      })
+    }
+    return loading
+  }
+}
+
+export const loadPi = createPiLoader(
+  () => import('@earendil-works/pi-coding-agent'),
+  async (packageDir) => await import(pathToFileURL(join(packageDir, HTTP_DISPATCHER_CHUNK)).href) as PiDispatcherModule
+)

package/src/plugins/api.ts

@@ -6,10 +6,10 @@ import { ensureSharedDir, sharedDir } from '../accounts/env'
 import { invalid, notFound } from '../core/errors'
 import { findProject } from '../core/projects'
 import type { Harness } from '../harness'
-import type { CallerContext } from '../memory/caller'
+import type { CallerContext } from '../core/caller'
 import type { Launch } from '../prompt/compile'
+import { materialise, type HarnessChoice } from '../tree/materialise'
 import * as attachments from './attachments'
-import { INCLUDED_PLUGIN, YOURS_PLUGIN } from './builtin'
 import { catalogue } from './catalogue'
 import { inventory } from './inventory'
 import type { Loading } from './plugins'
@@ -67,6 +67,8 @@ export interface InventoryParams extends PluginScope {
   launch?: Launch
   tools?: string[]
   connections?: boolean
+  /** The harness tree the caller runs, so what it adds is listed too. */
+  harness?: HarnessChoice | null
 }
 
 export async function inventoryFor(harness: Harness, params: InventoryParams): Promise<Inventory> {
@@ -79,7 +81,8 @@ export async function inventoryFor(harness: Harness, params: InventoryParams): P
     // What is switched off for the caller is not in what reaches it.
     plugins: await list(harness, { ...params, agentId: params.agentId ?? params.context?.agentId ?? null, projectId: params.projectId ?? params.context?.projectId ?? null }),
     descriptors: harness.descriptors,
-    saved: harness.apps.connections.list()
+    saved: harness.apps.connections.list(),
+    tree: params.harness ? materialise(harness.env.root, params.harness, { trust: harness.trust }) : null
   })
 }
 
@@ -129,13 +132,12 @@ export async function attach(harness: Harness, params: AttachParams, on: boolean
   if (contribution?.kind === 'connection') {
     harness.apps.attach(contribution.id.slice(`${plugin.id}/connection/`.length), scope, on)
   } else {
-    const registryItem = plugin.id === YOURS_PLUGIN.id || plugin.id === INCLUDED_PLUGIN.id
-    // A registry item's choice is stored under its own id; anything found, under its id and then its plugin's.
-    const ids = registryItem ? [contribution!.id.slice(plugin.id.length + 1)] : contribution ? [contribution.id, plugin.id] : [plugin.id]
-    // What it is until a person says otherwise: a built-in registry item is on, a person's own is
-    // off, a part that ships switched off is off, and anything found on disk is on.
+    // A choice is stored under the contribution's id and then its plugin's.
+    const ids = contribution ? [contribution.id, plugin.id] : [plugin.id]
+    // What it is until a person says otherwise: a part that ships switched off is off, and
+    // anything found on disk is on.
     const shipped = harness.descriptors.find((descriptor) => descriptor.id === plugin.id)?.switchable
-    const fallback = registryItem ? plugin.id === INCLUDED_PLUGIN.id : shipped ? shipped.on : true
+    const fallback = shipped ? shipped.on : true
     const choices = attachments.load(root)
     attachments.set(choices, ids, scope, on, fallback)
     attachments.save(root, choices)

package/src/plugins/builtin.ts

@@ -3,12 +3,11 @@
 import { CONNECTION_TOOLS, NATIVE_GROUP } from '../prompt/compile'
 import { ASK_USER } from '../tools/askUser'
 import { SPAWN_SUBAGENT, WAIT_SUBAGENTS } from '../sessions/subagents'
-import { PLUGIN_PROPOSE } from '../tools/pluginPropose'
-import { MEMORY_TOOLS, RECALL_TOOLS, TRAJECTORY_TOOLS, WIKI_TOOLS, type WikiToolDefinition } from '../tools/definitions'
+import { RECALL_TOOLS, SKILL_TOOLS, TRAJECTORY_TOOLS, WIKI_READ_TOOLS, WIKI_WRITE_TOOLS, type HarnessToolDefinition } from '../tools/definitions'
 import { FIRST_PARTY_PLUGINS } from './firstParty'
 import type { PluginDescriptor } from './types'
 
-const tools = (definitions: readonly WikiToolDefinition[]): PluginDescriptor['tools'] => definitions.map((tool) => ({ name: tool.name, description: tool.label }))
+const tools = (definitions: readonly HarnessToolDefinition[]): PluginDescriptor['tools'] => definitions.map((tool) => ({ name: tool.name, description: tool.label }))
 
 /** Pi itself. Its command's built-in extensions are added to it as they are found. */
 export const PI_PLUGIN: PluginDescriptor = {
@@ -20,55 +19,39 @@ export const PI_PLUGIN: PluginDescriptor = {
   toolGroups: ['Native']
 }
 
-/** A person's own registry. It owns the rules and skills sections even while it is empty. */
-export const YOURS_PLUGIN: PluginDescriptor = {
-  id: 'yours',
-  title: 'Yours',
-  description: 'Rules, skills and prompts you wrote, kept as files in the registry folder.',
-  manage: 'registry',
+/** The harness tree: the eight components that shape what an agent is told and can do. */
+export const HARNESS_TREE_PLUGIN: PluginDescriptor = {
+  id: 'harness',
+  title: 'Harness',
+  description: 'The agent\'s own harness: system prompt, guardrails, memory and tool guidance in every prompt; skills, scripts and subagents on demand; plugins in the tool loop. Versioned, and refined from evidence.',
+  required: 'Every agent runs on its harness.',
   sections: [
-    { id: 'rules', name: 'Rules', description: 'The full text of every rule that is on.' },
-    { id: 'skills', name: 'Skills list', description: 'One line for each skill that is on.' }
+    { id: 'system', name: 'System prompt', description: 'c1: role and procedure.' },
+    { id: 'guardrails', name: 'Guardrails', description: 'c2: standing rules.' },
+    { id: 'memory', name: 'Memory', description: 'c3: durable facts about this kind of work.' },
+    { id: 'subagents', name: 'Subagents', description: 'c5: the list of this harness\'s subagents.' },
+    { id: 'scripts', name: 'Scripts', description: 'c7: where this harness\'s scripts are.' }
   ],
-  tools: WIKI_TOOLS.filter((tool) => tool.name === 'skill_load').map((tool) => ({ name: tool.name, description: tool.label }))
+  tools: tools(SKILL_TOOLS)
 }
 
-export const INCLUDED_PLUGIN: PluginDescriptor = { id: 'included', title: 'Included', description: 'Rules, skills and prompts that ship with the app.', manage: 'registry' }
-
 export const HARNESS_PLUGINS: readonly PluginDescriptor[] = [
   PI_PLUGIN,
   { id: 'subagents', title: 'Subagents', description: 'Isolated child runs of the same caller, bounded by parent capabilities and nesting depth.', required: 'Availability is selected by the session host; child runs retain the parent permission boundary.', tools: [{ name: SPAWN_SUBAGENT, description: 'Start a subagent' }, { name: WAIT_SUBAGENTS, description: 'Wait for subagents' }] },
-  {
-    id: 'memory',
-    title: 'Memory',
-    description: 'Blocks of text that are always in context and that the agent edits as it works.',
-    required: 'Every agent keeps its own memory, and the background upkeep depends on it.',
-    // Facts are memory too: what the agent wrote down, recalled on request.
-    tools: tools([...MEMORY_TOOLS, ...WIKI_TOOLS.filter((tool) => tool.name === 'memory_facts')]),
-    sections: [{ id: 'blocks', name: 'Memory blocks', description: 'Every block attached to the caller, in full.' }],
-    toolGroups: ['Memory']
-  },
+  HARNESS_TREE_PLUGIN,
   {
     id: 'wiki',
     title: 'Wiki',
-    description: 'Pages and facts the agent searches, reads, and proposes changes to.',
-    required: 'What was learned is recorded and checked here.',
-    // `WIKI_TOOLS` is every memory tool; the Wiki's own are the ones that are not Memory's or History's.
-    tools: tools(WIKI_TOOLS.filter((tool) => tool.name.startsWith('wiki_'))),
+    description: 'Notes about projects, linked to each other, that agents search and read.',
+    required: 'Project notes are reached through it.',
+    tools: tools([...WIKI_READ_TOOLS, ...WIKI_WRITE_TOOLS]),
     sections: [
-      { id: 'knowledge', name: 'Knowledge map', description: 'Project pages, the Library count, and facts that match the request.' },
-      { id: 'references', name: 'Selected references', description: 'Pages and skills pinned to one request.' }
+      { id: 'wiki', name: 'Wiki', description: 'The current project\'s notes.' },
+      { id: 'references', name: 'Selected references', description: 'Notes pinned to one request.' }
     ],
-    toolGroups: ['Knowledge']
-  },
-  { id: 'history', title: 'History', description: 'Search earlier conversations and inspect recorded run trajectories.', required: 'Earlier runs are how an agent picks up where work stopped.', tools: tools([...RECALL_TOOLS, ...TRAJECTORY_TOOLS]) },
-  {
-    id: 'plugin-proposals',
-    title: 'Plugin proposals',
-    description: 'Lets an agent propose a plugin. You accept it in the Inbox, switch it on, and trust its code; an agent can do none of those.',
-    required: 'It only proposes. Nothing is saved or run until you decide.',
-    tools: [{ name: PLUGIN_PROPOSE, description: 'Propose a plugin' }]
+    toolGroups: ['Wiki']
   },
+  { id: 'history', title: 'History', description: 'Search earlier conversations and inspect recorded run trajectories.', required: 'Earlier runs are how an agent picks up where work stopped.', tools: tools([...RECALL_TOOLS, ...TRAJECTORY_TOOLS]), toolGroups: ['History'] },
   { id: 'ask-user', title: 'Ask the user', description: 'Lets the agent stop and ask a question with choices.', required: 'An agent must be able to stop and ask you.', tools: [{ name: ASK_USER }] },
   {
     id: 'connected-apps',
@@ -79,6 +62,5 @@ export const HARNESS_PLUGINS: readonly PluginDescriptor[] = [
     tools: CONNECTION_TOOLS.map((name) => ({ name })),
     toolGroups: ['Connections']
   },
-  YOURS_PLUGIN,
   ...FIRST_PARTY_PLUGINS
 ]

package/src/plugins/catalogue.test.ts

@@ -6,7 +6,7 @@ import { afterEach, describe, expect, it } from 'vitest'
 import { memorySecretStore } from '../accounts/secrets'
 import { createHarness, type Harness } from '../harness'
 import { methods } from '../server/methods'
-import { WIKI_TOOLS } from '../tools/definitions'
+import { HARNESS_TOOLS } from '../tools/definitions'
 import { WEB_PLUGIN } from '../web/tools'
 import { rootWithProject, writeFile } from '../../tests/helpers'
 import { HARNESS_PLUGINS } from './builtin'
@@ -68,12 +68,11 @@ describe('the plugin list', () => {
       ['project', 'project', ['code:local.ts:untrusted', 'instruction:AGENTS.md:on']],
       ['package:review-kit', 'package', ['code:guard.ts:on', 'command:guard:on', 'skill:audit:on']],
       ['home', 'home', ['skill:deploy:on']],
-      ['yours', 'yours', ['instruction:Rules:on', 'instruction:Skills list:on', 'tool:skill_load:on', 'command:review:on', 'instruction:Run tests:on', 'skill:Release notes:on', 'skill:unused:off']],
       ['app-identity', 'application', ['instruction:Identity line:on']],
       ['app-tasks', 'application', ['tool:start_task:on']],
       ['web', 'application', ['tool:web_search:on', 'tool:web_fetch:on']]
     ])
-    expect(plugins.filter((plugin) => plugin.source === 'builtin').map((plugin) => plugin.id)).toEqual(['ask-user', 'budget-guard', 'connected-apps', 'history', 'memory', 'output-trim', 'plugin-proposals', 'subagents', 'wiki'])
+    expect(plugins.filter((plugin) => plugin.source === 'builtin').map((plugin) => plugin.id)).toEqual(['ask-user', 'budget-guard', 'connected-apps', 'harness', 'history', 'output-trim', 'subagents', 'wiki'])
 
     const kit = plugins.find((plugin) => plugin.id === 'package:review-kit')!
     // It was there when trust was first asked per package, so it was taken over as trusted.
@@ -81,8 +80,6 @@ describe('the plugin list', () => {
     expect(kit.contributions[0].description).toBe('Adds commands /guard; hooks tool_call.')
     const project = plugins.find((plugin) => plugin.id === 'project')!
     expect(project).toMatchObject({ runsCode: true, trust: 'untrusted', code: { files: ['.pi/extensions/local.ts'] } })
-    const yours = plugins.find((plugin) => plugin.id === 'yours')!
-    expect(yours.contributions.map((entry) => entry.scope)).toEqual([null, null, null, 'App', 'Everywhere', 'App', null])
     const pi = plugins.find((plugin) => plugin.id === 'pi')!
     expect(pi.required).toBe('Pi runs every session.')
     expect(pi.contributions.filter((entry) => entry.kind === 'code').map((entry) => [entry.name, entry.state])).toEqual([['mcp', 'on'], ['llama.cpp', 'off']])
@@ -94,7 +91,7 @@ describe('the plugin list', () => {
       expect(names.filter((name, index) => names.indexOf(name) !== index)).toEqual([])
     }
     const declared = HARNESS_PLUGINS.flatMap((plugin) => (plugin.tools ?? []).map((tool) => tool.name))
-    expect(WIKI_TOOLS.map((tool) => tool.name).filter((name) => !declared.includes(name))).toEqual([])
+    expect(HARNESS_TOOLS.map((tool) => tool.name).filter((name) => !declared.includes(name))).toEqual([])
   })
 
   it('lists nothing a folder brings when no folder is named, and what every account shares even before the first account exists', async () => {
@@ -133,20 +130,21 @@ describe('what reaches one caller', () => {
   }
 
   it('attributes every prompt section, tool group and tool to a plugin', async () => {
-    const { call, cwd } = setup()
-    const result = await call<Inventory>('plugins.inventory', { cwd, context: { agentId: 'a1', projectId: 'p1' }, launch, tools: ['read', 'bash', 'start_task', 'web_search'] })
+    const { call, cwd, harness } = setup()
+    const { commit } = await import('../tree/store')
+    commit(harness.env.root, 'a1', { 'systemprompt.md': 'You review changes.\n', 'guardrails.md': '- When writing release notes, load the `release` skill.\n', 'memory.md': '', 'tool_guidance.md': 'Prefer grep.\n', 'skills/release/SKILL.md': '---\nname: release\ndescription: writing release notes\n---\nSteps.\n' }, { kind: 'seed' })
+    const result = await call<Inventory>('plugins.inventory', { cwd, context: { agentId: 'a1', projectId: 'p1' }, launch, tools: ['read', 'bash', 'start_task', 'web_search'], harness: { scope: 'a1' } })
     expect(result.unattributed).toEqual([])
     const of = (plugin: string) => result.items.filter((item) => item.pluginId === plugin).map((item) => `${item.kind}:${item.name}:${item.delivery}`)
     expect(of('app-identity')).toEqual(['instruction:Identity line:system'])
     expect(of('app-tasks')).toEqual(['instruction:Tool guidance: Tasks:system', 'tool:start_task:tool'])
-    expect(of('yours')).toEqual(['instruction:Run tests:system', 'instruction:Skills list:system', 'command:review:on-demand', 'skill:Release notes:on-demand', 'tool:skill_load:tool'])
-    // Facts are memory: recalling them is a memory tool, though it is defined beside the Wiki's.
-    expect(of('memory')).toEqual(['instruction:Memory blocks:context', 'instruction:Tool guidance: Memory:system', 'tool:memory_append:tool', 'tool:memory_replace:tool', 'tool:memory_rethink:tool', 'tool:memory_facts:tool'])
+    expect(of('harness')).toEqual(['instruction:System prompt:system', 'instruction:Guardrails:system', 'skill:release:on-demand', 'tool:skill_load:tool'])
+    expect(of('wiki')).toEqual(['instruction:Wiki:context', 'instruction:Tool guidance: Wiki:system', 'tool:wiki_search:tool', 'tool:wiki_read:tool', 'tool:wiki_list:tool'])
+    expect(of('history')).toEqual(['instruction:Tool guidance: History:system', 'tool:history_search:tool', 'tool:history_read:tool', 'tool:trajectory_search:tool', 'tool:trajectory_read:tool'])
     expect(of('pi')).toEqual(['instruction:Tool guidance: Native:system', 'tool:read:tool', 'tool:bash:tool', 'instruction:Base prompt:system'])
     // The working folder's code is not trusted, so only its instruction file reaches the caller.
     expect(of('project')).toEqual(['instruction:AGENTS.md:system'])
     expect(of('package:review-kit')).toEqual(['code:guard.ts:code', 'skill:audit:on-demand'])
-    expect(result.items.find((item) => item.name === 'Run tests')).toMatchObject({ contributionId: 'yours/rules/tests', cut: false })
     expect(result.items.find((item) => item.name === 'AGENTS.md')?.chars).toBe(10)
     expect(result.systemChars).toBeGreaterThan(0)
     expect(result.contextChars).toBeGreaterThan(0)
@@ -177,31 +175,6 @@ describe('what reaches one caller', () => {
 })
 
 describe('switching a plugin on and off', () => {
-  const state = (plugins: Plugin[], id: string) => plugins.flatMap((plugin) => plugin.contributions).find((entry) => entry.id === id)?.state
-
-  it('switches a registry item for one agent, and the agent then gets it in its prompt', async () => {
-    const { call } = setup()
-    const compiled = async (agentId: string) => (await call<{ text: string }>('context.compile', { context: { agentId, actor: 'Chat' }, render: true })).text
-    expect(await compiled('a1')).not.toContain('Release notes')
-    const after = await call<Plugin[]>('plugins.attach', { id: 'yours/skills/release', scope: { agentId: 'a1' } })
-    const release = after.flatMap((plugin) => plugin.contributions).find((entry) => entry.id === 'yours/skills/release')!
-    expect(release.attachment).toEqual({ global: false, on: { agentIds: ['a1'], projectIds: ['p1'] }, off: { agentIds: [], projectIds: [] } })
-    expect(release.scope).toBe('App, 1 agent')
-    expect(await compiled('a1')).toContain('Release notes')
-    expect(await compiled('a2')).not.toContain('Release notes')
-    // The earlier calls read the same choices.
-    expect((await call<any>('skills.list')).enabled).toEqual({ global: ['rules/tests'], p1: ['skills/release', 'prompts/review'] })
-
-    // A rule that is on everywhere is switched off for one agent only.
-    await call('plugins.detach', { id: 'yours/rules/tests', scope: { agentId: 'a1' } })
-    expect(await compiled('a1')).not.toContain('Always run the test suite')
-    expect(await compiled('a2')).toContain('Always run the test suite')
-    expect(state(await call<Plugin[]>('plugins.list', { agentId: 'a1' }), 'yours/rules/tests')).toBe('off')
-    expect(state(await call<Plugin[]>('plugins.list', { agentId: 'a2' }), 'yours/rules/tests')).toBe('on')
-
-    await call('plugins.forgetAgent', { agentId: 'a1' })
-    expect(await compiled('a1')).toContain('Always run the test suite')
-  })
 
   it('stops a found plugin, or one item of it, from loading for the caller it was switched off for', async () => {
     const { call, harness, cwd, base } = setup()
@@ -230,13 +203,12 @@ describe('switching a plugin on and off', () => {
 
   it('refuses a required part, an application part, and a file Pi reads itself, and says why', async () => {
     const { call, cwd } = setup()
-    await expect(call('plugins.detach', { id: 'memory' })).rejects.toThrow('Memory cannot be switched off. Every agent keeps its own memory')
-    await expect(call('plugins.detach', { id: 'memory/tool/memory_append' })).rejects.toThrow('cannot be switched off')
+    await expect(call('plugins.detach', { id: 'harness' })).rejects.toThrow('Harness cannot be switched off. Every agent runs on its harness')
+    await expect(call('plugins.detach', { id: 'wiki/tool/wiki_read' })).rejects.toThrow('cannot be switched off')
     await expect(call('plugins.detach', { id: 'app-tasks' })).rejects.toThrow('switched by the application')
-    await expect(call('plugins.detach', { id: 'yours' })).rejects.toThrow('one item at a time')
     await expect(call('plugins.detach', { cwd, id: 'project/instruction/AGENTS.md' })).rejects.toThrow('cannot be switched on its own')
     await expect(call('plugins.detach', { id: 'no-such-plugin' })).rejects.toThrow()
-    await expect(call('plugins.attach', { id: 'yours/skills/release', scope: { projectId: 'nope' } })).rejects.toThrow()
+    await expect(call('plugins.attach', { id: 'package:review-kit', scope: { projectId: 'nope' } })).rejects.toThrow()
   })
 
   it('switches a connected app for one agent through its own scope', async () => {