@xingular/harness 0.1.7 → 1.0.0

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))
-}

package/src/plugins/builtin.ts

@@ -1,82 +0,0 @@
-// The harness's own parts, described as plugins. Each is a description of code that already
-// exists; none of it is loaded through Pi's extension system.
-import { CONNECTION_TOOLS, NATIVE_GROUP } from '../prompt/compile'
-import { ASK_USER } from '../tools/askUser'
-import { PLUGIN_PROPOSE } from '../tools/pluginPropose'
-import { MEMORY_TOOLS, RECALL_TOOLS, WIKI_TOOLS, type WikiToolDefinition } 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 }))
-
-/** Pi itself. Its command's built-in extensions are added to it as they are found. */
-export const PI_PLUGIN: PluginDescriptor = {
-  id: 'pi',
-  title: 'Pi',
-  description: 'The engine every session runs on: its base prompt, its file and shell tools, and the extensions built into its command.',
-  required: 'Pi runs every session.',
-  tools: NATIVE_GROUP.map((name) => ({ name })),
-  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',
-  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.' }
-  ],
-  tools: WIKI_TOOLS.filter((tool) => tool.name === 'skill_load').map((tool) => ({ name: tool.name, description: tool.label }))
-}
-
-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: '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']
-  },
-  {
-    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_'))),
-    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.' }
-    ],
-    toolGroups: ['Knowledge']
-  },
-  { id: 'history', title: 'History', description: 'Search over earlier conversations and runs.', required: 'Earlier runs are how an agent picks up where work stopped.', tools: tools(RECALL_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' }]
-  },
-  { 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',
-    title: 'Connected apps',
-    description: 'Outside services reached over MCP, behind two tools that list and call what is connected.',
-    required: 'Connected apps are reached only through it. Each app is switched on its own.',
-    manage: 'connections',
-    tools: CONNECTION_TOOLS.map((name) => ({ name })),
-    toolGroups: ['Connections']
-  },
-  YOURS_PLUGIN,
-  ...FIRST_PARTY_PLUGINS
-]