@xingular/harness 2.1.2 → 3.0.0

package/src/sessions/runner.ts

@@ -6,10 +6,10 @@ import type { CreateAgentSessionOptions, ModelRuntime, SettingsManager } from '@
 import { classifyMessage } from '../accounts/accounts'
 import type { AccountContext } from '../accounts/env'
 import { HarnessError } from '../core/errors'
+import { loadPi } from '../pi/runtime'
 import type { InlineExtension } from '../plugins/firstParty'
 import type { Loading, Registered } from '../plugins/plugins'
 import { CONTEXT_MESSAGE_TYPE, CONTEXT_SNAPSHOT_KEY, type ContextUpdate } from '../prompt/compile'
-import type { RegistryResources } from '../skills/registry'
 import type { ToolSpec } from '../tools/types'
 import { toolAttachmentRefsSchema, type UsageRequest } from './contracts'
 import { completedReasoningSummary, REASONING_SUMMARY_APIS, requestConciseReasoningSummary } from './reasoningSummaries'
@@ -40,7 +40,10 @@ export interface TurnParams {
   /** Unattended: no project extensions, no context files, settings held in memory. */
   automatic?: boolean
   account: AccountContext
-  resources?: RegistryResources
+  /** Skills and prompt templates to load natively: the harness tree's skills folder. */
+  resources?: { ids: string[]; skillPaths: string[]; promptPaths: string[] }
+  /** Pi extensions from the harness tree (c8) that may load: trusted code, or a probe the person allowed. */
+  treeExtensions?: string[]
   /**
    * What the harness found for this session to load, and where it reports what loaded. Pi's own
    * discovery is off whenever this is set, so only these paths and the registry's reach the session.
@@ -482,13 +485,15 @@ export async function runTurn(run: ActiveRun, session: PiSessionLike, params: Tu
  * Loads what a session may use besides its tools: Pi's context files, the registry's skills and
  * prompts, and what the harness found for it. `gate` is loaded after every extension on disk.
  */
-export async function loadResources(pi: typeof import('@earendil-works/pi-coding-agent'), params: Pick<TurnParams, 'cwd' | 'account' | 'automatic' | 'resources' | 'plugins' | 'system' | 'inline'>, gate: unknown, automaticSettings?: SettingsManager) {
+export async function loadResources(pi: typeof import('@earendil-works/pi-coding-agent'), params: Pick<TurnParams, 'cwd' | 'account' | 'automatic' | 'resources' | 'treeExtensions' | 'plugins' | 'system' | 'inline'>, gate: unknown, automaticSettings?: SettingsManager) {
   const loading = params.automatic ? null : ((await params.plugins?.loading()) ?? null)
   const resourceLoader = new pi.DefaultResourceLoader({
     ...(automaticSettings ? { settingsManager: automaticSettings, noExtensions: true, noContextFiles: true } : {}),
     // The loader gets empty settings and no discovery of its own: it loads the paths below and
     // nothing else. The session still reads the account's real settings for everything but resources.
-    ...(loading ? { settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, additionalExtensionPaths: loading.extensionPaths } : {}),
+    ...(loading ? { settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true } : {}),
+    // The harness tree's plugins load in every kind of run, unattended ones included.
+    additionalExtensionPaths: [...(loading?.extensionPaths ?? []), ...(params.treeExtensions ?? [])],
     cwd: params.cwd,
     agentDir: params.account.configDir,
     // Inline extensions load after the ones on disk, and the gate after all of them, so it sees
@@ -520,7 +525,7 @@ export function registeredBy(loader: { getExtensions(): { extensions: readonly u
 
 /** Opens a Pi session for one turn: the account's runtime, the compiled prompt, and the gated tools. */
 export const piSessionFactory: SessionFactory = async ({ params, allow, gate, tools, runtime: loadRuntime, extensions: host }) => {
-  const pi = await import('@earendil-works/pi-coding-agent')
+  const pi = await loadPi()
   const { Type } = await import('typebox')
   const runtime = await loadRuntime()
 

package/src/sessions/sessions.test.ts

@@ -194,7 +194,7 @@ describe('session turns on Pi', () => {
     await tick()
     const snapshot = events.find((event) => event.type === 'context.snapshot')!.payload as { systemPrompt: string; contextUpdate: string; tools: unknown[] }
     expect(snapshot.systemPrompt).toContain('## Context updates')
-    expect(snapshot.contextUpdate).toContain('<block label="persona"')
+    expect(snapshot.contextUpdate).toContain('[App context update')
     expect(snapshot.tools).toEqual([{ name: 'read', description: 'Read a file', parameters: { type: 'object', properties: { path: { type: 'string' } } } }])
   })
 
@@ -443,7 +443,7 @@ describe('session turns on Pi', () => {
     expect(loadRun(harness.env.root, 'run-3').status).toBe('interrupted')
   })
 
-  it('gives every session the memory, recall and Wiki tools, a question tool, and the application\'s tools in order', async () => {
+  it('gives every session the history, Wiki and skill tools, a question tool, and the application\'s tools in order', async () => {
     let received: Parameters<SessionFactory>[0] | null = null
     const { run, harness } = setup(async (input) => {
       received = input
@@ -452,13 +452,52 @@ describe('session turns on Pi', () => {
     harness.sessions.provide(() => [{ name: 'react', label: 'React', description: 'React', parameters: (Type) => Type.Object({}), execute: async () => 'ok' }])
     await run('run-5', { tools: { allow: ['react'] } })
     await tick()
-    expect(received!.allow.slice(0, 3)).toEqual(['react', 'ask_user', 'plugin_propose'])
-    expect(received!.allow).toEqual(expect.arrayContaining(['memory_append', 'history_search', 'wiki_search', 'wiki_read', 'wiki_propose']))
-    expect(received!.tools.map((tool) => tool.name)).toEqual(['memory_append', 'memory_replace', 'memory_rethink', 'history_search', 'history_read', 'wiki_search', 'wiki_read', 'wiki_list', 'skill_load', 'memory_facts', 'wiki_propose', 'trajectory_search', 'trajectory_read', 'ask_user', 'plugin_propose', 'spawn_subagent', 'wait_subagents', 'react'])
-    expect(await received!.tools[0].execute({ block: 'notes', text: 'Remember this.' })).toContain('Updated the notes block')
+    expect(received!.allow.slice(0, 2)).toEqual(['react', 'ask_user'])
+    expect(received!.allow).toEqual(expect.arrayContaining(['history_search', 'wiki_search', 'wiki_read', 'skill_load', 'trajectory_read']))
+    expect(received!.allow).not.toContain('wiki_write')
+    expect(received!.tools.map((tool) => tool.name)).toEqual(['history_search', 'history_read', 'trajectory_search', 'trajectory_read', 'wiki_search', 'wiki_read', 'wiki_list', 'wiki_write', 'skill_load', 'ask_user', 'spawn_subagent', 'wait_subagents', 'react'])
+    expect(await received!.tools.find((tool) => tool.name === 'skill_load')!.execute({})).toBe('You have no skills.')
     expect(received!.params.system).toContain('# Xingular Harness context')
   })
 
+  it('refuses, never asks, when a refinement run reaches a call that needs a person', async () => {
+    let check: ((name: string, input: unknown) => Promise<string | null>) | null = null
+    const { run, events } = setup(async (input) => {
+      check = input.gate.check
+      return fakeSession(async () => undefined, input.gate)
+    })
+    await run('probe-1', { run: { id: 'probe-1', sessionId: 'agent-1', trigger: 'probe' }, tools: { allow: ['read', 'bash'], gated: ['bash'] }, automatic: true })
+    await tick()
+    expect(await check!('bash', { command: 'rm -rf /' })).toMatch(/^Refused in a refinement run/)
+    expect(events.some((event) => event.type === 'approval.requested')).toBe(false)
+  })
+
+  it('runs on a pinned harness tree: its sections, its skills, and its version on the run', async () => {
+    let received: Parameters<SessionFactory>[0] | null = null
+    const { run, harness } = setup(async (input) => {
+      received = input
+      return fakeSession(async () => undefined, input.gate)
+    })
+    const { commit, head } = await import('../tree/store')
+    commit(harness.env.root, 'agent-1', {
+      'systemprompt.md': 'You review pull requests.\n',
+      'guardrails.md': '- When a diff is large, load the `triage` skill.\n',
+      'memory.md': '',
+      'tool_guidance.md': '',
+      'skills/triage/SKILL.md': '---\nname: triage\ndescription: a diff is large\n---\nSplit it by folder.\n',
+      'plugins/guard.ts': 'export default function (pi) {}\n'
+    }, { kind: 'seed' })
+    await run('run-tree', { harness: { scope: 'agent-1' } })
+    await tick()
+    const record = loadRun(harness.env.root, 'run-tree')
+    expect(record).toMatchObject({ harnessScope: 'agent-1', harnessVersion: head(harness.env.root, 'agent-1')!.fingerprint })
+    expect(received!.params.system).toContain('You review pull requests.')
+    expect(received!.params.resources!.skillPaths[0]).toMatch(/versions\/[0-9a-f]{16}\/tree\/skills$/)
+    // Plugin code waits for trust.
+    expect(received!.params.treeExtensions).toEqual([])
+    expect(await received!.tools.find((tool) => tool.name === 'skill_load')!.execute({ name: 'triage' })).toContain('Split it by folder.')
+  })
+
   it('refuses missing continuation history before creating a run or opening a session', async () => {
     let called = false
     const { run, events, harness } = setup(async ({ gate }) => {

package/src/sessions/sessions.ts

@@ -12,18 +12,18 @@ import { capabilitySet as parseCapabilitySet, freezeRun } from '../capabilities/
 import type { CapabilitySet } from '../capabilities/types'
 import { now, writeJson } from '../core/fs'
 import { takeChars } from '../core/text'
-import type { CallerContext } from '../memory/caller'
-import type { DispatchEnv } from '../memory/dispatch'
+import type { CallerContext } from '../core/caller'
+import type { DispatchEnv } from '../tools/dispatch'
 import type { Plugins } from '../plugins/plugins'
 import { sessionLaunch, type Launch } from '../prompt/compile'
 import * as attachments from '../plugins/attachments'
 import { FIRST_PARTY_PLUGINS, firstPartyExtensions, type InlineExtension } from '../plugins/firstParty'
-import * as registry from '../skills/registry'
+import { materialise, type HarnessChoice, type Materialised } from '../tree/materialise'
+import type { TreeTrust } from '../tree/trust'
 import { ASK_USER, askUserTool } from '../tools/askUser'
-import { PLUGIN_PROPOSE, pluginProposeTool } from '../tools/pluginPropose'
 import { subagentTools } from '../tools/spawnSubagent'
-import { WIKI_TOOL_NAMES } from '../tools/definitions'
-import { memoryTools } from '../tools/memoryTools'
+import { DEFAULT_TOOL_NAMES } from '../tools/definitions'
+import { harnessTools } from '../tools/harnessTools'
 import type { ToolProvider, ToolSession, ToolSpec } from '../tools/types'
 import type { RunRecord } from './contracts'
 import { SPAWN_SUBAGENT, WAIT_SUBAGENTS, subagentDepth, subagentHistory, subagentNesting, type SubagentInput, type SubagentOptions } from './subagents'
@@ -58,8 +58,13 @@ export interface SessionRunInput {
   preamble?: string | null
   /** Unattended: no project extensions, no context files, nothing may ask a person. */
   automatic?: boolean
-  /** Who the session works as, for memory and the prompt. */
+  /** Who the session works as, for history, the Wiki and the prompt. */
   caller: CallerContext
+  /**
+   * The harness tree the session runs: a scope's head (or a version of it), or a tree on disk.
+   * Its version is pinned for the whole run and recorded on it.
+   */
+  harness?: HarnessChoice | null
   /** What the application adds to the prompt, and which tools it describes. */
   launch?: Launch
   /** The tools switched on, in the order the model sees them, and those that ask before each call. */
@@ -74,6 +79,8 @@ export interface SessionRunInput {
   subagents?: SubagentOptions | null
   /** Ask the application's tool providers for tools (the default). False runs with the harness's own tools only. */
   providers?: boolean
+  /** Give the session the harness's own tools: History, the Wiki, skills, and asking the user (the default). */
+  harnessTools?: boolean
   /**
    * Plan mode: the run may only read, search, recall and ask, and is told to end with a
    * `<proposed_plan>` block. Other calls are refused at the gate; the tool list is unchanged.
@@ -99,6 +106,8 @@ export interface SessionsOptions {
   /** Resolves the caller's capability set from the harness's stores. */
   resolveCapabilities?: (caller: CallerContext, tools: readonly string[], cwd: string) => Promise<CapabilitySet>
   factory?: SessionFactory
+  /** Which plugin code in harness trees a person trusted. */
+  trust?: TreeTrust | null
 }
 
 /** The harness's own plugins a person switched on for this caller, with the numbers they set. */
@@ -142,6 +151,8 @@ export class Sessions {
           return error instanceof Error ? error.message : 'Tool unavailable in the app settings.'
         }
         if (scope.allowed && !scope.humanOnly && (scope.automatic || !gated.has(tool))) return null
+        // Refinement runs have nobody to ask: what would need a person is refused, never queued.
+        if (call.run.trigger === 'probe' || call.run.trigger === 'improver') return scope.reason ? `Refused in a refinement run: ${scope.reason}` : 'Refused in a refinement run: this call needs a person to approve it.'
         // A call outside the scope is approved one at a time; a gated tool may be remembered, unless only a person may decide it.
         const decision = await run.requestApproval({
           target: tool,
@@ -178,15 +189,13 @@ export class Sessions {
     const account = this.options.accounts.resolve(input.accountId, input.poolId)
     const context = this.options.accounts.context(account)
     const runId = input.run.id
-    const caller: CallerContext = { ...input.caller, maintenanceJobIds: input.caller.maintenanceJobIds?.slice(), runId, sessionId: input.caller.sessionId ?? input.run.sessionId }
+    const caller: CallerContext = { ...input.caller, runId, sessionId: input.caller.sessionId ?? input.run.sessionId }
     const broker = input.connections ? this.options.broker : null
     const depth = input.depth ?? 0
     const canSpawn = input.subagents !== null && (!input.automatic || input.subagents !== undefined) && subagentNesting(root, input.run) < subagentDepth(input.subagents ?? undefined)
     const requestedTools = [...new Set([
       ...input.tools.allow.filter((name) => name !== SPAWN_SUBAGENT && name !== WAIT_SUBAGENTS),
-      ASK_USER,
-      ...(input.automatic ? [] : [PLUGIN_PROPOSE]),
-      ...WIKI_TOOL_NAMES,
+      ...(input.harnessTools === false ? [] : [ASK_USER, ...DEFAULT_TOOL_NAMES]),
       ...(broker?.toolNames ?? []),
       ...(canSpawn ? [SPAWN_SUBAGENT, WAIT_SUBAGENTS] : [])
     ])]
@@ -202,6 +211,16 @@ export class Sessions {
     }
     freezeRun(root, runId, caller, capabilities)
 
+    // The harness is resolved once and pinned: a child run or a later turn of this run uses the
+    // same files even if the head moves meanwhile.
+    let tree: Materialised | null = null
+    if (input.harness) {
+      const scope = input.harness.scope ?? null
+      const trust = this.options.trust ?? null
+      tree = materialise(root, input.harness, { trust, probeCode: input.run.trigger === 'probe' && Boolean(scope && trust?.probeCode(scope)), subagents: capabilities.tools.includes(SPAWN_SUBAGENT) })
+      input.harness = { dir: tree.dir, scope: tree.scope }
+    }
+
     saveRun(root, {
       resumedFromRunId: input.run.resumedFromRunId ?? null,
       parentRunId: input.run.parentRunId ?? null,
@@ -225,7 +244,9 @@ export class Sessions {
       handoffId: input.run.handoffId ?? null,
       accountId: account.id,
       agentId: input.run.agentId ?? caller.agentId ?? null,
-      trigger: input.run.trigger ?? null
+      trigger: input.run.trigger ?? null,
+      harnessScope: tree?.scope ?? null,
+      harnessVersion: tree?.fingerprint ?? null
     })
 
     // What the session is, kept with the run so later consolidation knows which memory it had.
@@ -254,7 +275,7 @@ export class Sessions {
         connectionTools: (launch.connectionTools ?? []).filter((name) => capabilities.tools.includes(name)),
         toolGroups: launch.toolGroups?.map((group) => ({ ...group, tools: group.tools.filter((name) => capabilities.tools.includes(name)) })).filter((group) => group.tools.length > 0)
       }
-      ;({ system, update } = sessionLaunch(this.env, caller, effectiveLaunch, historyFile, capabilities.contributions))
+      ;({ system, update } = sessionLaunch(this.env, caller, effectiveLaunch, historyFile, tree))
     } catch (error) {
       fail(error)
       throw error
@@ -262,6 +283,9 @@ export class Sessions {
 
     const run = this.options.runs.start(input.run.sessionId, runId)
     if (run.finished) return { runId, nativeSessionId: null }
+    if (tree?.untrustedPlugins.length) {
+      run.emit('extension.notice', { kind: 'notify', level: 'warning', text: `Harness plugins not loaded until their code is trusted: ${tree.untrustedPlugins.join(', ')}.` })
+    }
     // What every session has, after the tools the caller switched on and in a fixed order.
     const allow = capabilities.tools
     const session: ToolSession = { run, caller, allow, depth, cwd: input.cwd, capabilities }
@@ -271,9 +295,7 @@ export class Sessions {
     try {
       const tools: ToolSpec[] = [
         ...(broker ? broker.tools(session, { readOnly: typeof input.connections === 'object' && input.connections.readOnly === true }) : []),
-        ...memoryTools(this.options.env, caller, capabilities.contributions),
-        askUserTool(run),
-        pluginProposeTool(this.options.env, caller),
+        ...(input.harnessTools === false ? [] : [...harnessTools(this.options.env, caller, { treeDir: tree?.dir ?? null }), askUserTool(run)]),
         ...subagentTools(this.options.subagents, runId).filter(tool => allow.includes(tool.name))
       ]
       if (input.providers !== false) for (const provider of this.providers) tools.push(...(await provider(session)))
@@ -294,7 +316,8 @@ export class Sessions {
         preamble: input.preamble ?? null,
         automatic: input.automatic,
         account: context,
-        resources: registry.resources(root, caller.projectId ?? null, caller.agentId ?? null, capabilities.contributions),
+        resources: { ids: [], skillPaths: tree?.skillPaths ?? [], promptPaths: [] },
+        treeExtensions: tree?.extensionPaths ?? [],
         inline: [...firstPartyFor(root, capabilities.contributions), runLineageJoin(root, runId), this.options.subagents.extension(runId)],
         ...(plugins ? { plugins: { loading: () => plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null }, contributions: capabilities.contributions }), loaded: (extensions) => plugins.loaded(extensions) } } : {}),
         system,

package/src/sessions/subagentService.test.ts

@@ -14,8 +14,10 @@ afterEach(async () => { for (const harness of open.splice(0)) await harness.clos
 
 function setup() {
   const finish = new Map<string, (text: string) => void>()
+  const systems = new Map<string, string>()
   const root = mkdtempSync(join(tmpdir(), 'native-subagents-'))
   const harness = createHarness({ dataRoot: join(root, 'data'), stateDir: join(root, 'state'), secrets: memorySecretStore(), sessionFactory: async ({ params }) => {
+    systems.set(params.runId, params.system)
     let emit: (event: any) => void = () => {}
     let done: () => void = () => {}
     return { sessionId: 'native-history', subscribe: (listener) => { emit = listener; return () => {} }, sendCustomMessage: async () => {},
@@ -29,10 +31,29 @@ function setup() {
     run: { id, sessionId: 'opaque-parent' }, caller: { agentId: 'caller', actor: 'Chat' }, cwd: root,
     sessionDir: join(root, 'history'), text: 'Parent', tools: { allow: ['read'] }, ...extra
   })
-  return { harness, finish, start }
+  return { harness, finish, start, systems }
 }
 const empty = () => ({ owners: [], receipts: [] })
 
+describe('subagents a harness defines (c5)', () => {
+  it('starts one by name with its own instructions instead of the parent\'s, and refuses a name the harness lacks', async () => {
+    const { harness, start, systems } = setup()
+    const { commit } = await import('../tree/store')
+    commit(harness.env.root, 'caller', { 'systemprompt.md': 'You coordinate releases.\n', 'guardrails.md': '', 'memory.md': '', 'tool_guidance.md': '', 'sub_agents/reader/AGENT.md': '---\ndescription: reads long logs and answers briefly\n---\nRead the log and answer in three lines.\n' }, { kind: 'seed' })
+    await start('parent', { harness: { scope: 'caller' }, tools: { allow: ['read', 'spawn_subagent', 'wait_subagents'] } })
+    expect(systems.get('parent')).toContain('You coordinate releases.')
+    expect(systems.get('parent')).toContain('- reader — reads long logs and answers briefly')
+    const child = await harness.subagents.spawn({ parentRunId: 'parent', brief: 'Summarise build.log', agent: 'reader' })
+    expect(systems.get(child.runId)).toContain('Read the log and answer in three lines.')
+    expect(systems.get(child.runId)).not.toContain('You coordinate releases.')
+    // A plain child keeps the parent's harness, pinned to the same version.
+    const copy = await harness.subagents.spawn({ parentRunId: 'parent', brief: 'Check the tests' })
+    expect(systems.get(copy.runId)).toContain('You coordinate releases.')
+    expect(loadRun(harness.env.root, copy.runId).harnessVersion).toBe(loadRun(harness.env.root, 'parent').harnessVersion)
+    await expect(harness.subagents.spawn({ parentRunId: 'parent', brief: 'x', agent: 'writer' })).rejects.toThrow('There is no subagent named writer.')
+  })
+})
+
 describe('native subagent ownership and delivery', () => {
   it('spawns asynchronously, joins selected children, and rejects foreign handles', async () => {
     const { harness, finish, start } = setup()

package/src/sessions/subagentService.ts

@@ -13,6 +13,7 @@ import type { RunRegistry } from './registry'
 import type { Effort } from './runner'
 import type { SessionRunInput } from './sessions'
 import { isActiveStatus } from './contracts'
+import { subagentOf } from '../tree/materialise'
 import { findRun, loadRun, readEvents, recordedSubagents, recordSubagent, saveRun } from './runStore'
 import { SPAWN_SUBAGENT, SUBAGENT_RELATION, SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, subagentHistory, type SubagentInput, type SubagentReceipt, type SubagentResult, type SubagentSelection } from './subagents'
 
@@ -104,6 +105,17 @@ export class Subagents {
     if (outside.length) throw invalid(`A subagent cannot have tools you do not have: ${outside.join(', ')}.`)
     const tools = capabilities.tools.filter((name) => !request.tools || request.tools.includes(name))
     await until(parent.ready, parent.stopped.signal)
+    let harness = input.harness ?? null
+    let launch = input.launch
+    if (request.agent !== undefined) {
+      if (typeof request.agent !== 'string' || !request.agent.trim()) throw invalid('agent must be the name of one of your subagents.')
+      const dir = harness && 'dir' in harness ? harness.dir : null
+      const definition = dir ? subagentOf(dir, request.agent.trim()) : null
+      if (!definition) throw invalid(`There is no subagent named ${request.agent.trim()}.`)
+      // A named subagent works from its own definition, not from the parent's instructions.
+      harness = null
+      launch = { ...(input.launch ?? {}), sections: [...(input.launch?.sections ?? []).filter((section) => section.id !== 'subagent'), { id: 'subagent', title: `Your role: ${definition.name}`, body: definition.instructions || definition.description, budget: 16_000, order: 22 }] }
+    }
     const runId = randomUUID()
     const sessionId = randomUUID()
     recordSubagent(this.env.root, request.parentRunId, runId)
@@ -114,7 +126,8 @@ export class Subagents {
       text: brief, images: undefined, requiresImageInput: false, preamble: null,
       caller: { ...input.caller, runId: undefined, sessionId },
       tools: { allow: tools, gated: (input.tools.gated ?? []).filter((name) => tools.includes(name)) },
-      capabilities: { ...capabilities, tools }, depth: (input.depth ?? 0) + 1
+      capabilities: { ...capabilities, tools }, depth: (input.depth ?? 0) + 1,
+      harness, launch
     }
     const started = this.launch(child).catch((error) => {
       if (!findRun(this.env.root, runId)) {

package/src/sessions/subagents.ts

@@ -24,6 +24,8 @@ export interface SubagentInput {
   brief: string
   tools?: string[]
   wait?: boolean
+  /** One of the parent harness's subagents (c5) by name; its instructions frame the child. */
+  agent?: string
 }
 
 export interface SubagentSelection {

package/src/terminal/cli.ts

@@ -1,6 +1,6 @@
-// `xagent-wiki` and `xagent-mcp`: the harness's memory, Wiki, and connected apps as commands,
-// for a `pi` terminal session's shell. Each command maps onto one call to the session socket.
-import type { WikiCall } from '../tools/definitions'
+// `xagent-wiki` and `xagent-mcp`: the harness's notes, skills, history and connected apps as
+// commands, for a `pi` terminal session's shell. Each command maps onto one call to the session socket.
+import type { HarnessCall } from '../tools/definitions'
 import { connectionFromEnv, socketCall } from './client'
 
 export const WIKI_COMMAND = 'xagent-wiki'
@@ -8,22 +8,14 @@ export const APPS_COMMAND = 'xagent-mcp'
 
 export const USAGE = `Usage: ${WIKI_COMMAND} <command> [arguments]
 
-  entrypoint                         Your context pack: memory blocks, rules, skills, project map
-  search <query> [--kind K] [--namespace NS]
-                                     Search every namespace (K: page, fact, skill, rule, prompt)
-  read <id or path>                  Read one page, fact, skill, rule, or prompt
-  list [namespace] [--kind K]        List namespaces and pages, or all entries of a kind
-  skill [name]                       Load a skill, or list skills
-  facts [query] [--namespace NS]     Recall facts (also: memory)
+  search <query> [--project SLUG]    Search the Wiki's project notes
+  read <path>                        Read one note, e.g. projects/<slug>/decisions
+  list [project slug | library]      List notes
+  write <path> <text | ->            Save a note (when this session may write the Wiki)
+  skill [name]                       Load one of your skills, or list them
   history <query> [--scope all] [--since YYYY-MM-DD]
                                      Search earlier conversations and runs (also: recall)
   history-read <run id>              Read one earlier run (also: recall-read)
-  block append <label> <text>        Add to a memory block (user, project, or a shared block)
-  block replace <label> --old <text> --new <text>
-                                     Replace one exact passage in a memory block
-  block rethink <label> <text>       Rewrite a whole memory block
-  propose <json | ->                 Record knowledge, e.g. {"kind":"fact","title":"…","body":"…",
-                                     "type":"preference","sourceRefs":[{"kind":"run","ref":"current"}]}
 `
 
 export const APPS_USAGE = `Usage: ${APPS_COMMAND} <command>
@@ -33,15 +25,15 @@ export const APPS_USAGE = `Usage: ${APPS_COMMAND} <command>
                                      Use one of them
 `
 
-export type CliCommand = { kind: 'call'; call: WikiCall; params: Record<string, unknown> } | { kind: 'help' } | { kind: 'stdin-propose' }
+export type CliCommand = { kind: 'call'; call: HarnessCall; params: Record<string, unknown> } | { kind: 'help' } | { kind: 'stdin-write'; path: string }
 
 function options(args: string[]): { positional: string[]; flags: Record<string, string> } {
   const positional: string[] = []
   const flags: Record<string, string> = {}
   for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index]
+    const arg = args[index]!
     if (arg.startsWith('--') && index + 1 < args.length) {
-      flags[arg.slice(2)] = args[index + 1]
+      flags[arg.slice(2)] = args[index + 1]!
       index += 1
     } else {
       positional.push(arg)
@@ -55,21 +47,23 @@ export function parseCli(argv: string[]): CliCommand {
   const { positional, flags } = options(rest)
   const joined = positional.join(' ').trim()
   switch (command) {
-    case 'entrypoint':
-      return { kind: 'call', call: 'wiki.entrypoint', params: {} }
     case 'search':
       if (!joined) return { kind: 'help' }
-      return { kind: 'call', call: 'wiki.search', params: { query: joined, ...(flags.kind ? { kinds: [flags.kind] } : {}), ...(flags.namespace ? { namespace: flags.namespace } : {}) } }
+      return { kind: 'call', call: 'wiki.search', params: { query: joined, ...(flags.project ? { project: flags.project } : {}) } }
     case 'read':
       if (!joined) return { kind: 'help' }
-      return { kind: 'call', call: 'wiki.read', params: { id: joined } }
+      return { kind: 'call', call: 'wiki.read', params: { path: joined } }
     case 'list':
-      return { kind: 'call', call: 'wiki.list', params: { ...(joined ? { namespace: joined } : {}), ...(flags.kind ? { kind: flags.kind } : {}) } }
+      return { kind: 'call', call: 'wiki.list', params: joined ? { project: joined } : {} }
+    case 'write': {
+      const [path, ...words] = positional
+      if (!path) return { kind: 'help' }
+      if (words.join(' ').trim() === '-') return { kind: 'stdin-write', path }
+      if (!words.length) return { kind: 'help' }
+      return { kind: 'call', call: 'wiki.write', params: { path, text: words.join(' ') } }
+    }
     case 'skill':
-      return { kind: 'call', call: 'wiki.skill', params: joined ? { name: joined } : {} }
-    case 'facts':
-    case 'memory':
-      return { kind: 'call', call: 'wiki.memory', params: { ...(joined ? { query: joined } : {}), ...(flags.namespace ? { namespace: flags.namespace } : {}) } }
+      return { kind: 'call', call: 'skill.load', params: joined ? { name: joined } : {} }
     case 'history':
     case 'recall':
       if (!joined) return { kind: 'help' }
@@ -78,24 +72,6 @@ export function parseCli(argv: string[]): CliCommand {
     case 'recall-read':
       if (!joined) return { kind: 'help' }
       return { kind: 'call', call: 'recall.read', params: { run: joined } }
-    case 'block': {
-      const [action, label, ...words] = positional
-      const body = words.join(' ').trim()
-      if (action === 'append' && label && body) return { kind: 'call', call: 'memory.append', params: { block: label, text: body } }
-      if (action === 'rethink' && label && body) return { kind: 'call', call: 'memory.rethink', params: { block: label, body } }
-      if (action === 'replace' && label && flags.old !== undefined && flags.new !== undefined) return { kind: 'call', call: 'memory.replace', params: { block: label, old: flags.old, new: flags.new } }
-      return { kind: 'help' }
-    }
-    case 'propose': {
-      if (joined === '-') return { kind: 'stdin-propose' }
-      try {
-        const params = JSON.parse(joined) as unknown
-        if (params && typeof params === 'object' && !Array.isArray(params)) return { kind: 'call', call: 'wiki.propose', params: params as Record<string, unknown> }
-      } catch {
-        // Falls through to help.
-      }
-      return { kind: 'help' }
-    }
     default:
       return { kind: 'help' }
   }
@@ -119,8 +95,8 @@ export async function runWikiCli(argv: string[]): Promise<number> {
   try {
     const connection = connectionFromEnv()
     const result =
-      command.kind === 'stdin-propose'
-        ? await socketCall<string>(connection, 'wiki.propose', JSON.parse(await readStdin()) as Record<string, unknown>)
+      command.kind === 'stdin-write'
+        ? await socketCall<string>(connection, 'wiki.write', { path: command.path, text: await readStdin() })
         : await socketCall<string>(connection, command.call, command.params)
     process.stdout.write(`${typeof result === 'string' ? result : JSON.stringify(result)}\n`)
     return 0

package/src/terminal/pluginControl.test.ts

@@ -80,21 +80,20 @@ describe('plugin control from a terminal session', () => {
     const { key } = await socketCall<{ key: string }>(connection, 'control.claim')
     const call = <T>(method: string, params?: Record<string, unknown>) => socketCall<T>(connection, method, params ?? {}, 5_000, key)
     const rows = menuRows(await call<Plugin[]>('plugins.list'), 'p1')
-    expect(rows.map((row) => row.label)).toEqual(['● review-kit · code not trusted', '○ Run tests · instruction in Yours', '○ Budget guard · runs code', '○ Output trim · runs code'])
+    expect(rows.map((row) => row.label)).toEqual(['● review-kit · code not trusted', '○ Budget guard · runs code', '○ Output trim · runs code'])
     expect(rowActions(rows[0], 'p1')).toEqual(['Switch off for this project', 'Switch off everywhere', 'Trust its code', 'Back'])
     expect(rowActions(rows[1], null)).toEqual(['Switch on everywhere', 'Back'])
     // A part that ships with the harness needs no trust: it is the harness's own code.
-    expect(rowActions(rows[2], 'p1')).toEqual(['Switch on for this project', 'Switch on everywhere', 'Back'])
+    expect(rowActions(rows[1], 'p1')).toEqual(['Switch on for this project', 'Switch on everywhere', 'Back'])
 
-    // Declining the trust question leaves the code untrusted; then they trust it, switch a rule on, and leave.
-    const { ui, shown, said } = person(['● review-kit · code not trusted', 'Trust its code', false, '● review-kit · code not trusted', 'Trust its code', true, '○ Run tests · instruction in Yours', 'Switch on for this project', 'Done'])
+    // Declining the trust question leaves the code untrusted; then they trust it and leave.
+    const { ui, shown, said } = person(['● review-kit · code not trusted', 'Trust its code', false, '● review-kit · code not trusted', 'Trust its code', true, 'Done'])
     await runPluginsMenu(ui, call, 'p1')
     expect(shown.find((line) => line.startsWith('Trust this code?'))).toContain('extensions/guard.ts')
     expect(shown.find((line) => line.startsWith('Trust this code?'))).toContain('can do anything this app can')
     expect(said).toEqual(['Saved. It applies when this session restarts.'])
     const after = await call<Plugin[]>('plugins.list')
     expect(after.find((plugin) => plugin.id === 'package:review-kit')).toMatchObject({ trust: 'trusted' })
-    expect(after.flatMap((plugin) => plugin.contributions).find((entry) => entry.id === 'yours/rules/tests')).toMatchObject({ state: 'on', scope: 'App' })
     expect(harness.plugins.trust.list()).toHaveLength(1)
 
     // Leaving at once changes nothing and says nothing.
@@ -113,7 +112,7 @@ describe('the plugins command', () => {
     const last = (): string => lines.at(-1) ?? ''
 
     expect(await run(['list'])).toBe(0)
-    expect(last()).toMatch(/^memory\s+required\s+Memory$/m)
+    expect(last()).toMatch(/^harness\s+required\s+Harness$/m)
     expect(await run(['install', join(base, 'kit')])).toBe(0)
     expect(last()).toContain('Installed, switched off.')
     expect(last()).toContain('trust its code with "plugins trust <id>"')
@@ -134,8 +133,8 @@ describe('the plugins command', () => {
     expect(last()).toContain('Code (trusted)')
     expect(last()).toContain('● skill audit (package:review-kit/skill/audit)')
 
-    expect(await run(['detach', 'memory'])).toBe(1)
-    expect(last()).toContain('Memory cannot be switched off.')
+    expect(await run(['detach', 'harness'])).toBe(1)
+    expect(last()).toContain('Harness cannot be switched off.')
     expect(await run(['untrust', 'package:review-kit'])).toBe(0)
     expect(await run(['remove', 'package:review-kit'])).toBe(0)
     expect(await run(['show', 'package:review-kit'])).toBe(1)

package/src/terminal/socket.ts

@@ -13,7 +13,7 @@ import { log } from '../core/bus'
 import { HarnessError, toErrorShape } from '../core/errors'
 import { newId } from '../core/fs'
 import type { BrokerSession } from '../mcp/service'
-import type { CallerContext } from '../memory/caller'
+import type { CallerContext } from '../core/caller'
 
 /** What a token stands for. */
 export interface SocketGrant {
@@ -27,7 +27,7 @@ export interface SocketGrant {
 }
 
 export interface SocketHandlers {
-  /** `wiki.*`, `memory.*`, `recall.*`. */
+  /** `wiki.*`, `skill.*`, `recall.*`, `trajectory.*`. */
   memory(caller: CallerContext, call: string, params: Record<string, unknown>): string
   /** `mcp.list`, `mcp.call`, `mcp.revision`, `tools.list`, `tools.call`. */
   apps(session: BrokerSession, call: string, params: Record<string, unknown>): Promise<unknown>
@@ -147,7 +147,7 @@ export class SessionSocket {
       }
       const call = typeof request.call === 'string' ? request.call : ''
       const params = (request.params && typeof request.params === 'object' ? request.params : {}) as Record<string, unknown>
-      if (['wiki.', 'memory.', 'recall.'].some((prefix) => call.startsWith(prefix))) return { result: this.handlers.memory(grant.caller(), call, params) }
+      if (['wiki.', 'skill.', 'recall.', 'trajectory.'].some((prefix) => call.startsWith(prefix))) return { result: this.handlers.memory(grant.caller(), call, params) }
       if (call === 'tools.list' && !grant.broker) return { result: { tools: [] } }
       if (['mcp.', 'tools.'].some((prefix) => call.startsWith(prefix))) {
         if (!grant.broker) throw new HarnessError('mcp_unauthorized', 'Connected apps are not available to this session.')