@xingular/harness 0.0.0-stage → 0.1.1

package/src/memory/maintainer.ts

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

@@ -0,0 +1,176 @@
+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([])
+  })
+})