@xingular/harness 2.1.2 → 3.0.0

package/src/memory/graph.ts

@@ -1,103 +0,0 @@
-// One graph of the Wiki: pages, facts, memory blocks, registry skills/prompts/rules, and sources
-// as nodes; frontmatter links, citations, and namespace membership as edges.
-import type { HarnessEnv } from '../core/env'
-import { charCount } from '../core/text'
-import * as registry from '../skills/registry'
-import * as blocks from './blocks'
-import * as facts from './facts'
-import * as store from './store'
-import { registryEntryKind } from './wiki'
-
-export interface GraphNode {
-  id: string
-  label: string
-  type: 'project' | 'page' | 'memory' | 'skill' | 'prompt' | 'rule' | 'block' | 'source'
-  pageType: string | null
-  namespace: string
-  summary: string
-  status: 'unresolved' | 'established' | 'stale'
-  provenance: string
-}
-
-export interface GraphEdge {
-  id: string
-  source: string
-  target: string
-  type: string
-  evidence: string | null
-}
-
-export interface GraphResponse {
-  nodes: GraphNode[]
-  edges: GraphEdge[]
-}
-
-const statusOf = (sourceIds: readonly string[]): 'unresolved' | 'established' => (sourceIds.length ? 'established' : 'unresolved')
-
-export function build(env: HarnessEnv): GraphResponse {
-  const wiki = store.wikiDir(env.root)
-  const pages = store.loadPages(wiki)
-  const memories = facts.loadMemories(wiki)
-  const nodes: GraphNode[] = pages.map((page) => ({
-    id: page.frontmatter.id,
-    label: page.frontmatter.title,
-    type: page.frontmatter.type === 'project' ? 'project' : 'page',
-    pageType: page.frontmatter.type,
-    namespace: page.location.namespace,
-    summary: store.firstParagraph(page.body),
-    status: statusOf(page.frontmatter.sourceIds),
-    provenance: `Wiki page ${page.location.path} · ${page.frontmatter.sourceIds.length} source(s)`
-  }))
-  for (const memory of memories) {
-    nodes.push({
-      id: memory.front.id,
-      label: memory.front.title,
-      type: 'memory',
-      pageType: memory.front.kind,
-      namespace: memory.front.namespace,
-      summary: store.firstParagraph(memory.body),
-      status: memory.front.status !== 'active' ? 'stale' : statusOf(memory.front.sourceIds),
-      provenance: `Memory · ${memory.front.confidence} confidence · ${memory.front.sourceIds.length} source(s)`
-    })
-  }
-  for (const item of registry.list(env.root)) {
-    const type = registryEntryKind(item.kind)
-    if (type) nodes.push({ id: item.id, label: item.name, type, pageType: null, namespace: store.ROOT_NAMESPACE, summary: item.description, status: 'established', provenance: `Registry item ${item.id}` })
-  }
-  for (const block of blocks.loadAll(wiki)) {
-    nodes.push({
-      id: block.id,
-      label: block.scope === 'agent' && block.owner ? `${env.directory.agentName(block.owner) ?? 'Removed agent'} · ${block.front.label}` : block.front.label,
-      type: 'block',
-      pageType: block.scope,
-      namespace: block.scope === 'project' && block.owner ? `/projects/${block.owner}` : store.ROOT_NAMESPACE,
-      summary: block.body.trim() ? store.firstParagraph(block.body) : block.front.description,
-      status: 'established',
-      provenance: `Memory block · ${charCount(block.body)} of ${block.front.limit} characters`
-    })
-  }
-  for (const source of store.listSources(wiki)) {
-    nodes.push({ id: source.id, label: source.name, type: 'source', pageType: null, namespace: store.ROOT_NAMESPACE, summary: `Imported source, version ${source.version}`, status: 'established', provenance: `Imported ${source.importedAt}` })
-  }
-
-  const ids = new Set(nodes.map((node) => node.id))
-  const edges: GraphEdge[] = []
-  const pushLinks = (from: string, links: readonly store.WikiLink[], sourceIds: readonly string[]): void => {
-    for (const link of links) if (ids.has(link.toId)) edges.push({ id: `${from}->${link.toId}:${link.type}`, source: from, target: link.toId, type: link.type, evidence: null })
-    for (const sourceId of sourceIds) if (ids.has(sourceId)) edges.push({ id: `${from}->${sourceId}:cites`, source: from, target: sourceId, type: 'references', evidence: sourceId })
-  }
-  for (const page of pages) pushLinks(page.frontmatter.id, page.frontmatter.links, page.frontmatter.sourceIds)
-  for (const memory of memories) pushLinks(memory.front.id, memory.front.links, memory.front.sourceIds)
-  // Namespace membership: entries in a project namespace attach to that project's overview page.
-  const projectPages = pages.filter((page) => page.frontmatter.type === 'project' && page.location.namespace.startsWith('/projects/')).map((page) => ({ namespace: page.location.namespace, id: page.frontmatter.id }))
-  const members = [
-    ...pages.map((page) => ({ id: page.frontmatter.id, namespace: page.location.namespace })),
-    ...memories.map((memory) => ({ id: memory.front.id, namespace: memory.front.namespace })),
-    ...nodes.filter((node) => node.type === 'block').map((node) => ({ id: node.id, namespace: node.namespace }))
-  ]
-  for (const member of members) {
-    const project = projectPages.find((entry) => entry.namespace === member.namespace && entry.id !== member.id)
-    if (project) edges.push({ id: `${member.id}->${project.id}:part_of`, source: member.id, target: project.id, type: 'part_of', evidence: null })
-  }
-  return { nodes, edges }
-}

package/src/memory/health.test.ts

@@ -1,130 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { expect, test } from 'vitest'
-
-import { dataRoot, writeFile } from '../../tests/helpers'
-import { createEnv } from '../core/env'
-import { now, readJson, writeJson } from '../core/fs'
-import * as blocks from './blocks'
-import { loadMemories } from './facts'
-import { build } from './graph'
-import { check } from './health'
-import { run, version, WIKI_VERSION } from './migrate'
-import { ensureProjectNamespace, isDir, isFile, loadPages, wikiDir } from './store'
-
-test('reports problems across the wiki', () => {
-  const root = dataRoot()
-  const wiki = wikiDir(root)
-  writeFileSync(join(wiki, 'library/tauri.md'), '---\nid: tauri\ntitle: Use Tauri\ntype: decision\nsourceIds: []\nlinks:\n  - toId: xingular-agent\n    type: references\n  - toId: electron\n    type: contradicts\n---\n\nWe use Tauri 2.\n')
-  writeFile(join(wiki, 'projects/xingular-agent/xingular-agent.md'), '---\nid: xingular-agent\ntitle: Xingular Agent\ntype: concept\n---\n\nThe app.\n')
-  writeFileSync(join(wiki, 'library/lonely.md'), '---\nid: lonely\ntitle: Lonely\ntype: concept\nsourceIds: [run:r1]\n---\n\nAlone.\n')
-  writeFileSync(join(wiki, 'facts/m.md'), '---\nid: m\ntitle: M\nkind: fact\nsourceIds: [src-missing]\n---\n\nFact.\n')
-  const report = check(root)
-  expect(report.brokenLinks).toHaveLength(1)
-  expect(report.contradictions).toHaveLength(1)
-  expect(report.orphanPages).toEqual(['lonely'])
-  expect([...report.missingEvidence].sort()).toEqual(['m', 'tauri', 'xingular-agent'])
-  expect([report.staleFacts, report.similarTitles, report.fullBlocks]).toEqual([[], [], []])
-})
-
-test('reports stale facts, near-duplicate titles and full blocks', () => {
-  const root = dataRoot()
-  ensureProjectNamespace(root, 'app', 'App')
-  const wiki = wikiDir(root)
-  for (const [file, title] of [['a', 'Linear MCP availability observed in run a3695ebe'], ['b', 'Linear MCP availability observed in run c54c128a'], ['c', 'Release plan']]) {
-    writeFileSync(join(wiki, `library/${file}.md`), `---\nid: ${file}\ntitle: ${title}\ntype: reference\nsourceIds: [user]\n---\n\nText.\n`)
-  }
-  writeFileSync(join(wiki, 'facts/old.md'), '---\nid: old\ntitle: Open issues\nkind: fact\nvolatile: true\nobservedAt: 2020-01-01T00:00:00Z\nsourceIds: [user]\n---\n\nThree open.\n')
-  writeFileSync(join(wiki, 'facts/new.md'), `---\nid: new\ntitle: On call\nkind: fact\nvolatile: true\nobservedAt: ${now()}\nsourceIds: [user]\n---\n\nNora.\n`)
-  const user = blocks.ensureUser(wiki)
-  writeFileSync(user.path, blocks.serializeBlock({ ...user.front, limit: 20 }, 'Nineteen characters'))
-  const report = check(root)
-  expect(report.staleFacts).toEqual(['old'])
-  expect(report.similarTitles).toEqual([['a', 'b']])
-  expect(report.fullBlocks).toEqual(['blocks/shared/user'])
-  // A project's skeleton pages start empty and unlinked without being reported.
-  expect(report.orphanPages).toEqual(['a', 'b', 'c'])
-  expect(report.missingEvidence).toEqual([])
-})
-
-test('graph spans namespaces, memories and registry', () => {
-  const root = dataRoot()
-  ensureProjectNamespace(root, 'app', 'App')
-  const wiki = wikiDir(root)
-  writeFileSync(join(wiki, 'projects/app/arch.md'), '---\nid: arch\ntitle: Arch\ntype: concept\nlinks:\n  - toId: skills/review\n    type: uses\n---\n\nBody.\n')
-  writeFileSync(join(wiki, 'facts/m.md'), '---\nid: m\ntitle: M\nkind: fact\nnamespace: /projects/app\n---\n\nFact.\n')
-  writeFile(join(root, 'registry/skills/review.md'), 'Review code.\n')
-  const graph = build(createEnv(root))
-  const types = new Set(graph.nodes.map((node) => node.type))
-  for (const type of ['project', 'memory', 'skill'] as const) expect(types.has(type)).toBe(true)
-  expect(graph.edges.some((edge) => edge.source === 'arch' && edge.target === 'skills/review')).toBe(true)
-  expect(graph.edges.some((edge) => edge.source === 'm' && edge.target === 'project-app' && edge.type === 'part_of')).toBe(true)
-})
-
-function v2Layout(): string {
-  const root = mkdtempSync(join(tmpdir(), 'harness-migrate-'))
-  writeJson(join(root, 'projects.json'), [{ id: 'p1', name: 'Xingular Agent', slug: 'xingular-agent', rootPath: '/tmp/x', autoMaintenance: true, createdAt: '2026-01-01T00:00:00Z' }])
-  writeFile(join(root, 'config/storage.json'), '{"wikiVersion":2}')
-  writeFile(join(root, 'wiki/docs/observed.md'), '---\nid: observed\ntitle: Observed in run\ntype: reference\n---\n\nA run.\n')
-  writeFile(join(root, 'wiki/memory/pnpm.md'), '---\nid: pnpm\ntitle: Use pnpm\nkind: preference\n---\n\nUse pnpm.\n')
-  writeFile(join(root, 'wiki/log.md'), '# Maintenance log\n\n- t · user · ingest\n')
-  writeFile(join(root, 'registry/rules/style.md'), 'Use spaces.\n')
-  return root
-}
-
-test('version 3 starts clean and keeps the old wiki as a backup', () => {
-  const root = v2Layout()
-  expect(version(root)).toBe(2)
-  expect(run(createEnv(root), ['a1'])).toBe(true)
-  const wiki = wikiDir(root)
-  expect(loadPages(wiki).every((page) => page.frontmatter.id !== 'observed')).toBe(true)
-  expect(loadMemories(wiki)).toEqual([])
-  for (const relative of ['blocks/shared/user.md', 'blocks/agents/a1/persona.md', 'blocks/agents/a1/notes.md', 'blocks/projects/xingular-agent/brief.md', 'projects/xingular-agent/overview.md']) expect(isFile(join(wiki, relative))).toBe(true)
-  expect(isDir(join(wiki, 'library')) && isDir(join(wiki, 'facts'))).toBe(true)
-  expect(isFile(join(root, 'wiki.pre-v3/docs/observed.md')) && isFile(join(root, 'wiki.pre-v3/memory/pnpm.md'))).toBe(true)
-  expect(readFileSync(join(root, 'registry/rules/style.md'), 'utf8')).toBe('Use spaces.\n')
-  expect(isDir(join(root, 'wiki.migrating'))).toBe(false)
-  expect(version(root)).toBe(WIKI_VERSION)
-  expect(run(createEnv(root))).toBe(false)
-})
-
-test('a version 2 wiki without a marker is still migrated', () => {
-  const root = v2Layout()
-  rmSync(join(root, 'config/storage.json'))
-  expect(version(root)).toBe(2)
-  expect(run(createEnv(root))).toBe(true)
-  expect(isFile(join(root, 'wiki.pre-v3/docs/observed.md'))).toBe(true)
-})
-
-test('version 1 knowledge is kept as a backup and personal items become global', () => {
-  const root = mkdtempSync(join(tmpdir(), 'harness-migrate-'))
-  writeJson(join(root, 'projects.json'), [{ id: 'p1', name: 'Xingular Agent', rootPath: '/tmp/x', autoMaintenance: true, createdAt: '2026-01-01T00:00:00Z' }])
-  writeFile(join(root, 'knowledge/personal/wiki/overview.md'), '---\nid: overview\ntitle: Mine\ntype: summary\n---\n\nMine.\n')
-  writeFile(join(root, 'config/registry-enabled.json'), '{"personal":["skills/a"],"p1":["rules/b"]}')
-  expect(version(root)).toBe(1)
-  expect(run(createEnv(root))).toBe(true)
-  expect(isDir(join(root, 'knowledge'))).toBe(false)
-  expect(isFile(join(root, 'knowledge.pre-v2/personal/wiki/overview.md'))).toBe(true)
-  expect(isFile(join(wikiDir(root), 'blocks/projects/xingular-agent/brief.md'))).toBe(true)
-  const enablement = readJson<Record<string, string[]>>(join(root, 'config/registry-enabled.json'))!
-  expect(enablement.global[0]).toBe('skills/a')
-  expect('personal' in enablement).toBe(false)
-})
-
-test('a failed migration leaves the wiki untouched', () => {
-  const root = v2Layout()
-  // An unreadable project registry makes staging fail.
-  writeFileSync(join(root, 'projects.json'), 'not json')
-  expect(() => run(createEnv(root))).toThrow()
-  expect(isFile(join(root, 'wiki/docs/observed.md'))).toBe(true)
-  expect(isDir(join(root, 'wiki.migrating')) || isDir(join(root, 'wiki.pre-v3'))).toBe(false)
-  expect(version(root)).toBe(2)
-})
-
-test('fresh data roots need no migration', () => {
-  const root = mkdtempSync(join(tmpdir(), 'harness-migrate-'))
-  mkdirSync(root, { recursive: true })
-  expect(version(root)).toBe(WIKI_VERSION)
-  expect(run(createEnv(root))).toBe(false)
-})

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