@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/memory/wikiIndex.test.ts

@@ -1,88 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { DatabaseSync } from 'node:sqlite'
-import { expect, test } from 'vitest'
-
-import { writeFile } from '../../tests/helpers'
-import { writeJson } from '../core/fs'
-import { all, closeIndex, dbPath, migrate, withIndex } from '../core/index'
-import { runRecordSchema, type RunRecord } from '../sessions/contracts'
-import { recordRun, runsSince, syncRuns } from '../sessions/runIndex'
-import { ensure, rebuild, search } from './wikiIndex'
-
-const temp = () => mkdtempSync(join(tmpdir(), 'harness-index-'))
-const page = (root: string, relative: string, text: string) => writeFile(join(root, 'wiki', relative), text)
-const record = (fields: Partial<RunRecord> & { id: string }): RunRecord => runRecordSchema.parse({ projectId: null, mode: 'chat', harness: 'pi', sessionType: 'structured', sessionId: 'agent-1', nativeSessionId: null, workingDirectory: null, worktreeId: null, goal: null, startedAt: new Date().toISOString(), endedAt: null, status: 'completed', ...fields })
-
-test('rebuild indexes the whole wiki and boosts the current project', () => {
-  const root = temp()
-  page(root, 'library/a.md', '---\nid: tauri\ntitle: Use Tauri for the desktop shell\ntype: decision\n---\n\nRust host and React renderer.\n')
-  page(root, 'projects/app/b.md', '---\nid: notes\ntitle: Meeting notes\ntype: summary\n---\n\nWe mentioned tauri once.\n')
-  page(root, 'facts/m.md', '---\nid: shell\ntitle: Shell choice\nkind: decision\n---\n\nTauri stays.\n')
-  expect(rebuild(root)).toBe(2)
-  const first = search(root, 'tauri', 10, null)
-  expect(first[0]).toBe('tauri')
-  expect(first).toHaveLength(3)
-  expect(search(root, 'rend', 10, null)).toEqual(['tauri'])
-  // The current project's namespace ranks higher but nothing else is hidden.
-  const boosted = search(root, 'tauri', 10, '/projects/app')
-  expect(boosted.indexOf('notes')).toBeLessThanOrEqual(first.indexOf('notes'))
-  expect(boosted).toHaveLength(3)
-  // Rebuilding from files after deleting the index gives the same results.
-  closeIndex(root)
-  rmSync(dbPath(root))
-  expect(ensure(root)).toBe(2)
-  expect(search(root, 'tauri', 10, null)).toEqual(first)
-  closeIndex(root)
-})
-
-test('runs are listed per account and agent and survive a rebuild', () => {
-  const root = temp()
-  const run = record({ id: 'run1', mode: 'code', harness: 'codex', sessionId: 's1', agentId: 'agent-7', accountId: 'acc1' })
-  writeJson(join(root, 'runs/run1/run.json'), run)
-  writeFileSync(join(root, 'runs/run1/events.jsonl'), '{"type":"usage.updated","payload":{"inputTokens":7,"outputTokens":3,"model":"gpt"}}\n')
-  recordRun(root, run)
-  expect(runsSince(root, { account: 'acc1' }, null)).toEqual(['run1'])
-  expect(runsSince(root, { agent: 'agent-7' }, null)).toEqual(['run1'])
-  rebuild(root)
-  expect(runsSince(root, { account: 'acc1' }, null)).toEqual(['run1'])
-  expect(runsSince(root, { agent: 'agent-7' }, null)).toEqual(['run1'])
-  expect(runsSince(root, { agent: 'agent-8' }, null)).toEqual([])
-  expect(withIndex(root, (database) => all<{ count: number }>(database, "SELECT COUNT(*) AS count FROM sqlite_master WHERE name = 'usage'")[0].count)).toBe(0)
-  closeIndex(root)
-})
-
-test('runs the index never saw are picked up from their files', () => {
-  const root = temp()
-  const run = (id: string, status: string) => record({ id, status, startedAt: `2026-10-01T10:00:0${id.length}.000Z`, accountId: 'acc1' })
-  // The index file exists with one run before the others are noticed, so `ensure` does not rebuild.
-  writeJson(join(root, 'runs/a/run.json'), run('a', 'running'))
-  recordRun(root, run('a', 'running'))
-  writeJson(join(root, 'runs/a/run.json'), run('a', 'completed'))
-  writeJson(join(root, 'runs/bb/run.json'), run('bb', 'completed'))
-
-  ensure(root)
-  expect(runsSince(root, { session: 'agent-1' }, null)).toEqual(['a', 'bb'])
-  expect(runsSince(root, { session: 'agent-1' }, '2026-10-01T10:00:02.000Z')).toEqual(['bb'])
-  // Chat runs from before the agent column count for the agent whose conversation they ran in.
-  expect(runsSince(root, { agent: 'agent-1' }, null)).toHaveLength(2)
-  expect(runsSince(root, { account: 'acc1' }, null)).toEqual(['a', 'bb'])
-  expect(runsSince(root, { account: 'other' }, null)).toEqual([])
-  expect(withIndex(root, (database) => all<{ status: string }>(database, "SELECT status FROM runs WHERE id = 'a'")[0].status)).toBe('completed')
-  // Nothing is rewritten once the tables match the files.
-  expect(syncRuns(root)).toBe(0)
-  closeIndex(root)
-})
-
-test('failed migration restores the backup', () => {
-  const path = join(temp(), 'index.sqlite')
-  const good = ["CREATE TABLE kept (value TEXT); INSERT INTO kept VALUES ('before');"]
-  migrate(path, good).close()
-  expect(() => migrate(path, [good[0], 'CREATE TABLE extra (value TEXT); THIS IS NOT SQL;'])).toThrow('Index migration 2 failed')
-  const database = new DatabaseSync(path)
-  expect((database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get() as { value: string }).value).toBe('1')
-  expect((database.prepare('SELECT value FROM kept').get() as { value: string }).value).toBe('before')
-  expect(() => database.prepare('SELECT COUNT(*) FROM extra').get()).toThrow()
-  database.close()
-})

package/src/memory/wikiIndex.ts

@@ -1,117 +0,0 @@
-// The Wiki's rows in the index: full-text entries, links, sources, and revisions, all derived
-// from the canonical files.
-import { existsSync } from 'node:fs'
-import type { DatabaseSync } from 'node:sqlite'
-
-import { logLine } from '../core/bus'
-import { all, dbPath, deleteIndex, ftsQuery, run, transaction, withIndex } from '../core/index'
-import { readAllRuns, syncRuns, upsertRun } from '../sessions/runIndex'
-import { scan } from './wiki'
-
-/** Replaces every Wiki row from canonical files. Returns the number of pages indexed. */
-export function indexWiki(database: DatabaseSync, root: string): number {
-  const { entries, sources } = scan(root)
-  transaction(database, () => {
-    for (const table of ['entries', 'entries_fts', 'links', 'sources', 'revisions']) database.exec(`DELETE FROM ${table}`)
-    for (const entry of entries) {
-      run(
-        database,
-        'INSERT OR REPLACE INTO entries (id, kind, title, type, path, namespace, file, updated_at, source_ids) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)',
-        entry.id,
-        entry.kind,
-        entry.title,
-        entry.entryType,
-        entry.path,
-        entry.namespace,
-        entry.file,
-        entry.updatedAt,
-        JSON.stringify(entry.sourceIds)
-      )
-      const sourceNames = entry.sourceIds.flatMap((id) => sources.find((source) => source.id === id)?.name ?? [])
-      run(
-        database,
-        'INSERT INTO entries_fts (id, kind, namespace, title, body, links, sources) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)',
-        entry.id,
-        entry.kind,
-        entry.namespace,
-        entry.title,
-        entry.body,
-        entry.links.map(([to]) => to).join(' '),
-        `${entry.path.replaceAll('/', ' ')} ${entry.sourceIds.join(' ')} ${sourceNames.join(' ')}`
-      )
-      for (const [to, type] of entry.links) run(database, 'INSERT INTO links (from_id, to_id, type) VALUES (?1, ?2, ?3)', entry.id, to, type)
-      for (const [id, createdAt, actor] of entry.revisions) run(database, 'INSERT OR REPLACE INTO revisions (entry_id, id, created_at, actor) VALUES (?1, ?2, ?3, ?4)', entry.id, id, createdAt, actor)
-    }
-    for (const source of sources) run(database, 'INSERT OR REPLACE INTO sources (id, name, imported_at, version) VALUES (?1, ?2, ?3, ?4)', source.id, source.name, source.importedAt, source.version)
-  })
-  return entries.filter((entry) => entry.kind === 'page').length
-}
-
-export function reindexWiki(root: string): number {
-  return withIndex(root, (database) => indexWiki(database, root))
-}
-
-/** `reindexWiki` for callers that must not fail because the index is unavailable. */
-export function reindexQuietly(root: string): void {
-  try {
-    reindexWiki(root)
-  } catch (error) {
-    logLine(`[index] reindex failed: ${error instanceof Error ? error.message : String(error)}`)
-  }
-}
-
-/** Deletes the index and rebuilds it from canonical files. Returns pages indexed. */
-export function rebuild(root: string): number {
-  deleteIndex(root)
-  return withIndex(root, (database) => {
-    const pages = indexWiki(database, root)
-    const records = readAllRuns(root)
-    transaction(database, () => records.forEach((record) => upsertRun(database, record)))
-    return pages
-  })
-}
-
-/**
- * Builds the index when it is missing and otherwise refreshes the Wiki rows, which also
- * catches edits made while nothing was running. `after` runs last, whatever happened before it.
- */
-export function ensure(root: string, after?: () => void): number {
-  let pages: number
-  if (existsSync(dbPath(root))) {
-    pages = reindexWiki(root)
-    try {
-      syncRuns(root)
-    } catch (error) {
-      logLine(`[index] ${error instanceof Error ? error.message : String(error)}`)
-    }
-  } else {
-    pages = rebuild(root)
-  }
-  after?.()
-  return pages
-}
-
-/**
- * Ranked entry ids across the whole Wiki (best match first). Entries in `boostNamespace`
- * rank higher; nothing is filtered out by namespace here.
- */
-export function search(root: string, query: string, limit: number, boostNamespace: string | null): string[] {
-  const fts = ftsQuery(query)
-  if (!fts) return []
-  return withIndex(root, (database) =>
-    all<{ id: string }>(
-      database,
-      `SELECT id FROM entries_fts WHERE entries_fts MATCH ?1
-       ORDER BY bm25(entries_fts, 0, 0, 0, 10.0, 1.0, 2.0, 2.0) * (CASE WHEN ?2 IS NOT NULL AND namespace = ?2 THEN 1.5 ELSE 1.0 END)
-       LIMIT ?3`,
-      fts,
-      boostNamespace,
-      limit
-    ).map((row) => row.id)
-  )
-}
-
-/** (from id, link type) for every entry linking to `entryId`. */
-export function backlinks(root: string, entryId: string): [string, string][] {
-  return withIndex(root, (database) => all<{ from_id: string; type: string }>(database, 'SELECT from_id, type FROM links WHERE to_id = ?1 ORDER BY from_id', entryId).map((row) => [row.from_id, row.type]))
-}

package/src/plugins/api.ts

@@ -1,181 +0,0 @@
-// The plugin calls a host makes: the list, what reaches one caller, switching something on or
-// off for a scope, and the trust decision.
-import { join } from 'node:path'
-
-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 { Launch } from '../prompt/compile'
-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'
-import type { Inventory, Plugin } from './types'
-
-export interface PluginScope {
-  /** The working folder to list for. Without one, nothing a folder brings is listed. */
-  cwd?: string | null
-  /** The account whose Pi folder is searched. Defaults to the default account. */
-  accountId?: string | null
-  /** Whose list it is. With either, each state is what that agent or project gets. */
-  agentId?: string | null
-  projectId?: string | null
-}
-
-const callerOf = (scope: PluginScope): attachments.AttachScope => ({ agentId: scope.agentId ?? null, projectId: scope.projectId ?? null })
-
-/**
- * What Pi would load for this account and folder. Before the first account exists, the folder
- * every account shares stands in: packages and shared files are the same for all of them.
- * `null` only when the account that was named cannot be found.
- */
-export async function loadingFor(harness: Harness, scope: PluginScope): Promise<Loading | null> {
-  let agentDir: string
-  try {
-    agentDir = harness.accounts.context(harness.accounts.resolve(scope.accountId ?? null, null)).configDir
-  } catch {
-    if (scope.accountId) return null
-    agentDir = ensureSharedDir(harness.accounts.dir)
-  }
-  // Listing never installs anything. Without a working folder the state folder stands in, and
-  // what it "brings" is dropped by the catalogue.
-  return harness.plugins.loading({ cwd: scope.cwd || harness.stateDir, agentDir, caller: callerOf(scope) })
-}
-
-export async function list(harness: Harness, scope: PluginScope = {}): Promise<Plugin[]> {
-  return catalogue({
-    root: harness.env.root,
-    descriptors: harness.descriptors,
-    application: harness.applicationPlugins,
-    connections: harness.apps.connections.list(),
-    loading: await loadingFor(harness, scope),
-    cwd: scope.cwd || null,
-    sharedDir: sharedDir(harness.accounts.dir),
-    packagesDir: join(harness.env.root, 'plugins'),
-    registered: harness.plugins.registered(),
-    hooks: harness.hooks.status(),
-    attachments: attachments.load(harness.env.root),
-    caller: callerOf(scope)
-  })
-}
-
-export interface InventoryParams extends PluginScope {
-  context?: CallerContext
-  launch?: Launch
-  tools?: string[]
-  connections?: boolean
-}
-
-export async function inventoryFor(harness: Harness, params: InventoryParams): Promise<Inventory> {
-  return inventory({
-    env: harness.env,
-    context: params.context ?? {},
-    launch: params.launch ?? {},
-    tools: Array.isArray(params.tools) ? params.tools : [],
-    connections: params.connections !== false,
-    // 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()
-  })
-}
-
-/**
- * Trusts code a person was shown, if it is still that code: a working folder's own, or an
- * installed package's. The hash names which; a folder is needed only for the working folder's.
- */
-export async function trust(harness: Harness, scope: PluginScope & { hash: string }): Promise<Plugin[]> {
-  const loading = await loadingFor(harness, scope)
-  const project = scope.cwd && loading?.projectCode?.hash === scope.hash ? { code: loading.projectCode, folder: scope.cwd } : null
-  const packaged = Object.entries(loading?.packageCode ?? {}).find(([, code]) => code.hash === scope.hash)
-  const match = project ?? (packaged ? { code: packaged[1], folder: packaged[0] } : null)
-  if (!match) throw invalid('This code changed since it was shown. Review it again before trusting it.')
-  harness.plugins.trust.grant({ hash: match.code.hash, files: match.code.files }, match.folder)
-  return list(harness, scope)
-}
-
-export async function untrust(harness: Harness, scope: PluginScope & { hash: string }): Promise<Plugin[]> {
-  harness.plugins.trust.revoke(scope.hash)
-  return list(harness, scope)
-}
-
-export interface AttachParams extends PluginScope {
-  /** A plugin's id, or one contribution's. */
-  id: string
-  /** Who the switch is for. Neither id means everywhere. */
-  scope?: attachments.AttachScope | null
-}
-
-/**
- * Switches a plugin, or one thing it brings, on or off: everywhere, for one agent, or for one
- * project. A required part refuses and says why. Nothing here grants a permission: a tool that
- * is switched on still passes the gate.
- */
-export async function attach(harness: Harness, params: AttachParams, on: boolean): Promise<Plugin[]> {
-  const { root } = harness.env
-  const scope: attachments.AttachScope = { agentId: params.scope?.agentId || null, projectId: params.scope?.projectId || null }
-  if (scope.projectId) findProject(root, scope.projectId)
-  const plugins = await list(harness, params)
-  const plugin = plugins.find((candidate) => candidate.id === params.id || candidate.contributions.some((entry) => entry.id === params.id))
-  if (!plugin) throw notFound('Plugin')
-  const contribution = plugin.id === params.id ? null : plugin.contributions.find((entry) => entry.id === params.id)!
-  if (plugin.required && contribution?.kind !== 'connection') throw invalid(`${plugin.title} cannot be switched off. ${plugin.required}`)
-  if (plugin.source === 'application') throw invalid(`${plugin.title} is switched by the application that provides it.`)
-  if (!(contribution ?? plugin).attachment) throw invalid(contribution ? `${contribution.name} cannot be switched on its own.` : `${plugin.title} is switched one item at a time.`)
-
-  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.
-    const shipped = harness.descriptors.find((descriptor) => descriptor.id === plugin.id)?.switchable
-    const fallback = registryItem ? plugin.id === INCLUDED_PLUGIN.id : shipped ? shipped.on : true
-    const choices = attachments.load(root)
-    attachments.set(choices, ids, scope, on, fallback)
-    attachments.save(root, choices)
-  }
-  harness.bus.emit({ type: 'plugins.changed' })
-  return list(harness, params)
-}
-
-/** Saves the numbers a person set on a plugin. Each must be one of the plugin's settings and inside its range. */
-export async function configure(harness: Harness, params: PluginScope & { pluginId: string; settings: Record<string, unknown> }): Promise<Plugin[]> {
-  const descriptor = harness.descriptors.find((candidate) => candidate.id === params.pluginId)
-  if (!descriptor?.settings?.length) throw invalid('This plugin has no settings.')
-  const choices = attachments.load(harness.env.root)
-  const saved: Record<string, unknown> = { ...choices.settings[descriptor.id] }
-  for (const [key, value] of Object.entries(params.settings ?? {})) {
-    const setting = descriptor.settings.find((candidate) => candidate.key === key)
-    if (!setting) throw invalid(`${descriptor.title} has no setting called "${key}".`)
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < setting.min || value > setting.max) throw invalid(`${setting.label} must be a number from ${setting.min} to ${setting.max}.`)
-    saved[key] = Math.floor(value)
-  }
-  choices.settings[descriptor.id] = saved
-  attachments.save(harness.env.root, choices)
-  harness.bus.emit({ type: 'plugins.changed' })
-  return list(harness, params)
-}
-
-/**
- * Makes sure the packages that loaded before trust was asked per package were taken over, before
- * something new is written that must not be taken over with them.
- */
-export async function ensureAdopted(harness: Harness): Promise<void> {
-  if (harness.plugins.trust.adopted) return
-  await loadingFor(harness, {})
-  if (!harness.plugins.trust.adopted) harness.plugins.trust.adopt([])
-}
-
-/** Forgets what was switched for an agent that no longer exists. */
-export function forgetAgent(harness: Harness, agentId: string): void {
-  const choices = attachments.load(harness.env.root)
-  if (!choices.agents[agentId]) return
-  attachments.forget(choices, { agentId })
-  attachments.save(harness.env.root, choices)
-}

package/src/plugins/attachments.test.ts

@@ -1,84 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { writeJson } from '../core/fs'
-import { attached, decided, describe as where, load, save, set, type Attachments } from './attachments'
-
-const empty = (): Attachments => ({ version: 1, global: { on: [], off: [] }, agents: {}, projects: {}, settings: {} })
-
-describe('what is switched on, and for whom', () => {
-  it('follows the narrowest scope that says something', () => {
-    const choices = empty()
-    choices.global.on = ['skill']
-    choices.projects.p1 = { on: [], off: ['skill'] }
-    choices.agents.a1 = { on: ['skill'], off: [] }
-    choices.agents.a2 = { on: [], off: ['other'] }
-    const rows: [string, { agentId?: string; projectId?: string }, boolean | null][] = [
-      ['skill', {}, true],
-      ['skill', { projectId: 'p1' }, false],
-      ['skill', { projectId: 'p2' }, true],
-      // An agent's own choice holds in every project it works in.
-      ['skill', { agentId: 'a1', projectId: 'p1' }, true],
-      ['skill', { agentId: 'a2', projectId: 'p1' }, false],
-      ['other', { agentId: 'a2' }, false],
-      ['other', {}, null]
-    ]
-    for (const [id, caller, expected] of rows) expect([id, caller, decided(choices, [id], caller)]).toEqual([id, caller, expected])
-    // With no entry, a thing keeps its own default.
-    expect([attached(choices, ['other'], {}, true), attached(choices, ['other'], {}, false)]).toEqual([true, false])
-  })
-
-  it('lets one item of a plugin differ from the plugin', () => {
-    const choices = empty()
-    choices.global.off = ['package:kit']
-    choices.projects.p1 = { on: ['package:kit/skill/audit'], off: [] }
-    expect(attached(choices, ['package:kit/skill/audit', 'package:kit'], {}, true)).toBe(false)
-    expect(attached(choices, ['package:kit/skill/audit', 'package:kit'], { projectId: 'p1' }, true)).toBe(true)
-    expect(attached(choices, ['package:kit/code/guard.ts', 'package:kit'], { projectId: 'p1' }, true)).toBe(false)
-  })
-
-  it('keeps a choice only where it differs from the wider scope', () => {
-    const choices = empty()
-    set(choices, ['shared/code/a.ts', 'shared'], {}, false, true)
-    expect(choices.global).toEqual({ on: [], off: ['shared/code/a.ts'] })
-    // On again is the default, so nothing is stored.
-    set(choices, ['shared/code/a.ts', 'shared'], {}, true, true)
-    expect(choices.global).toEqual({ on: [], off: [] })
-
-    set(choices, ['skills/review'], { agentId: 'a1' }, true, false)
-    expect(choices.agents.a1).toEqual({ on: ['skills/review'], off: [] })
-    // Switching it on everywhere and then off for the agent keeps the agent's own choice.
-    set(choices, ['skills/review'], {}, true, false)
-    set(choices, ['skills/review'], { agentId: 'a1' }, false, false)
-    expect(choices.agents.a1).toEqual({ on: [], off: ['skills/review'] })
-    set(choices, ['skills/review'], { agentId: 'a1' }, true, false)
-    expect(choices.agents.a1).toEqual({ on: [], off: [] })
-
-    // A project's choice cannot stand in for an agent's, so the agent's is kept as said.
-    set(choices, ['skills/review'], { projectId: 'p1' }, false, false)
-    set(choices, ['skills/review'], { agentId: 'a1' }, true, false)
-    expect(choices.agents.a1.on).toEqual(['skills/review'])
-    expect(where(choices, 'skills/review', false)).toEqual({ global: true, on: { agentIds: ['a1'], projectIds: [] }, off: { agentIds: [], projectIds: ['p1'] } })
-  })
-
-  it("reads the registry's earlier file until the first change, and never rewrites it", () => {
-    const root = mkdtempSync(join(tmpdir(), 'attach-'))
-    const legacy = join(root, 'config/registry-enabled.json')
-    writeJson(legacy, { global: ['rules/tests'], personal: ['skills/old'], p1: ['skills/review'], builtinOff: ['rules/plain'] })
-    const before = readFileSync(legacy, 'utf8')
-    const choices = load(root)
-    expect(choices.global).toEqual({ on: ['rules/tests', 'skills/old'], off: ['rules/plain'] })
-    expect(choices.projects).toEqual({ p1: { on: ['skills/review'], off: [] } })
-    expect(existsSync(join(root, 'config/plugin-attachments.json'))).toBe(false)
-
-    set(choices, ['skills/review'], { agentId: 'a1' }, true, false)
-    save(root, choices)
-    expect(readFileSync(legacy, 'utf8')).toBe(before)
-    expect(load(root)).toEqual(choices)
-    // From here the earlier file is not read any more.
-    writeJson(legacy, { global: [] })
-    expect(load(root).global.on).toEqual(['rules/tests', 'skills/old'])
-  })
-})

package/src/plugins/attachments.ts

@@ -1,141 +0,0 @@
-// What is switched on, and for whom. One file in the data root holds every choice a person made
-// about a plugin or one of its contributions; one rule reads it: the narrowest scope that says
-// something wins, an agent before a project before everywhere. With no entry, the thing keeps
-// its own default (what loads today stays on; a person's registry item is off until switched on).
-import { join } from 'node:path'
-
-import { readJsonOr, writeJson } from '../core/fs'
-
-/** Who a choice applies to. Neither id means everywhere. */
-export interface AttachScope {
-  agentId?: string | null
-  projectId?: string | null
-}
-
-interface Entries {
-  on: string[]
-  off: string[]
-}
-
-export interface Attachments {
-  version: 1
-  global: Entries
-  agents: Record<string, Entries>
-  projects: Record<string, Entries>
-  /** Values a plugin reads, such as a limit. Keyed by plugin id. */
-  settings: Record<string, Record<string, unknown>>
-}
-
-/** Where one id is switched on and off, as data for a screen. */
-export interface Attachment {
-  /** On everywhere, unless a narrower scope says otherwise. */
-  global: boolean
-  on: { agentIds: string[]; projectIds: string[] }
-  off: { agentIds: string[]; projectIds: string[] }
-}
-
-const path = (root: string): string => join(root, 'config/plugin-attachments.json')
-const legacyPath = (root: string): string => join(root, 'config/registry-enabled.json')
-
-const strings = (value: unknown): string[] => (Array.isArray(value) ? value.filter((id): id is string => typeof id === 'string') : [])
-const entries = (value: unknown): Entries => {
-  const record = (value && typeof value === 'object' ? value : {}) as Record<string, unknown>
-  return { on: strings(record.on), off: strings(record.off) }
-}
-const scoped = (value: unknown): Record<string, Entries> => Object.fromEntries(Object.entries((value && typeof value === 'object' && !Array.isArray(value) ? value : {}) as Record<string, unknown>).map(([id, item]) => [id, entries(item)]))
-
-/**
- * The registry's earlier file: enabled ids keyed by project id, `global` (once `personal`) for
- * everyone, and `builtinOff` for built-in items a person switched off. It is read until the
- * first change is saved here, and never written again.
- */
-function fromLegacy(root: string): Attachments {
-  const legacy = readJsonOr<unknown>(legacyPath(root), {})
-  const map = (legacy && typeof legacy === 'object' && !Array.isArray(legacy) ? legacy : {}) as Record<string, unknown>
-  const projects: Record<string, Entries> = {}
-  for (const [key, ids] of Object.entries(map)) {
-    if (key === 'global' || key === 'personal' || key === 'builtinOff') continue
-    projects[key] = { on: strings(ids), off: [] }
-  }
-  return { version: 1, global: { on: [...new Set([...strings(map.global), ...strings(map.personal)])], off: strings(map.builtinOff) }, agents: {}, projects, settings: {} }
-}
-
-export function load(root: string): Attachments {
-  const stored = readJsonOr<Record<string, unknown> | null>(path(root), null)
-  if (!stored || typeof stored !== 'object' || stored.version !== 1) return fromLegacy(root)
-  const settings = (stored.settings && typeof stored.settings === 'object' && !Array.isArray(stored.settings) ? stored.settings : {}) as Attachments['settings']
-  return { version: 1, global: entries(stored.global), agents: scoped(stored.agents), projects: scoped(stored.projects), settings }
-}
-
-export function save(root: string, attachments: Attachments): void {
-  const kept = (map: Record<string, Entries>): Record<string, Entries> => Object.fromEntries(Object.entries(map).filter(([, item]) => item.on.length || item.off.length))
-  writeJson(path(root), { ...attachments, agents: kept(attachments.agents), projects: kept(attachments.projects) })
-}
-
-const said = (item: Entries | undefined, ids: readonly string[]): boolean | null => {
-  if (!item) return null
-  // The first id is the thing itself; the rest are what it belongs to.
-  for (const id of ids) {
-    if (item.off.includes(id)) return false
-    if (item.on.includes(id)) return true
-  }
-  return null
-}
-
-/** What the stored choices say for a caller, or `null` when none applies. `ids` is the thing, then what it belongs to. */
-export function decided(attachments: Attachments, ids: readonly string[], caller: AttachScope = {}): boolean | null {
-  return (caller.agentId ? said(attachments.agents[caller.agentId], ids) : null) ?? (caller.projectId ? said(attachments.projects[caller.projectId], ids) : null) ?? said(attachments.global, ids)
-}
-
-export function attached(attachments: Attachments, ids: readonly string[], caller: AttachScope, fallback: boolean): boolean {
-  return decided(attachments, ids, caller) ?? fallback
-}
-
-function entriesAt(attachments: Attachments, scope: AttachScope): Entries {
-  if (scope.agentId) return (attachments.agents[scope.agentId] ??= { on: [], off: [] })
-  if (scope.projectId) return (attachments.projects[scope.projectId] ??= { on: [], off: [] })
-  return attachments.global
-}
-
-/**
- * Switches one thing on or off for a scope. A choice that only repeats what the wider scopes
- * already say is not kept, so the thing follows them again when they change.
- */
-export function set(attachments: Attachments, ids: readonly string[], scope: AttachScope, on: boolean, fallback: boolean): void {
-  const [id] = ids
-  const target = entriesAt(attachments, scope.agentId ? { agentId: scope.agentId } : scope)
-  target.on = target.on.filter((item) => item !== id)
-  target.off = target.off.filter((item) => item !== id)
-  // An agent works in different projects, so a project's choice about this thing cannot stand in for the agent's.
-  const projectSays = !!scope.agentId && Object.values(attachments.projects).some((item) => said(item, ids) !== null)
-  const inherited = decided(attachments, ids, scope.agentId ? { agentId: scope.agentId } : scope) ?? fallback
-  if (on !== inherited || projectSays) (on ? target.on : target.off).push(id)
-}
-
-export function describe(attachments: Attachments, id: string, fallback: boolean): Attachment {
-  const where = (map: Record<string, Entries>, list: 'on' | 'off'): string[] => Object.entries(map).filter(([, item]) => item[list].includes(id)).map(([key]) => key)
-  return {
-    global: said(attachments.global, [id]) ?? fallback,
-    on: { agentIds: where(attachments.agents, 'on'), projectIds: where(attachments.projects, 'on') },
-    off: { agentIds: where(attachments.agents, 'off'), projectIds: where(attachments.projects, 'off') }
-  }
-}
-
-/** Forgets an agent's or a project's own choices, when it is deleted. */
-export function forget(attachments: Attachments, scope: AttachScope): void {
-  if (scope.agentId) delete attachments.agents[scope.agentId]
-  if (scope.projectId) delete attachments.projects[scope.projectId]
-}
-
-/** Removes one capability's choices without disturbing the other items in each scope. */
-export function forgetId(attachments: Attachments, id: string): void {
-  const forgetFrom = (item: Entries): void => {
-    item.on = item.on.filter((entry) => entry !== id)
-    item.off = item.off.filter((entry) => entry !== id)
-  }
-  forgetFrom(attachments.global)
-  for (const item of Object.values(attachments.agents)) forgetFrom(item)
-  for (const item of Object.values(attachments.projects)) forgetFrom(item)
-  attachments.agents = Object.fromEntries(Object.entries(attachments.agents).filter(([, item]) => item.on.length || item.off.length))
-  attachments.projects = Object.fromEntries(Object.entries(attachments.projects).filter(([, item]) => item.on.length || item.off.length))
-}