@xingular/harness 2.1.2 → 3.0.0

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

package/src/plugins/identity.ts

@@ -1,8 +1,9 @@
 // Which plugin a found file belongs to, and what it is called there. The list a person sees and
 // the choice of what loads both use this, so a switch on the page names exactly what stops loading.
+import { readFileSync } from 'node:fs'
 import { basename, dirname } from 'node:path'
 
-import * as registry from '../skills/registry'
+import * as frontmatter from '../core/frontmatter'
 import { BUILTIN_PREFIX, type Found } from './discover'
 import { packageManifest } from './manifest'
 import type { ContributionKind } from './types'
@@ -24,7 +25,7 @@ export function describeFound(item: Found): { name: string; description: string
   const file = basename(item.path)
   if (item.kind === 'extension') return { name: file.startsWith('index.') ? basename(dirname(item.path)) : file, description: null }
   if (item.kind === 'context' || item.kind === 'theme' || item.kind === 'hook') return { name: file, description: null }
-  const described = registry.describeFile(item.path)
+  const described = describeFile(item.path)
   return { name: described?.name ?? file, description: described?.description ?? '' }
 }
 
@@ -35,3 +36,16 @@ export function foundIds(item: Found): [string, string] {
   const pluginId = pluginIdOf(item)
   return [contributionId(pluginId, FOUND_KINDS[item.kind], describeFound(item).name), pluginId]
 }
+
+/** A Markdown file's `name` and `description` frontmatter; a `SKILL.md` is named after its folder. */
+export function describeFile(path: string): { name: string; description: string } | null {
+  let text: string
+  try {
+    text = readFileSync(path, 'utf8')
+  } catch {
+    return null
+  }
+  const front = frontmatter.parse(text)?.front ?? {}
+  const fallback = basename(path) === 'SKILL.md' ? basename(dirname(path)) : basename(path).replace(/\.md$/, '')
+  return { name: typeof front.name === 'string' && front.name.trim() ? front.name.trim() : fallback, description: typeof front.description === 'string' ? front.description.trim() : '' }
+}

package/src/plugins/install.test.ts

@@ -83,7 +83,7 @@ describe('installing a package', () => {
   it('refuses a folder that is not there, and a plugin that was not installed', async () => {
     const { base, call } = setup()
     await expect(call('plugins.install', { source: join(base, 'missing') })).rejects.toThrow('does not exist')
-    await expect(call('plugins.remove', { pluginId: 'memory' })).rejects.toThrow('was not installed as a package')
+    await expect(call('plugins.remove', { pluginId: 'wiki' })).rejects.toThrow('was not installed as a package')
     await expect(call('plugins.update', { pluginId: 'nope' })).rejects.toThrow()
   })
 

package/src/plugins/install.ts

@@ -10,6 +10,7 @@ import { ensureSharedDir } from '../accounts/env'
 import { invalid, notFound } from '../core/errors'
 import { now } from '../core/fs'
 import type { Harness } from '../harness'
+import { loadPi } from '../pi/runtime'
 import { ensureAdopted, list, type PluginScope } from './api'
 import * as attachments from './attachments'
 import { withoutInstallScripts } from './discover'
@@ -26,7 +27,7 @@ export function normalizeSource(input: string): string {
 }
 
 async function manager(harness: Harness) {
-  const pi = await import('@earendil-works/pi-coding-agent')
+  const pi = await loadPi()
   // The shared folder is where `settings.json` really is; an account's own is a link to it.
   const agentDir = ensureSharedDir(harness.accounts.dir)
   const settings = pi.SettingsManager.create(harness.stateDir, agentDir)

package/src/plugins/inventory.ts

@@ -7,13 +7,12 @@ import type { HarnessEnv } from '../core/env'
 import { charCount } from '../core/text'
 import { allowed } from '../mcp/connections'
 import type { Connection } from '../mcp/types'
-import type { CallerContext } from '../memory/caller'
+import type { CallerContext } from '../core/caller'
 import { BUILT_IN_DYNAMIC, compile, toolGroups, type Launch } from '../prompt/compile'
-import * as registry from '../skills/registry'
+import type { Materialised } from '../tree/materialise'
 import { ASK_USER } from '../tools/askUser'
-import { PLUGIN_PROPOSE } from '../tools/pluginPropose'
-import { WIKI_TOOL_NAMES } from '../tools/definitions'
-import { INCLUDED_PLUGIN, YOURS_PLUGIN } from './builtin'
+import { DEFAULT_TOOL_NAMES } from '../tools/definitions'
+import { HARNESS_TREE_PLUGIN } from './builtin'
 import type { Contribution, Inventory, InventoryItem, Plugin, PluginDescriptor } from './types'
 
 export interface InventoryInput {
@@ -28,6 +27,8 @@ export interface InventoryInput {
   plugins: readonly Plugin[]
   descriptors: readonly PluginDescriptor[]
   saved: readonly Connection[]
+  /** The harness tree the caller runs, when it has one. */
+  tree?: Materialised | null
 }
 
 const size = (path: string | null): number | null => {
@@ -47,10 +48,8 @@ export function inventory(input: InventoryInput): Inventory {
     items.push({ pluginId, contributionId: null, kind, name, delivery, chars, cut: false, ...rest })
   }
 
-  const pack = compile(env, context, launch)
+  const pack = compile(env, context, launch, input.tree ?? null)
   const dynamic = new Set([...BUILT_IN_DYNAMIC.map((entry) => entry.id), ...(launch.sections ?? []).filter((section) => section.dynamic).map((section) => section.id)])
-  const active = registry.enabledFor(env.root, context.projectId ?? null, context.agentId ?? null)
-  const owner = (entry: registry.RegistryItem): string => (entry.builtin ? INCLUDED_PLUGIN.id : YOURS_PLUGIN.id)
   let systemChars = 0
   let contextChars = 0
 
@@ -68,26 +67,28 @@ export function inventory(input: InventoryInput): Inventory {
       }
       continue
     }
-    if (section.id === 'rules') {
-      for (const rule of active.filter((entry) => entry.kind === 'rules')) {
-        item(owner(rule), 'instruction', rule.name, delivery, charCount(`### ${rule.name} (${rule.id})\n\n${registry.itemBody(rule).trim()}`), { contributionId: `${owner(rule)}/${rule.id}`, cut: section.cut })
-      }
-      continue
-    }
     const plugin = descriptors.find((descriptor) => descriptor.sections?.some((declared) => declared.id === section.id))
     if (!plugin) unattributed.push({ kind: 'section', id: section.id })
     const name = plugin?.sections?.find((declared) => declared.id === section.id)?.name ?? section.title
     item(plugin?.id ?? '', 'instruction', name, delivery, section.size, { contributionId: plugin ? `${plugin.id}/instruction/${name}` : null, cut: section.cut })
   }
 
-  // A skill's or a prompt's own text is loaded only when it is used.
-  for (const entry of active.filter((candidate) => candidate.kind === 'skills' || candidate.kind === 'prompts')) {
-    item(owner(entry), entry.kind === 'skills' ? 'skill' : 'command', entry.name, 'on-demand', size(entry.path), { contributionId: `${owner(entry)}/${entry.id}` })
+  // The harness tree's skills are loaded only when used; its plugins run in the tool loop.
+  const tree = input.tree ?? null
+  if (tree) {
+    for (const rel of Object.keys(tree.tree).filter((path) => /^skills\/[^/]+\/SKILL\.md$/.test(path)).sort()) {
+      const name = rel.split('/')[1]!
+      item(HARNESS_TREE_PLUGIN.id, 'skill', name, 'on-demand', charCount(tree.tree[rel]!), { contributionId: `${HARNESS_TREE_PLUGIN.id}/skill/${name}` })
+    }
+    for (const path of tree.extensionPaths) {
+      const name = path.split('/').pop()!
+      item(HARNESS_TREE_PLUGIN.id, 'code', name, 'code', size(path), { contributionId: `${HARNESS_TREE_PLUGIN.id}/code/${name}` })
+    }
   }
 
   const names = [...input.tools]
   const extensionToolNames = new Set(input.plugins.filter((plugin) => ['project', 'package', 'shared', 'home'].includes(plugin.source)).flatMap((plugin) => plugin.contributions.filter((entry) => entry.kind === 'tool' && entry.state === 'on').map((entry) => entry.name)))
-  for (const name of [ASK_USER, PLUGIN_PROPOSE, ...WIKI_TOOL_NAMES, ...(input.connections ? ['mcp_list_tools', 'mcp_call_tool'] : [])]) if (!names.includes(name)) names.push(name)
+  for (const name of [ASK_USER, ...DEFAULT_TOOL_NAMES, ...(input.connections ? ['mcp_list_tools', 'mcp_call_tool'] : [])]) if (!names.includes(name)) names.push(name)
   for (const name of names) {
     if (extensionToolNames.has(name)) continue
     const plugin = descriptors.find((descriptor) => descriptor.tools?.some((tool) => tool.name === name))

package/src/plugins/plugins.ts

@@ -1,11 +1,10 @@
 // The harness decides what a Pi session loads. Pi's own discovery is switched off for sessions
 // and terminals; they receive the paths chosen here, so nothing reaches a model unlisted.
-import { chmodSync, readdirSync } from 'node:fs'
+import { chmodSync, lstatSync, readdirSync, rmSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
 
 import type { Bus } from '../core/bus'
 import { now, readJsonOr, writeJson } from '../core/fs'
-import { removeLinkedSkills } from '../skills/registry'
 import { attached, type Attachments, type AttachScope } from './attachments'
 import { piResolver, type Found, type ResolveInput, type Resolver } from './discover'
 import { foundIds, pluginIdOf } from './identity'
@@ -187,3 +186,40 @@ export class Plugins {
     this.options.bus.emit({ type: 'plugins.changed' })
   }
 }
+
+// Prefix of the entries an earlier version of the harness linked into a Pi agent folder's `skills/`.
+const LINKED_SKILL_PREFIX = 'agentx-'
+
+function isLinkedSkill(path: string): boolean {
+  let meta
+  try {
+    meta = lstatSync(path)
+  } catch {
+    return false
+  }
+  if (meta.isSymbolicLink()) return true
+  if (!meta.isDirectory()) return false
+  // A single-file skill was linked as `agentx-<name>/SKILL.md` inside a folder the harness made.
+  try {
+    const entries = readdirSync(path)
+    return entries.length === 1 && entries[0] === 'SKILL.md' && lstatSync(join(path, 'SKILL.md')).isSymbolicLink()
+  } catch {
+    return false
+  }
+}
+
+/** Removes the skill links an earlier version of the harness kept in a Pi agent folder's `skills/`. */
+export function removeLinkedSkills(skillsDir: string): void {
+  let names: string[]
+  try {
+    names = readdirSync(skillsDir)
+  } catch {
+    return
+  }
+  for (const name of names) {
+    const path = join(skillsDir, name)
+    if (!name.startsWith(LINKED_SKILL_PREFIX) || !isLinkedSkill(path)) continue
+    if (lstatSync(path).isSymbolicLink()) unlinkSync(path)
+    else rmSync(path, { recursive: true, force: true })
+  }
+}