@xingular/harness 0.0.0-stage → 0.1.1

package/src/plugins/api.ts

@@ -0,0 +1,181 @@
+// 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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,141 @@
+// 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

@@ -0,0 +1,82 @@
+// 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
+]