@xingular/harness 2.1.1 → 3.0.0

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 () => {

package/src/plugins/catalogue.ts

@@ -1,13 +1,11 @@
 // Every plugin there is, from every source, as one list. Building it reads files and settings;
 // it runs no plugin's code and changes nothing.
-import { basename, dirname, join } from 'node:path'
+import { basename, dirname } from 'node:path'
 
 import { projectsOrNone } from '../core/projects'
 import { compareText } from '../core/text'
 import type { Connection } from '../mcp/types'
-import * as registry from '../skills/registry'
 import { attached, describe, type Attachment, type Attachments, type AttachScope } from './attachments'
-import { INCLUDED_PLUGIN, YOURS_PLUGIN } from './builtin'
 import { settingValue } from './firstParty'
 import { BUILTIN_PREFIX, type Found } from './discover'
 import { registrationHash } from './runtime'
@@ -40,8 +38,6 @@ export interface CatalogueInput {
   caller: AttachScope
 }
 
-const REGISTRY_KINDS: Record<string, ContributionKind> = { rules: 'instruction', skills: 'skill', prompts: 'command' }
-
 const contribution = (plugin: string, kind: ContributionKind, name: string, rest: Partial<Contribution> = {}): Contribution => ({
   id: contributionId(plugin, kind, name),
   kind,
@@ -98,24 +94,6 @@ function scopeWords(attachment: Attachment, projects: Map<string, string>): stri
   return parts.length ? parts.join(', ') : null
 }
 
-/** A person's registry items, and the built-in ones, as contributions with who each is on for. */
-function registryContributions(input: CatalogueInput, projects: Map<string, string>): { yours: Contribution[]; included: Contribution[] } {
-  const yours: Contribution[] = []
-  const included: Contribution[] = []
-  const scoped = !!(input.caller.agentId || input.caller.projectId)
-  for (const item of registry.list(input.root)) {
-    const kind = REGISTRY_KINDS[item.kind]
-    if (!kind) continue
-    // A registry item's choices are stored under its own id, whichever plugin lists it.
-    const attachment = describe(input.attachments, item.id, !!item.builtin)
-    const scope = scopeWords(attachment, projects)
-    const on = scoped ? attached(input.attachments, [item.id], input.caller, !!item.builtin) : scope !== null
-    const plugin = item.builtin ? INCLUDED_PLUGIN.id : YOURS_PLUGIN.id
-    ;(item.builtin ? included : yours).push({ ...contribution(plugin, kind, item.name, { description: item.description, path: item.path, state: on ? 'on' : 'off', scope, attachment }), id: `${plugin}/${item.id}` })
-  }
-  return { yours, included }
-}
-
 /** A connection keeps its own scope; this is the same shape for a screen. */
 function connectionAttachment(connection: Connection): Attachment | null {
   if (!connection.enabled) return null
@@ -177,16 +155,8 @@ const empty = (id: string, title: string, description: string, source: PluginSou
 
 export function catalogue(input: CatalogueInput): Plugin[] {
   const plugins = new Map<string, Plugin>()
-  for (const descriptor of input.descriptors) plugins.set(descriptor.id, fromDescriptor(descriptor, descriptor.id === 'pi' ? 'pi' : descriptor.id === YOURS_PLUGIN.id ? 'yours' : input.application.has(descriptor.id) ? 'application' : 'builtin', input.attachments, input.caller))
+  for (const descriptor of input.descriptors) plugins.set(descriptor.id, fromDescriptor(descriptor, descriptor.id === 'pi' ? 'pi' : input.application.has(descriptor.id) ? 'application' : 'builtin', input.attachments, input.caller))
 
-  const projects = new Map(projectsOrNone(input.root).map((project) => [project.id, project.name]))
-  const items = registryContributions(input, projects)
-  const yours = plugins.get(YOURS_PLUGIN.id)
-  if (yours) {
-    yours.path = join(input.root, 'registry')
-    yours.contributions.push(...items.yours)
-  }
-  if (items.included.length) plugins.set(INCLUDED_PLUGIN.id, { ...fromDescriptor(INCLUDED_PLUGIN, 'builtin'), contributions: items.included })
 
   const apps = plugins.get('connected-apps')
   if (apps) {
@@ -196,6 +166,7 @@ export function catalogue(input: CatalogueInput): Plugin[] {
     }
   }
 
+  const projects = new Map(projectsOrNone(input.root).map((project) => [project.id, project.name]))
   const loading = input.loading
   const trusted = trustedBy(loading)
   for (const item of loading?.found ?? []) {

package/src/plugins/discover.ts

@@ -5,6 +5,7 @@ import { homedir } from 'node:os'
 import { join, sep } from 'node:path'
 
 import { log } from '../core/bus'
+import { loadPi } from '../pi/runtime'
 import { packageManifest } from './manifest'
 
 /**
@@ -82,7 +83,7 @@ export async function withoutInstallScripts<T>(action: () => Promise<T>): Promis
 }
 
 export const piResolver: Resolver = async ({ cwd, agentDir, install, packages }) => {
-  const pi = await import('@earendil-works/pi-coding-agent')
+  const pi = await loadPi()
   const settings = pi.SettingsManager.create(cwd, agentDir)
   const shared = new Set((settings.getGlobalSettings().packages ?? []).map((entry) => (typeof entry === 'string' ? entry : entry.source)))
   const manager = (): InstanceType<typeof pi.DefaultPackageManager> => new pi.DefaultPackageManager({ cwd, agentDir, settingsManager: settings, builtinExtensions: [...PI_BUILTINS] })

package/src/plugins/firstParty.test.ts

@@ -23,7 +23,7 @@ async function setup() {
   const root = rootWithProject()
   const base = mkdtempSync(join(tmpdir(), 'first-party-'))
   // The background upkeep would ask the scripted model too; it is not what is tested here.
-  const harness = createHarness({ dataRoot: root, stateDir: join(base, 'state'), secrets: memorySecretStore(), maintainerFactory: async () => ({ prompt: async () => undefined, dispose: () => undefined, error: () => null }) })
+  const harness = createHarness({ dataRoot: root, stateDir: join(base, 'state'), secrets: memorySecretStore() })
   open.push(harness)
   harness.accounts.create('Main', 'apiKey')
   const model = await fauxModel(harness)

package/src/plugins/hooks.test.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync, readFileSync, readdirSync } from 'node:fs'
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
@@ -6,13 +6,9 @@ import { afterEach, describe, expect, it } from 'vitest'
 import { memorySecretStore } from '../accounts/secrets'
 import { Bus } from '../core/bus'
 import { createHarness, type Harness } from '../harness'
-import { listInbox } from '../memory/operations'
-import { wikiDir } from '../memory/store'
 import { methods } from '../server/methods'
-import { pluginProposeTool } from '../tools/pluginPropose'
 import { rootWithProject, writeFile } from '../../tests/helpers'
 import { entryEvent, Hooks, type HookEvent } from './hooks'
-import { checkPluginProposal } from './proposal'
 import type { Plugin } from './types'
 
 const open: Harness[] = []
@@ -31,7 +27,7 @@ const recorder = (out: string, events: string[], extra = ''): string =>
 const told = (out: string): Record<string, unknown>[] => (existsSync(out) ? readFileSync(out, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line)) : [])
 
 function kit(folder: string, name: string, hooks: string): void {
-  writeFile(join(folder, 'package.json'), JSON.stringify({ name, version: '1.0.0', description: `${name} mirrors memory.`, harness: { extends: ['memory', 'nonsense'], hooks: './hooks.mjs' } }))
+  writeFile(join(folder, 'package.json'), JSON.stringify({ name, version: '1.0.0', description: `${name} mirrors notes.`, harness: { extends: ['wiki', 'nonsense'], hooks: './hooks.mjs' } }))
   writeFile(join(folder, 'hooks.mjs'), hooks)
 }
 
@@ -42,30 +38,28 @@ function setup() {
   open.push(harness)
   const table = methods(harness)
   const call = <T>(method: string, params: Record<string, unknown> = {}) => table[method](params) as Promise<T>
-  const saveFact = (title: string, body: string) => call('facts.save', { input: { title, kind: 'fact', body, namespace: '/' } })
+  const saveFact = (title: string, body: string) => call('wiki.write', { path: `library/${title.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`, text: `---\ntitle: ${title}\n---\n\n${body}\n` })
   return { harness, root, base, call, saveFact }
 }
 
 describe('a written file as an event', () => {
-  it('is a fact, a memory block, or a page by where it is in the Wiki', () => {
+  it('is a saved note, titled from its front matter', () => {
     const wiki = '/data/wiki'
     const change = (path: string, text: string) => entryEvent({ wiki, id: 'x', path: join(wiki, path), text, actor: 'user', reason: 'Edited' })
-    expect(change('facts/pnpm.md', '---\ntitle: Use pnpm\nkind: preference\n---\n\nAlways pnpm.\n')).toMatchObject({ type: 'memory.saved', title: 'Use pnpm', body: 'Always pnpm.', actor: 'user' })
-    expect(change('blocks/agents/a1/notes.md', '---\nlabel: notes\n---\n\nLikes tabs.\n')).toMatchObject({ type: 'memory.block.changed', title: 'notes', body: 'Likes tabs.' })
-    expect(change('library/arch.md', '---\ntitle: Architecture\n---\n\nLayers.\n')).toMatchObject({ type: 'wiki.page.saved', title: 'Architecture' })
+    expect(change('library/arch.md', '---\ntitle: Architecture\n---\n\nLayers.\n')).toMatchObject({ type: 'wiki.page.saved', title: 'Architecture', body: 'Layers.', actor: 'user' })
     expect(change('home.md', 'No front matter.')).toMatchObject({ type: 'wiki.page.saved', title: 'x', body: 'No front matter.' })
   })
 })
 
 describe('hooks a plugin gives the harness', () => {
-  it('mirrors saved facts through a real disposable MCP subprocess and stops on detach, changed code or revoked permission', async () => {
+  it('mirrors saved notes through a real disposable MCP subprocess and stops on detach, changed code or revoked permission', async () => {
     const { harness, base, call, saveFact } = setup()
     const output = join(base, 'mirrored.jsonl')
     await harness.apps.save({ id: 'mirror', name: 'Disposable mirror', kind: 'local', command: process.execPath, args: [join(process.cwd(), 'tests/mcp-hook-fixture.mjs'), output], enabled: true, global: true, readTools: ['mirror_fact'] })
     const paths = ['one', 'two'].map((name) => join(base, name))
     for (const [index, path] of paths.entries()) {
       const name = ['mirror-one', 'mirror-two'][index]
-      kit(path, name, `export default function(harness) { harness.on('memory.saved', async (event, ctx) => { await ctx.call('Disposable mirror', 'mirror_fact', { plugin: '${name}', id: event.id, title: event.title, body: event.body }) }) }\n`)
+      kit(path, name, `export default function(harness) { harness.on('wiki.page.saved', async (event, ctx) => { await ctx.call('Disposable mirror', 'mirror_fact', { plugin: '${name}', id: event.id, title: event.title, body: event.body }) }) }\n`)
       const plugins = await call<Plugin[]>('plugins.install', { source: path })
       const plugin = plugins.find((entry) => entry.id === `package:${name}`)!
       await call('plugins.attach', { id: plugin.id })
@@ -97,17 +91,17 @@ describe('hooks a plugin gives the harness', () => {
     const { harness, base, call, saveFact } = setup()
     const one = join(base, 'one.log')
     const two = join(base, 'two.log')
-    kit(join(base, 'docs'), 'memory-to-docs', recorder(one, ['memory.saved']))
-    kit(join(base, 'sheet'), 'memory-to-sheet', recorder(two, ['memory.saved', 'history.run.ended']))
+    kit(join(base, 'docs'), 'notes-to-docs', recorder(one, ['wiki.page.saved']))
+    kit(join(base, 'sheet'), 'notes-to-sheet', recorder(two, ['wiki.page.saved', 'history.run.ended']))
     await call('plugins.install', { source: join(base, 'docs') })
     const listed = await call<Plugin[]>('plugins.install', { source: join(base, 'sheet') })
-    const docs = listed.find((plugin) => plugin.id === 'package:memory-to-docs')!
-    const sheet = listed.find((plugin) => plugin.id === 'package:memory-to-sheet')!
+    const docs = listed.find((plugin) => plugin.id === 'package:notes-to-docs')!
+    const sheet = listed.find((plugin) => plugin.id === 'package:notes-to-sheet')!
     // What it says it extends is kept only for parts that exist.
-    expect(docs).toMatchObject({ extends: ['memory'], runsCode: true, trust: 'untrusted', attachment: { global: false } })
+    expect(docs).toMatchObject({ extends: ['wiki'], runsCode: true, trust: 'untrusted', attachment: { global: false } })
     expect(docs.contributions.map((entry) => [entry.kind, entry.name, entry.state])).toEqual([['code', 'hooks.mjs', 'off']])
 
-    // Installed, switched off, untrusted: a saved fact reaches nobody.
+    // Installed, switched off, untrusted: a saved note reaches nobody.
     await saveFact('Use pnpm', 'Always pnpm.')
     await harness.hooks.settled()
     expect([told(one), told(two)]).toEqual([[], []])
@@ -120,17 +114,17 @@ describe('hooks a plugin gives the harness', () => {
     await harness.hooks.settled()
     expect([told(one), told(two)]).toEqual([[], []])
 
-    // Trusted: both hear the next fact, each in its own way.
+    // Trusted: both hear the next note, each in its own way.
     await call('plugins.trust', { hash: docs.code!.hash })
     const trusted = await call<Plugin[]>('plugins.trust', { hash: sheet.code!.hash })
     await harness.hooks.reload()
     await saveFact('Line length', 'Wrap at 100.')
     await harness.hooks.settled()
-    expect(told(one)).toEqual([{ type: 'memory.saved', id: expect.any(String), title: 'Line length', body: 'Wrap at 100.', actor: 'user' }])
+    expect(told(one)).toEqual([{ type: 'wiki.page.saved', id: expect.any(String), title: 'Line length', body: 'Wrap at 100.', actor: 'user' }])
     expect(told(two)).toEqual(told(one))
     expect(trusted.find((plugin) => plugin.id === docs.id)!.contributions[0]).toMatchObject({ state: 'on', problem: null })
     const described = (await call<Plugin[]>('plugins.list')).find((plugin) => plugin.id === sheet.id)!.contributions[0]
-    expect(described.description).toBe('Runs in the background after: memory.saved, history.run.ended.')
+    expect(described.description).toBe('Runs in the background after: wiki.page.saved, history.run.ended.')
 
     // Switched off for everyone again, it stops hearing; the other keeps going.
     await call('plugins.detach', { id: docs.id })
@@ -144,20 +138,20 @@ describe('hooks a plugin gives the harness', () => {
     const bus = new Bus()
     const base = temp()
     const out = join(base, 'ok.log')
-    writeFile(join(base, 'bad.mjs'), `export default function (harness) { harness.on('memory.saved', async () => { throw new Error('the document is gone') }) }\n`)
-    writeFile(join(base, 'slow.mjs'), `export default function (harness) { harness.on('memory.saved', () => new Promise(() => {})) }\n`)
-    writeFile(join(base, 'good.mjs'), recorder(out, ['memory.saved']))
+    writeFile(join(base, 'bad.mjs'), `export default function (harness) { harness.on('wiki.page.saved', async () => { throw new Error('the document is gone') }) }\n`)
+    writeFile(join(base, 'slow.mjs'), `export default function (harness) { harness.on('wiki.page.saved', () => new Promise(() => {})) }\n`)
+    writeFile(join(base, 'good.mjs'), recorder(out, ['wiki.page.saved']))
     writeFile(join(base, 'broken.mjs'), `export const nothing = 1\n`)
     writeFile(join(base, 'unknown.mjs'), `export default function (harness) { harness.on('memory.deleted', () => {}) }\n`)
     const hooks = new Hooks({ stateDir: base, bus, timeoutMs: 40, importFile, call: async () => undefined, wanted: async () => ['bad', 'slow', 'good', 'broken', 'unknown'].map((name) => ({ path: join(base, `${name}.mjs`), hash: 'h1' })) })
     await hooks.reload()
-    const event: HookEvent = { type: 'memory.saved', id: 'f1', path: '/w/facts/f1.md', title: 'Fact', body: 'Body', text: 'Body', actor: 'user', reason: 'Created', at: '2026-10-13T00:00:00.000Z' }
+    const event: HookEvent = { type: 'wiki.page.saved', id: 'f1', path: '/w/library/f1.md', title: 'Fact', body: 'Body', text: 'Body', actor: 'user', reason: 'Created', at: '2026-10-13T00:00:00.000Z' }
     hooks.emit(event)
     await hooks.settled()
     // The good hook ran although two before it failed.
     expect(told(out)).toHaveLength(1)
     const status = hooks.status()
-    expect(status[join(base, 'bad.mjs')]).toMatchObject({ events: ['memory.saved'], lastError: 'memory.saved: the document is gone' })
+    expect(status[join(base, 'bad.mjs')]).toMatchObject({ events: ['wiki.page.saved'], lastError: 'wiki.page.saved: the document is gone' })
     expect(status[join(base, 'slow.mjs')].lastError).toMatch(/took longer than/)
     expect(status[join(base, 'good.mjs')]).toMatchObject({ lastError: null, lastRunAt: expect.any(String) })
     expect(status[join(base, 'broken.mjs')].lastError).toBe('It could not be loaded: It must export a default function.')
@@ -204,47 +198,3 @@ describe('hooks a plugin gives the harness', () => {
     await expect(harness.apps.callUnattended('Nope', 'read_record', {})).rejects.toThrow('no connected app called "Nope"')
   })
 })
-
-describe('a plugin an agent proposes', () => {
-  const proposal = { name: 'Memory to Docs', description: 'Adds every saved memory to the team document.', extends: ['memory'], reason: 'You asked for a copy in Docs.', files: [{ path: 'hooks.mjs', content: "export default function (harness) { harness.on('memory.saved', async () => {}) }\n" }, { path: 'skills/docs/SKILL.md', content: '---\nname: docs\ndescription: How the copy works.\n---\nSteps.\n' }] }
-
-  it('waits in the Inbox, and is saved switched off and untrusted only when the person accepts it', async () => {
-    const { harness, root, call } = setup()
-    const tool = pluginProposeTool(harness.env, { agentId: 'a1', agentName: 'Helper', actor: 'Chat' })
-    expect(await tool.execute(proposal)).toBe('The plugin "memory-to-docs" is waiting in the Inbox. It is saved only if the user accepts it, and it does nothing until they switch it on and trust its code.')
-    expect(existsSync(join(root, 'plugins'))).toBe(false)
-    const [item] = listInbox(wikiDir(root))
-    expect(item).toMatchObject({ kind: 'proposed', title: 'Proposed plugin "Memory to Docs"' })
-    expect(item.detail).toContain('- hooks.mjs (')
-    expect(item.detail).toContain('It brings code.')
-    expect(item.detail).toContain('From Helper (Chat).')
-
-    expect(await call<string>('wiki.inboxAccept', { itemId: item.id })).toBe('Saved the plugin "memory-to-docs", switched off. Its code does not run until you switch it on and trust it.')
-    expect(readdirSync(join(root, 'plugins'))).toEqual(['memory-to-docs'])
-    expect(JSON.parse(readFileSync(join(root, 'plugins/memory-to-docs/package.json'), 'utf8'))).toMatchObject({ name: 'memory-to-docs', description: proposal.description, harness: { extends: ['memory'], hooks: './hooks.mjs' } })
-    const plugin = (await call<Plugin[]>('plugins.list')).find((candidate) => candidate.id === 'package:memory-to-docs')!
-    expect(plugin).toMatchObject({ extends: ['memory'], trust: 'untrusted', install: { kind: 'folder' }, attachment: { global: false } })
-    expect(plugin.contributions.map((entry) => [entry.kind, entry.name, entry.state])).toEqual([['skill', 'docs', 'off'], ['code', 'hooks.mjs', 'off']])
-    await harness.hooks.reload()
-    expect(Object.keys(harness.hooks.status())).toEqual([])
-    // Accepting the same proposal again would overwrite a folder, so it is refused.
-    await tool.execute(proposal)
-    await expect(call('wiki.inboxAccept', { itemId: listInbox(wikiDir(root))[0].id })).rejects.toThrow('already a plugin folder')
-  })
-
-  it('refuses what could not be a safe plugin, and says why', () => {
-    const bad = (change: Partial<typeof proposal>) => () => checkPluginProposal({ ...proposal, ...change })
-    expect(bad({ name: '  ' })).toThrow('short name')
-    expect(bad({ description: '' })).toThrow('one line')
-    expect(bad({ extends: ['approvals'] })).toThrow('"approvals" is none of them')
-    expect(bad({ files: [] })).toThrow('between 1 and 40 files')
-    expect(bad({ files: [{ path: '../outside.mjs', content: 'x' }] })).toThrow('not a path inside the plugin')
-    expect(bad({ files: [{ path: '/etc/hosts', content: 'x' }] })).toThrow('not a path inside the plugin')
-    expect(bad({ files: [{ path: '.env', content: 'x' }] })).toThrow('cannot be part of a plugin')
-    expect(bad({ files: [{ path: 'node_modules/x/index.js', content: 'x' }] })).toThrow('cannot be part of a plugin')
-    expect(bad({ files: [{ path: 'package.json', content: '{}' }] })).toThrow('Leave package.json out')
-    expect(bad({ files: [{ path: 'a.md', content: 'x' }, { path: 'A.md', content: 'y' }] })).toThrow('listed twice')
-    expect(bad({ files: [{ path: 'big.md', content: 'x'.repeat(300 * 1024) }] })).toThrow('larger than 256 KiB')
-    expect(checkPluginProposal({ ...proposal, files: [{ path: './skills/a/SKILL.md', content: 'x' }] })).toMatchObject({ slug: 'memory-to-docs', hooks: null, runsCode: false })
-  })
-})

package/src/plugins/hooks.ts

@@ -7,7 +7,7 @@
 // and what it throws is recorded and shown on its plugin. It reaches outside only through
 // `ctx.call`, which the harness limits to connected-app tools a person marked to run without asking.
 import { chmodSync } from 'node:fs'
-import { join, sep } from 'node:path'
+import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
 import type { Bus } from '../core/bus'
@@ -16,12 +16,12 @@ import { onChange, type Change } from '../core/changes'
 import * as frontmatter from '../core/frontmatter'
 import { now, readJsonOr, writeJson } from '../core/fs'
 
-export const HOOK_EVENTS = ['memory.saved', 'memory.block.changed', 'wiki.page.saved', 'history.run.ended'] as const
+export const HOOK_EVENTS = ['wiki.page.saved', 'history.run.ended'] as const
 export type HookEventType = (typeof HOOK_EVENTS)[number]
 
-/** A fact, a memory block, or a page, as it is after the change. */
+/** A Wiki note, as it is after the change. */
 export interface EntryEvent {
-  type: 'memory.saved' | 'memory.block.changed' | 'wiki.page.saved'
+  type: 'wiki.page.saved'
   id: string
   path: string
   title: string
@@ -58,7 +58,7 @@ export interface HookContext {
 
 type Handler = (event: HookEvent, context: HookContext) => unknown
 
-/** What a hooks file is given: `export default function (harness) { harness.on('memory.saved', …) }`. */
+/** What a hooks file is given: `export default function (harness) { harness.on('wiki.page.saved', …) }`. */
 export interface HookApi {
   on(event: HookEventType, handler: Handler): void
 }
@@ -100,8 +100,7 @@ interface Loaded extends HookTarget {
 
 /** Which event a written file is, from where it is in the Wiki. */
 export function entryEvent(change: Change): EntryEvent {
-  const within = change.path.startsWith(`${change.wiki}${sep}`) ? change.path.slice(change.wiki.length + 1).split(sep) : []
-  const type = within[0] === 'facts' ? 'memory.saved' : within[0] === 'blocks' ? 'memory.block.changed' : 'wiki.page.saved'
+  const type = 'wiki.page.saved' as const
   const parsed = frontmatter.parse(change.text)
   const front = (parsed?.front ?? {}) as Record<string, unknown>
   const title = typeof front.title === 'string' ? front.title : typeof front.label === 'string' ? front.label : change.id