@xingular/harness 0.1.7 → 1.1.1

package/src/memory/health.ts

@@ -1,74 +0,0 @@
-// Health checks over the whole Wiki. They report problems with a route to the affected
-// entries and never delete anything.
-import { charCount } from '../core/text'
-import * as registry from '../skills/registry'
-import * as blocks from './blocks'
-import * as facts from './facts'
-import { lastOperationAt } from './operations'
-import * as store from './store'
-
-export interface HealthReport {
-  brokenLinks: { pageId: string; targetId: string }[]
-  orphanPages: string[]
-  missingEvidence: string[]
-  contradictions: { fromId: string; toId: string }[]
-  duplicateIds: string[]
-  /** Volatile facts that have not been observed for a while and may no longer be true. */
-  staleFacts: string[]
-  /** Groups of pages whose titles differ only by a run id, a number, or punctuation. */
-  similarTitles: string[][]
-  /** Memory blocks at 90% of their limit or more. */
-  fullBlocks: string[]
-  lastMaintenanceAt: string | null
-}
-
-const IGNORED_WORDS = new Set(['the', 'a', 'an', 'in', 'of', 'run'])
-
-/** A title without the parts that make near-duplicates look different: case, punctuation, numbers, and id-like words. */
-function titleKey(title: string): string {
-  return title.toLowerCase().split(/[^\p{Alphabetic}\p{N}]+/u).filter((word) => word && !/[0-9]/.test(word) && !IGNORED_WORDS.has(word)).join(' ')
-}
-
-export function check(root: string): HealthReport {
-  const wiki = store.wikiDir(root)
-  const pages = store.loadPages(wiki)
-  const memories = facts.loadMemories(wiki)
-  const sourceIds = new Set(store.listSources(wiki).map((source) => source.id))
-  const registryIds = registry.list(root).map((item) => item.id)
-
-  // Every page and fact; `standalone` ones need neither links nor sources.
-  const entries = [
-    ...pages.map((page) => ({ id: page.frontmatter.id, links: page.frontmatter.links, sources: page.frontmatter.sourceIds, standalone: page.frontmatter.id === 'home' || page.frontmatter.type === 'project' || store.isSkeleton(page.location) })),
-    ...memories.map((memory) => ({ id: memory.front.id, links: memory.front.links, sources: memory.front.sourceIds, standalone: true }))
-  ]
-  const seen = new Set<string>()
-  const duplicateIds = entries.filter((entry) => seen.size === seen.add(entry.id).size).map((entry) => entry.id)
-  const known = new Set([...entries.map((entry) => entry.id), ...sourceIds, ...registryIds])
-  const linked = new Set(entries.flatMap((entry) => entry.links.map((link) => link.toId)))
-  const validEvidence = (id: string): boolean => sourceIds.has(id) || store.isExternalEvidence(id)
-
-  // Pages in one namespace whose titles reduce to the same key, in namespace then key order.
-  const groups = new Map<string, { namespace: string; key: string; ids: string[] }>()
-  for (const page of pages) {
-    if (store.isSkeleton(page.location) || page.frontmatter.type === 'project') continue
-    const key = titleKey(page.frontmatter.title)
-    if (!key) continue
-    const name = `${page.location.namespace}\u0000${key}`
-    if (!groups.has(name)) groups.set(name, { namespace: page.location.namespace, key, ids: [] })
-    groups.get(name)!.ids.push(page.frontmatter.id)
-  }
-  const ordered = [...groups.values()].sort((left, right) => (left.namespace === right.namespace ? (left.key < right.key ? -1 : left.key > right.key ? 1 : 0) : left.namespace < right.namespace ? -1 : 1))
-
-  return {
-    brokenLinks: entries.flatMap((entry) => entry.links.filter((link) => !known.has(link.toId)).map((link) => ({ pageId: entry.id, targetId: link.toId }))),
-    // Home, project overviews, and facts stand on their own; other pages should be linked.
-    orphanPages: entries.filter((entry) => !entry.standalone && !entry.links.length && !linked.has(entry.id)).map((entry) => entry.id),
-    missingEvidence: entries.filter((entry) => (!entry.standalone && !entry.sources.length) || entry.sources.some((id) => !validEvidence(id))).map((entry) => entry.id),
-    contradictions: entries.flatMap((entry) => entry.links.filter((link) => link.type === 'contradicts').map((link) => ({ fromId: entry.id, toId: link.toId }))),
-    duplicateIds,
-    staleFacts: memories.filter((memory) => facts.isStale(memory.front)).map((memory) => memory.front.id),
-    similarTitles: ordered.filter((group) => group.ids.length > 1).map((group) => group.ids),
-    fullBlocks: blocks.loadAll(wiki).filter((block) => block.front.limit > 0 && charCount(block.body) * 100 >= block.front.limit * 90).map((block) => block.id),
-    lastMaintenanceAt: lastOperationAt(wiki)
-  }
-}

package/src/memory/maintainer.ts

@@ -1,272 +0,0 @@
-// Sleep-time consolidation: a Pi session that reads new evidence (an imported source or a
-// settled run) or a set of full memory blocks, and proposes changes. It has no file or shell
-// tools, only proposal tools, so every change goes back to the proposal check, which looks each
-// quoted excerpt up in the evidence before anything is written.
-import type { ModelRuntime } from '@earendil-works/pi-coding-agent'
-
-import type { AccountContext } from '../accounts/env'
-import { HarnessError } from '../core/errors'
-import { MEMORY_KINDS } from './facts'
-import { LINK_TYPES, PAGE_TYPES } from './store'
-
-export interface ExistingPage {
-  id: string
-  title: string
-  type: string
-  path?: string
-  summary: string
-  /** The page's current text, for the few pages closest to the evidence. */
-  body?: string
-}
-
-export interface ExistingMemory {
-  id: string
-  title: string
-  kind: string
-  namespace: string
-  body: string
-}
-
-/** A memory block attached to the run, in full. */
-export interface ExistingBlock {
-  id: string
-  label: string
-  description: string
-  limit: number
-  body: string
-}
-
-export type MaintenanceTrigger = { kind: 'ingest'; sourceId: string; sourceName: string; text: string } | { kind: 'run'; runId: string; transcript: string } | { kind: 'consolidate' }
-
-export interface MaintenanceRequest {
-  jobId: string
-  /** Where new pages go by default: /library or /projects/<slug>. */
-  namespace: string
-  trigger: MaintenanceTrigger
-  pages: ExistingPage[]
-  memories?: ExistingMemory[]
-  blocks?: ExistingBlock[]
-  namespaces?: { namespace: string; label: string }[]
-  index: string
-}
-
-/** What the session proposed, as its tools received it. Nothing here has been checked yet. */
-export interface MaintenanceResult {
-  pages: unknown[]
-  memories: unknown[]
-  blocks: unknown[]
-  flags: unknown[]
-}
-
-const EVIDENCE_RULE = `Every change must carry sourceRefs with an excerpt: a short passage (at least a few words) copied
-exactly from the evidence. The host looks the excerpt up in the evidence and discards any change whose
-excerpt it cannot find, so never paraphrase an excerpt and never cite something the evidence does not say.`
-
-const runInstructions = (product: string): string => `You consolidate memory for ${product} after a run has finished ("sleep-time" work).
-You are given the run's transcript, the memory blocks that were in its context, the facts that apply,
-and related Wiki pages. Decide what is worth keeping for future work, then:
-- rethink_block: rewrite a memory block when the run taught something that belongs in it (see each
-  block's description). Give the complete new content, merged with what is already there. Remove
-  what the run showed to be wrong or finished. Stay within the block's limit.
-- propose_memory: record a short standing fact, preference, decision, or piece of feedback. Update
-  an existing fact by id, or replace one with supersedes. Use low confidence when unsure.
-- propose_page: update a page that ALREADY EXISTS, by its id, with its complete new body (merge with
-  the current text shown to you; never drop established content unless the evidence supersedes it).
-  You cannot create pages: one run is an episode, not a page. What a run merely observed (a tool
-  result, a status, a list that will change) is not durable knowledge; leave it out.
-- flag_claim: send an uncertain, contradictory, or sensitive claim to the review inbox instead.
-${EVIDENCE_RULE}
-Use {"kind":"run","ref":"<the run id>","excerpt":"…"}.
-Skip small talk and transient details. Most runs need few changes; it is fine to change nothing.`
-
-const ingestInstructions = (product: string): string => `You maintain ${product}'s global knowledge Wiki (Karpathy-style LLM Wiki).
-Raw sources are immutable evidence; Wiki pages are durable, interlinked Markdown syntheses, one per
-entity, concept, or decision, updated in place. The Wiki is one corpus: the Library (/library) and one
-namespace per project (/projects/<name>). Facts are short typed statements.
-Read the imported source and decide what durable knowledge it adds. Then:
-- propose_page once per page to create or update. To update, pass the existing page id and the
-  complete new body (merge with what the page already says; never drop established content unless
-  the source supersedes it, and say so). Prefer updating an existing page over creating a near
-  duplicate. New pages go to the job's namespace unless they clearly belong elsewhere.
-- propose_memory for a short standing fact, preference, decision, or piece of feedback. Use namespace
-  "/" when it applies everywhere.
-- Link related pages with typed links (references, depends_on, supersedes, contradicts,
-  produced_by, uses) using existing page ids or ids you propose.
-- flag_claim for a claim that is uncertain, contradicts an existing page, or contains secrets or
-  personal data that should not be stored.
-${EVIDENCE_RULE}
-Use {"kind":"source","ref":"<the source id>","excerpt":"…"}.
-Prefer few, well-structured pages. Page ids are short kebab-case slugs. It is fine to propose nothing.`
-
-const consolidateInstructions = (product: string): string => `You tidy ${product}'s memory blocks. Each block below is close to its
-character limit. For each one, call rethink_block with a shorter version that keeps everything still
-true and useful: merge repeats, drop what is finished or superseded, and tighten the wording. Do not
-add anything that is not already in the block. The new content must be shorter than the current one.`
-
-export function instructions(kind: MaintenanceTrigger['kind'], product: string): string {
-  return kind === 'run' ? runInstructions(product) : kind === 'ingest' ? ingestInstructions(product) : consolidateInstructions(product)
-}
-
-/** The proposal tools each kind of job gets. */
-export function toolNames(kind: MaintenanceTrigger['kind']): string[] {
-  if (kind === 'consolidate') return ['rethink_block']
-  if (kind === 'run') return ['rethink_block', 'propose_memory', 'propose_page', 'flag_claim']
-  return ['propose_page', 'propose_memory', 'flag_claim']
-}
-
-export function prompt(request: MaintenanceRequest): string {
-  const blocks = request.blocks?.length
-    ? request.blocks.map((block) => `<block id="${block.id}" label="${block.label}" chars="${Array.from(block.body).length}/${block.limit}">\n${block.description}\n---\n${block.body.trim() || '(empty)'}\n</block>`).join('\n\n')
-    : '(none)'
-  if (request.trigger.kind === 'consolidate') return `Memory blocks to condense:\n\n${blocks}`
-  const existing = request.pages.length ? request.pages.map((page) => `- ${page.id} (${page.type}${page.path ? `, ${page.path}` : ''}): ${page.title} — ${page.summary}`).join('\n') : '(no pages yet)'
-  const bodies = request.pages.filter((page) => page.body?.trim()).map((page) => `<page id="${page.id}" title="${page.title}">\n${page.body}\n</page>`).join('\n\n')
-  const memories = request.memories?.length ? request.memories.map((memory) => `- ${memory.id} [${memory.kind}, ${memory.namespace}] ${memory.title}: ${memory.body}`).join('\n') : '(none)'
-  const namespaces = ['/library', ...(request.namespaces ?? []).map((namespace) => `${namespace.namespace} (${namespace.label})`)].join(', ')
-  const evidence = request.trigger.kind === 'ingest' ? `Imported source ${request.trigger.sourceId} ("${request.trigger.sourceName}"):\n\n${request.trigger.text}` : `Settled run ${request.trigger.runId} transcript:\n\n${request.trigger.transcript}`
-  return [
-    `Namespace for this job: ${request.namespace}`,
-    `Namespaces: ${namespaces}`,
-    ...(request.trigger.kind === 'run' ? [`Memory blocks in this run's context:\n\n${blocks}`] : []),
-    `Current index:\n${request.index}`,
-    `Relevant pages:\n${existing}`,
-    ...(bodies ? [`Current text of the closest pages:\n\n${bodies}`] : []),
-    `Facts:\n${memories}`,
-    `New evidence:\n${evidence}`
-  ].join('\n\n')
-}
-
-export interface MaintainerSession {
-  prompt(text: string): Promise<void>
-  dispose(): void
-  /** Assistant error text, if the provider failed. */
-  error(): string | null
-}
-
-type Collector = { page: (proposal: unknown) => string; memory: (proposal: unknown) => string; block: (proposal: unknown) => string; flag: (flag: unknown) => string }
-
-export type MaintainerFactory = (input: {
-  cwd: string
-  /** Which job this is; it decides the instructions and the tools. */
-  kind: MaintenanceTrigger['kind']
-  product: string
-  account: AccountContext
-  runtime: () => Promise<ModelRuntime>
-  collect: Collector
-}) => Promise<MaintainerSession>
-
-export const piMaintainerFactory: MaintainerFactory = async ({ cwd, kind, product, account, runtime, collect }) => {
-  const pi = await import('@earendil-works/pi-coding-agent')
-  const { Type } = await import('typebox')
-  const agentDir = account.configDir
-  const resourceLoader = new pi.DefaultResourceLoader({ cwd, agentDir, noExtensions: true, noSkills: true, noPromptTemplates: true, noContextFiles: true, appendSystemPromptOverride: (base) => [...base, instructions(kind, product)] })
-  await resourceLoader.reload()
-  const sourceRefs = Type.Array(
-    Type.Object({
-      kind: Type.Union([Type.Literal('source'), Type.Literal('run'), Type.Literal('url')]),
-      ref: Type.String(),
-      excerpt: Type.Optional(Type.String({ description: 'A passage copied exactly from the evidence' }))
-    })
-  )
-  const reply = (text: string) => ({ content: [{ type: 'text' as const, text }], details: {} })
-  const tools = [
-    pi.defineTool({
-      name: 'rethink_block',
-      label: 'Rewrite block',
-      description: 'Rewrite one memory block with its complete new content. The host checks the excerpt and the block limit before anything is written.',
-      parameters: Type.Object({ block: Type.String({ description: 'The block id, as given in <block id="…">' }), body: Type.String({ description: 'The complete new content of the block' }), sourceRefs: Type.Optional(sourceRefs) }),
-      execute: async (_id, input) => reply(collect.block({ sourceRefs: [], ...(input as object) }))
-    }),
-    pi.defineTool({
-      name: 'propose_page',
-      label: 'Propose page',
-      description: 'Create or update one Wiki page. The host validates it before anything is written.',
-      parameters: Type.Object({
-        id: Type.Optional(Type.String({ description: 'Existing page id to update, or a new kebab-case id' })),
-        title: Type.String(),
-        type: Type.Union(PAGE_TYPES.map((value) => Type.Literal(value))),
-        body: Type.String({ description: 'Complete Markdown body' }),
-        namespace: Type.Optional(Type.String({ description: 'For a new page: /library or /projects/<name>; defaults to the job namespace' })),
-        sourceRefs,
-        links: Type.Array(Type.Object({ toId: Type.String(), type: Type.Union(LINK_TYPES.map((value) => Type.Literal(value))) }))
-      }),
-      execute: async (_id, input) => reply(collect.page(input))
-    }),
-    pi.defineTool({
-      name: 'propose_memory',
-      label: 'Propose fact',
-      description: 'Create or update one fact: a short standing statement agents can look up. The host validates it before anything is written.',
-      parameters: Type.Object({
-        id: Type.Optional(Type.String({ description: 'Existing fact id to update, or a new kebab-case id' })),
-        title: Type.String(),
-        kind: Type.Union(MEMORY_KINDS.map((value) => Type.Literal(value))),
-        body: Type.String({ description: 'One to a few sentences' }),
-        namespace: Type.Optional(Type.String({ description: '/ for everywhere, or /projects/<name>' })),
-        confidence: Type.Optional(Type.Union([Type.Literal('high'), Type.Literal('medium'), Type.Literal('low')])),
-        supersedes: Type.Optional(Type.String({ description: 'Id of the fact this replaces' })),
-        sourceRefs
-      }),
-      execute: async (_id, input) => reply(collect.memory(input))
-    }),
-    pi.defineTool({
-      name: 'flag_claim',
-      label: 'Flag claim',
-      description: 'Send an uncited, contradictory, uncertain, or sensitive claim to the review inbox instead of the Wiki.',
-      parameters: Type.Object({ claim: Type.String(), kind: Type.Union([Type.Literal('uncited'), Type.Literal('contradiction'), Type.Literal('low_confidence'), Type.Literal('sensitive')]), reason: Type.String() }),
-      execute: async (_id, input) => reply(collect.flag(input))
-    })
-  ]
-  const allowed = toolNames(kind)
-  const { session } = await pi.createAgentSession({
-    cwd,
-    agentDir,
-    modelRuntime: await runtime(),
-    tools: allowed,
-    customTools: tools.filter((tool) => allowed.includes((tool as { name: string }).name)) as never,
-    resourceLoader,
-    sessionManager: pi.SessionManager.inMemory(cwd)
-  })
-  let lastError: string | null = null
-  session.subscribe((event) => {
-    if (event.type !== 'message_end') return
-    const message = event.message as { role?: string; stopReason?: string; errorMessage?: string }
-    if (message.role === 'assistant' && message.stopReason === 'error') lastError = message.errorMessage ?? 'Provider error'
-  })
-  return { prompt: (text) => session.prompt(text), dispose: () => session.dispose(), error: () => lastError }
-}
-
-/** Runs one job's session and returns what it proposed. Nothing is written here. */
-export async function runMaintenance(request: MaintenanceRequest, input: Omit<Parameters<MaintainerFactory>[0], 'kind' | 'collect'>, factory: MaintainerFactory = piMaintainerFactory): Promise<MaintenanceResult> {
-  const result: MaintenanceResult = { pages: [], memories: [], blocks: [], flags: [] }
-  const titled = (proposal: unknown): string => String((proposal as { title?: unknown } | null)?.title ?? '')
-  const session = await factory({
-    ...input,
-    kind: request.trigger.kind,
-    collect: {
-      page: (proposal) => {
-        result.pages.push(proposal)
-        return `Proposed "${titled(proposal)}". The host will validate it.`
-      },
-      memory: (proposal) => {
-        result.memories.push(proposal)
-        return `Proposed memory "${titled(proposal)}". The host will validate it.`
-      },
-      block: (proposal) => {
-        result.blocks.push(proposal)
-        return `Proposed a rewrite of ${String((proposal as { block?: unknown } | null)?.block ?? '')}. The host will validate it.`
-      },
-      flag: (flag) => {
-        result.flags.push(flag)
-        return 'Sent to the review inbox.'
-      }
-    }
-  })
-  try {
-    await session.prompt(prompt(request))
-    const error = session.error()
-    if (error) throw new HarnessError('provider_error', error)
-  } finally {
-    session.dispose()
-  }
-  return result
-}

package/src/memory/maintenance.test.ts

@@ -1,176 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { memorySecretStore } from '../accounts/secrets'
-import { writeJson } from '../core/fs'
-import type { Notice } from '../core/bus'
-import { createHarness, type Harness } from '../harness'
-import type { PiSessionLike } from '../sessions/runner'
-import * as blocks from './blocks'
-import { findMemory } from './facts'
-import { prompt, runMaintenance, toolNames, type MaintainerFactory, type MaintenanceRequest } from './maintainer'
-import { chatUpdatesPaused, fullBlocks } from './maintenance'
-import { listInbox } from './operations'
-import { wikiDir } from './store'
-
-const request: MaintenanceRequest = { jobId: 'job-1', namespace: '/library', trigger: { kind: 'ingest', sourceId: 'src-1', sourceName: 'notes.md', text: 'We chose Tauri.' }, pages: [], index: '# Index' }
-const input = { cwd: '/tmp', product: 'Xingular Agent', account: { id: 'a', provider: 'pi' as const, label: 'A', env: {}, configDir: '/tmp', sharing: [] }, runtime: async () => ({}) as never }
-
-describe('the maintainer session', () => {
-  it('collects proposals and flags without writing anything itself', async () => {
-    let prompted = ''
-    const factory: MaintainerFactory = async ({ collect }) => ({
-      prompt: async (text) => {
-        prompted = text
-        collect.page({ title: 'Use Tauri', type: 'decision', body: 'We use Tauri.', sourceRefs: [{ kind: 'source', ref: 'src-1' }], links: [] })
-        collect.memory({ title: 'Prefers Tauri', kind: 'preference', body: 'Use Tauri for desktop apps.', namespace: '/', sourceRefs: [{ kind: 'source', ref: 'src-1' }] })
-        collect.flag({ claim: 'Electron is slow', kind: 'uncited', reason: 'No source' })
-      },
-      dispose: () => undefined,
-      error: () => null
-    })
-    const result = await runMaintenance(request, input, factory)
-    expect(prompted).toContain('src-1')
-    expect(prompted).toContain('Namespace for this job: /library')
-    expect(result.pages).toHaveLength(1)
-    expect(result.memories[0]).toMatchObject({ kind: 'preference', namespace: '/' })
-    expect(result.flags[0]).toMatchObject({ kind: 'uncited' })
-  })
-
-  it('gives a run its blocks and page bodies, and each job only its tools', async () => {
-    const block = { id: 'blocks/shared/user', label: 'user', description: 'About the user.', limit: 2000, body: 'Likes pnpm.' }
-    const run: MaintenanceRequest = { ...request, trigger: { kind: 'run', runId: 'run-1', transcript: 'User: hi\nAssistant: hello' }, pages: [{ id: 'shell', title: 'Shell', type: 'decision', summary: 'Tauri', body: 'We use Tauri.' }], blocks: [block] }
-    const text = prompt(run)
-    expect(text).toContain('<block id="blocks/shared/user" label="user" chars="11/2000">')
-    expect(text).toContain('<page id="shell" title="Shell">\nWe use Tauri.')
-    expect(text).toContain('Settled run run-1 transcript')
-    expect(prompt({ ...request, trigger: { kind: 'consolidate' }, blocks: [block] })).toBe('Memory blocks to condense:\n\n<block id="blocks/shared/user" label="user" chars="11/2000">\nAbout the user.\n---\nLikes pnpm.\n</block>')
-    expect(toolNames('run')).toEqual(['rethink_block', 'propose_memory', 'propose_page', 'flag_claim'])
-    expect(toolNames('ingest')).not.toContain('rethink_block')
-    expect(toolNames('consolidate')).toEqual(['rethink_block'])
-  })
-
-  it('reports provider failures', async () => {
-    const factory: MaintainerFactory = async () => ({ prompt: async () => undefined, dispose: () => undefined, error: () => 'quota exceeded' })
-    await expect(runMaintenance(request, input, factory)).rejects.toMatchObject({ code: 'provider_error' })
-  })
-})
-
-const open: Harness[] = []
-afterEach(async () => {
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-function setup(factory: MaintainerFactory) {
-  const reply: PiSessionLike = {
-    sessionId: 'native',
-    subscribe: (listener) => {
-      emit = listener as never
-      return () => undefined
-    },
-    prompt: async () => emit({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'We decided to use Tauri. I prefer small commits.' }] } }),
-    sendCustomMessage: async () => undefined,
-    abort: async () => undefined,
-    dispose: () => undefined
-  }
-  let emit: (event: unknown) => void = () => undefined
-  const harness = createHarness({ dataRoot: mkdtempSync(join(tmpdir(), 'harness-maint-data-')), stateDir: mkdtempSync(join(tmpdir(), 'harness-maint-state-')), secrets: memorySecretStore(), sessionFactory: async () => reply, maintainerFactory: factory })
-  open.push(harness)
-  harness.accounts.create('Main', 'apiKey')
-  const notices: Notice[] = []
-  harness.bus.on((notice) => void notices.push(notice))
-  const turn = (id: string) => harness.sessions.run({ run: { id, sessionId: 'nora' }, cwd: harness.env.root, sessionDir: join(harness.env.root, 'history'), text: 'Which shell do we use?', caller: { agentId: 'nora', agentName: 'Nora', actor: 'Chat' }, tools: { allow: [] } })
-  return { harness, notices, turn, wiki: wikiDir(harness.env.root) }
-}
-
-describe('the memory lifecycle', () => {
-  it('a settled run is consolidated: quoted changes apply, invented ones wait, and the session never writes', async () => {
-    let seen: { kind: string; text: string } | null = null
-    const { harness, notices, turn, wiki } = setup(async ({ kind, collect }) => ({
-      prompt: async (text) => {
-        seen = { kind, text }
-        collect.memory({ title: 'Small commits', kind: 'preference', body: 'Prefer small commits.', confidence: 'high', sourceRefs: [{ kind: 'run', ref: 'run-1', excerpt: 'I prefer small commits' }] })
-        collect.memory({ title: 'Invented', kind: 'fact', body: 'Never said.', confidence: 'high', sourceRefs: [{ kind: 'run', ref: 'run-1', excerpt: 'something never said at all' }] })
-        collect.block({ block: 'blocks/agents/nora/notes', body: 'The shell is Tauri.', sourceRefs: [{ kind: 'run', ref: 'run-1', excerpt: 'We decided to use Tauri' }] })
-        collect.page({ title: 'A new page', type: 'concept', body: 'From one run.', sourceRefs: [{ kind: 'run', ref: 'run-1', excerpt: 'We decided to use Tauri' }], links: [] })
-      },
-      dispose: () => undefined,
-      error: () => null
-    }))
-    await turn('run-1')
-    await new Promise((resolve) => setTimeout(resolve, 30))
-    await harness.maintenance.settled()
-    expect(seen!.kind).toBe('run')
-    expect(seen!.text).toContain('Settled run run-1 transcript:\n\nUser: Which shell do we use?\nAssistant: We decided to use Tauri.')
-    expect(seen!.text).toContain('<block id="blocks/agents/nora/notes" label="notes"')
-    expect(findMemory(wiki, 'small-commits').front).toMatchObject({ namespace: '/', sourceIds: ['run:run-1'] })
-    expect(() => findMemory(wiki, 'invented')).toThrow()
-    expect(blocks.find(wiki, 'blocks/agents/nora/notes').body).toBe('The shell is Tauri.')
-    // One run is an episode: it never becomes a page by itself.
-    expect(listInbox(wiki).map((item) => item.kind).sort()).toEqual(['applied', 'unresolved', 'unresolved'])
-    expect(notices.some((notice) => notice.type === 'wiki.maintenance' && String(notice.detail).includes('2 parked'))).toBe(true)
-    expect(readFileSync(join(wiki, 'log.md'), 'utf8')).toContain('Sleep-time · run run-1')
-    // A person can undo the whole consolidation as one operation.
-    harness.maintenance.undoOperation(listInbox(wiki).find((item) => item.operationId)!.operationId!)
-    expect(blocks.find(wiki, 'blocks/agents/nora/notes').body).toBe('')
-  })
-
-  it('skips a run that settings exclude, and a paused conversation', async () => {
-    let jobs = 0
-    const { harness, turn } = setup(async () => ({ prompt: async () => void (jobs += 1), dispose: () => undefined, error: () => null }))
-    writeJson(join(harness.env.root, 'config/settings.json'), { excludedSourceIds: ['run-1'] })
-    await turn('run-1')
-    await new Promise((resolve) => setTimeout(resolve, 30))
-    await harness.maintenance.settled()
-    writeJson(join(harness.env.root, 'config/settings.json'), { autoMaintenanceChat: false })
-    await turn('run-2')
-    await new Promise((resolve) => setTimeout(resolve, 30))
-    await harness.maintenance.settled()
-    expect(jobs).toBe(0)
-    expect([chatUpdatesPaused({}), chatUpdatesPaused({ autoMaintenanceChat: true }), chatUpdatesPaused({ autoMaintenanceChat: false })]).toEqual([false, false, true])
-  })
-
-  it('an imported source is read once and its proposals are checked against its text', async () => {
-    const { harness, wiki } = setup(async ({ kind, collect }) => ({
-      prompt: async () => {
-        expect(kind).toBe('ingest')
-        const source = (await import('./store')).listSources(wiki)[0]
-        collect.page({ id: 'shell', title: 'Shell', type: 'decision', body: 'We use Tauri.', sourceRefs: [{ kind: 'source', ref: source.id, excerpt: 'we chose Tauri for the shell' }], links: [] })
-        collect.page({ id: 'rumor', title: 'Rumor', type: 'concept', body: 'Not in the source.', sourceRefs: [{ kind: 'source', ref: source.id, excerpt: 'Electron is faster than everything' }], links: [] })
-      },
-      dispose: () => undefined,
-      error: () => null
-    }))
-    harness.maintenance.ingest('notes.md', Buffer.from('After the review we chose Tauri for the shell.'))
-    await harness.maintenance.settled()
-    expect(readFileSync(join(wiki, 'library/shell.md'), 'utf8')).toContain('We use Tauri.')
-    const parked = listInbox(wiki).find((item) => item.payload !== undefined)!
-    expect(parked.title).toContain('Rumor')
-    // The user is the authority when they accept what was parked.
-    expect(harness.maintenance.acceptInboxItem(parked.id)).toContain('created')
-    expect(readFileSync(join(wiki, 'library/rumor.md'), 'utf8')).toContain('user:accepted')
-  })
-
-  it('condenses a block that is close to its limit once nothing else is happening, and only to something shorter', async () => {
-    const harness = createHarness({
-      dataRoot: mkdtempSync(join(tmpdir(), 'harness-maint-data-')),
-      stateDir: mkdtempSync(join(tmpdir(), 'harness-maint-state-')),
-      secrets: memorySecretStore(),
-      idleMs: 20,
-      maintainerFactory: async ({ kind, collect }) => ({ prompt: async () => void (kind === 'consolidate' && collect.block({ block: 'blocks/shared/user', body: 'Uses pnpm.' })), dispose: () => undefined, error: () => null })
-    })
-    open.push(harness)
-    harness.accounts.create('Main', 'apiKey')
-    const wiki = wikiDir(harness.env.root)
-    const user = blocks.ensureUser(wiki)
-    writeFileSync(user.path, blocks.serializeBlock({ ...user.front, limit: 60 }, 'Likes pnpm. Likes pnpm a lot. Uses pnpm everywhere, always.'))
-    expect(fullBlocks(wiki, new Set())).toEqual(['blocks/shared/user'])
-    await new Promise((resolve) => setTimeout(resolve, 120))
-    await harness.maintenance.settled()
-    expect(blocks.find(wiki, 'blocks/shared/user').body).toBe('Uses pnpm.')
-    const tried = new Set<string>()
-    expect(fullBlocks(wiki, tried)).toEqual([])
-  })
-})