@agfpd/iapeer 0.1.0

package/src/launch/composeSystemPrompt.layers.test.ts

@@ -0,0 +1,319 @@
+// Layer 3 (registry) + Layer 4 (other domains) tests for composeSystemPrompt,
+// plus the FS-discovery gatherPromptInput. The golden file (composeSystemPrompt
+// .test.ts) proves layers 1+2 stay byte-for-byte; THIS file proves the new
+// layers render correctly, in order (general → specific), and that empty/absent
+// inputs add nothing (backward-compat with the legacy bytes).
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { composeSystemPrompt, gatherPromptInput } from './composeSystemPrompt.ts'
+import type { ComposePromptInput, PromptDomainBlock, PublicPeerSummary } from './types.ts'
+
+const base: Omit<ComposePromptInput, 'peers' | 'pluginDomains'> = {
+  personality: 'iapeer',
+  description: 'impl',
+  cwd: '/Users/macmini/Peers/iapeer',
+  platform: 'darwin',
+  osVersion: '15.5',
+  user: 'macmini',
+  hostname: 'macmini',
+  today: '2026-06-06',
+  peerDoctrine: 'Be the implementer.\n',
+  globalDoctrine: 'GLOBAL\n',
+}
+
+const peerA: PublicPeerSummary = {
+  personality: 'boris',
+  runtime: 'claude',
+  runtimes: ['claude'],
+  description: 'PM partner',
+  intelligence: 'artificial',
+}
+const peerB: PublicPeerSummary = {
+  personality: 'arthur',
+  runtime: 'telegram',
+  runtimes: ['telegram', 'claude'],
+  description: '',
+  intelligence: 'natural',
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Pure renderer — Layers 3 + 4
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('composeSystemPrompt — layer 3 (registry)', () => {
+  test('empty/omitted peers add NOTHING (legacy bytes preserved)', () => {
+    const legacy = composeSystemPrompt(base)
+    expect(composeSystemPrompt({ ...base, peers: [] })).toBe(legacy)
+    expect(composeSystemPrompt({ ...base, peers: undefined })).toBe(legacy)
+    expect(legacy).not.toContain('## Known peers')
+  })
+
+  test('renders WITH descriptions + all 5 normalized fields (boris refinement #1)', () => {
+    const out = composeSystemPrompt({ ...base, peers: [peerA] })
+    expect(out).toContain('## Known peers')
+    expect(out).toContain('- boris — PM partner')
+    expect(out).toContain('  runtime: claude')
+    expect(out).toContain('  runtimes: claude')
+    expect(out).toContain('  intelligence: artificial')
+  })
+
+  test('a peer with an empty description renders no " — " suffix', () => {
+    const out = composeSystemPrompt({ ...base, peers: [peerB] })
+    expect(out).toContain('- arthur\n')
+    expect(out).not.toContain('- arthur — ')
+    expect(out).toContain('  runtimes: telegram, claude')
+  })
+
+  test('layer 3 sits AFTER the doctrine (layer 2), separated by a blank line', () => {
+    const out = composeSystemPrompt({ ...base, peers: [peerA] })
+    expect(out.indexOf('Be the implementer.')).toBeLessThan(out.indexOf('## Known peers'))
+    expect(out).toContain('Be the implementer.\n\n## Known peers')
+  })
+})
+
+describe('composeSystemPrompt — layer 4 (other domains)', () => {
+  const dom = (over: Partial<PromptDomainBlock>): PromptDomainBlock => ({ domain: 'X', ...over })
+
+  test('empty/omitted domains add NOTHING (legacy bytes preserved)', () => {
+    const legacy = composeSystemPrompt(base)
+    expect(composeSystemPrompt({ ...base, pluginDomains: [] })).toBe(legacy)
+    expect(composeSystemPrompt({ ...base, pluginDomains: undefined })).toBe(legacy)
+  })
+
+  test('a presence-marker domain (empty halves) emits no text and no dangling separator (boris refinement #2)', () => {
+    const legacy = composeSystemPrompt(base)
+    // a 0-byte marker → both halves '' → contributes nothing
+    expect(composeSystemPrompt({ ...base, pluginDomains: [dom({ local: '' })] })).toBe(legacy)
+    expect(composeSystemPrompt({ ...base, pluginDomains: [dom({ global: '', local: '' })] })).toBe(legacy)
+    // a marker next to a real domain must not inject a blank block between them
+    const out = composeSystemPrompt({
+      ...base,
+      pluginDomains: [dom({ domain: 'MARKER', local: '' }), dom({ domain: 'REAL', global: 'real-content\n' })],
+    })
+    expect(out).toContain('real-content')
+    expect(out).not.toMatch(/\n{4,}/) // no 3+ blank lines = no empty block injected
+  })
+
+  test('within a domain, global precedes local (general → specific)', () => {
+    const out = composeSystemPrompt({
+      ...base,
+      pluginDomains: [dom({ domain: 'MM', global: 'mm-global', local: 'mm-local' })],
+    })
+    expect(out).toContain('mm-global\nmm-local')
+    expect(out.indexOf('mm-global')).toBeLessThan(out.indexOf('mm-local'))
+  })
+
+  test('layer 4 sits after layer 3; domains kept in the order given', () => {
+    const out = composeSystemPrompt({
+      ...base,
+      peers: [peerA],
+      pluginDomains: [dom({ domain: 'AAA', global: 'aaa' }), dom({ domain: 'ZZZ', local: 'zzz' })],
+    })
+    expect(out.indexOf('## Known peers')).toBeLessThan(out.indexOf('aaa'))
+    expect(out.indexOf('aaa')).toBeLessThan(out.indexOf('zzz'))
+    expect(out).toContain('aaa\n\nzzz')
+  })
+
+  test('full 4-layer ordering: YAML → doctrine → registry → domains', () => {
+    const out = composeSystemPrompt({ ...base, peers: [peerA], pluginDomains: [dom({ global: 'domain-text' })] })
+    const iYaml = out.indexOf('personality:')
+    const iDoctrine = out.indexOf('Be the implementer.')
+    const iReg = out.indexOf('## Known peers')
+    const iDom = out.indexOf('domain-text')
+    expect(iYaml).toBeGreaterThanOrEqual(0)
+    expect(iYaml).toBeLessThan(iDoctrine)
+    expect(iDoctrine).toBeLessThan(iReg)
+    expect(iReg).toBeLessThan(iDom)
+  })
+})
+
+// ─────────────────────────────────────────────────────────────────────────────
+// gatherPromptInput — FS discovery over ~/.iapeer + <cwd>/.iapeer
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('gatherPromptInput — FS discovery of all 4 layers', () => {
+  let root: string
+  let globalRoot: string
+  let cwd: string
+  let localRoot: string
+
+  beforeAll(() => {
+    root = mkdtempSync(join(tmpdir(), 'iapeer-gather-'))
+    globalRoot = join(root, 'home', '.iapeer')
+    cwd = join(root, 'peer')
+    localRoot = join(cwd, '.iapeer')
+    mkdirSync(globalRoot, { recursive: true })
+    mkdirSync(localRoot, { recursive: true })
+
+    // Layer 2 — IAPEER.md, global + local
+    writeFileSync(join(globalRoot, 'IAPEER.md'), 'GLOBAL DOCTRINE\n')
+    writeFileSync(join(localRoot, 'IAPEER.md'), 'LOCAL ROLE\n')
+
+    // Layer 4 — domains: both halves / global-only / local-only / 0-byte marker
+    writeFileSync(join(globalRoot, 'MERGEMIND.md'), 'mm-global\n')
+    writeFileSync(join(localRoot, 'MERGEMIND.md'), 'mm-local\n')
+    writeFileSync(join(globalRoot, 'AAA.md'), 'aaa-global-only\n')
+    writeFileSync(join(localRoot, 'ZZZ.md'), 'zzz-local-only\n')
+    writeFileSync(join(localRoot, 'MARKER.md'), '') // presence marker, must not merge
+    // a non-.md file must be ignored
+    writeFileSync(join(localRoot, 'peer-profile.json'), '{}')
+
+    // Layer 3 — registry at the global root (deliberately UNSORTED on disk)
+    const index = {
+      version: 2,
+      peers: [
+        { personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: 'PM', intelligence: 'artificial', cwd: '/p/boris' },
+        { personality: 'arthur', runtime: 'telegram', runtimes: ['telegram', 'claude'], description: 'owner', intelligence: 'natural', cwd: '/p/arthur' },
+      ],
+    }
+    writeFileSync(join(globalRoot, 'peers-profiles.json'), JSON.stringify(index))
+  })
+  afterAll(() => rmSync(root, { recursive: true, force: true }))
+
+  function gather() {
+    return gatherPromptInput({
+      personality: 'iapeer',
+      description: 'impl',
+      cwd,
+      platform: 'darwin',
+      osVersion: '15.5',
+      user: 'u',
+      hostname: 'h',
+      today: '2026-06-06',
+      globalRoot,
+    })
+  }
+
+  test('layer 2: IAPEER.md read as global + local', () => {
+    const input = gather()
+    expect(input.globalDoctrine).toBe('GLOBAL DOCTRINE\n')
+    expect(input.peerDoctrine).toBe('LOCAL ROLE\n')
+  })
+
+  test('layer 4: IAPEER.md excluded; other domains discovered, sorted, non-.md ignored', () => {
+    const input = gather()
+    expect((input.pluginDomains ?? []).map(d => d.domain)).toEqual(['AAA', 'MARKER', 'MERGEMIND', 'ZZZ'])
+  })
+
+  test('layer 4: per-domain global/local halves resolved correctly', () => {
+    const input = gather()
+    const byName = Object.fromEntries((input.pluginDomains ?? []).map(d => [d.domain, d]))
+    expect(byName.MERGEMIND).toEqual({ domain: 'MERGEMIND', global: 'mm-global\n', local: 'mm-local\n' })
+    expect(byName.AAA).toEqual({ domain: 'AAA', global: 'aaa-global-only\n' })
+    expect(byName.ZZZ).toEqual({ domain: 'ZZZ', local: 'zzz-local-only\n' })
+    expect(byName.MARKER).toEqual({ domain: 'MARKER', local: '' }) // present but empty
+  })
+
+  test('layer 3: registry projected to EXACTLY 5 fields, sorted by personality', () => {
+    const input = gather()
+    expect((input.peers ?? []).map(p => p.personality)).toEqual(['arthur', 'boris'])
+    for (const p of input.peers ?? []) {
+      expect(Object.keys(p).sort()).toEqual(['description', 'intelligence', 'personality', 'runtime', 'runtimes'])
+    }
+    expect((input.peers ?? [])[0]).toEqual({
+      personality: 'arthur',
+      runtime: 'telegram',
+      runtimes: ['telegram', 'claude'],
+      description: 'owner',
+      intelligence: 'natural',
+    })
+  })
+
+  test('CHECKPOINT — the assembled prompt of a real peer contains all 4 layers, in order', () => {
+    const prompt = composeSystemPrompt(gather())
+    // Layer 1
+    expect(prompt).toContain('---\npersonality: "iapeer"')
+    // Layer 2
+    expect(prompt).toContain('GLOBAL DOCTRINE')
+    expect(prompt).toContain('LOCAL ROLE')
+    // Layer 3 (with descriptions)
+    expect(prompt).toContain('## Known peers')
+    expect(prompt).toContain('- arthur — owner')
+    expect(prompt).toContain('- boris — PM')
+    // Layer 4 (markers excluded, others merged, sorted)
+    expect(prompt).toContain('aaa-global-only')
+    expect(prompt).toContain('mm-global\nmm-local')
+    expect(prompt).toContain('zzz-local-only')
+
+    const order = [
+      prompt.indexOf('personality: "iapeer"'),
+      prompt.indexOf('LOCAL ROLE'),
+      prompt.indexOf('## Known peers'),
+      prompt.indexOf('aaa-global-only'),
+    ]
+    expect(order).toEqual([...order].sort((a, b) => a - b))
+    // marker file produced no content and no blank-block artifact
+    expect(prompt).not.toContain('MARKER')
+    expect(prompt).not.toMatch(/\n{4,}/)
+  })
+
+  test('absent IAPEER.md → peerDoctrine "" (does not throw); empty dirs → no domains/peers', () => {
+    const bareCwd = join(root, 'bare')
+    const bareGlobal = join(root, 'bareglobal', '.iapeer')
+    mkdirSync(join(bareCwd, '.iapeer'), { recursive: true })
+    mkdirSync(bareGlobal, { recursive: true })
+    const input = gatherPromptInput({
+      personality: 'bare', description: '', cwd: bareCwd,
+      platform: 'darwin', osVersion: '1', user: 'u', hostname: 'h', today: '2026-06-06',
+      globalRoot: bareGlobal,
+    })
+    expect(input.peerDoctrine).toBe('')
+    expect(input.globalDoctrine).toBeUndefined()
+    expect(input.pluginDomains).toEqual([])
+    expect(input.peers).toEqual([])
+    // composes to just the YAML block (+ empty doctrine), no extra layers
+    const prompt = composeSystemPrompt(input)
+    expect(prompt).not.toContain('## Known peers')
+    expect(prompt.endsWith('---\n\n')).toBe(true)
+  })
+
+  test('doctrine excluded from Layer 4 case-INSENSITIVELY; .MD ext picked up (verify edge-lens fix)', () => {
+    // A separate tree so a lowercase iapeer.md cannot collide with the uppercase
+    // IAPEER.md of the main fixture on a case-insensitive volume.
+    const ciCwd = join(root, 'ci')
+    const ciLocal = join(ciCwd, '.iapeer')
+    const ciGlobal = join(root, 'ciglobal', '.iapeer')
+    mkdirSync(ciLocal, { recursive: true })
+    mkdirSync(ciGlobal, { recursive: true })
+    writeFileSync(join(ciLocal, 'iapeer.md'), 'lowercase doctrine\n') // doctrine, lowercase name
+    writeFileSync(join(ciLocal, 'OTHER.md'), 'other domain\n')
+    writeFileSync(join(ciLocal, 'UP.MD'), 'upper ext domain\n') // uppercase extension
+
+    const input = gatherPromptInput({
+      personality: 'ci', description: '', cwd: ciCwd,
+      platform: 'darwin', osVersion: '1', user: 'u', hostname: 'h', today: '2026-06-06',
+      globalRoot: ciGlobal, peers: [],
+    })
+    const domains = (input.pluginDomains ?? []).map(d => d.domain)
+    // The doctrine (whatever its on-disk case) must NEVER be a Layer-4 domain —
+    // before the fix, on a case-sensitive FS 'iapeer' would leak in here.
+    expect(domains).not.toContain('iapeer')
+    expect(domains).toContain('OTHER')
+    expect(domains).toContain('UP') // .MD upper-ext now included
+
+    // And the doctrine text is never duplicated: at most once (Layer 2 on a
+    // case-insensitive FS; zero on a case-sensitive FS where IAPEER.md is absent).
+    const prompt = composeSystemPrompt(input)
+    expect(prompt.split('lowercase doctrine').length - 1).toBeLessThanOrEqual(1)
+  })
+
+  test('gatherPromptInput honors a passed-in peers projection without a second registry read', () => {
+    // Point globalRoot at a dir with NO peers-profiles.json — if gather tried to
+    // read the registry it would just get []. We pass peers explicitly and expect
+    // them through (sorted), proving the thread-through path works.
+    const provided: PublicPeerSummary[] = [
+      { personality: 'zeta', runtime: 'claude', runtimes: ['claude'], description: 'z', intelligence: 'artificial' },
+      { personality: 'alpha', runtime: 'codex', runtimes: ['codex'], description: 'a', intelligence: 'artificial' },
+    ]
+    const input = gatherPromptInput({
+      personality: 'x', description: '', cwd: join(root, 'noreg'),
+      platform: 'darwin', osVersion: '1', user: 'u', hostname: 'h', today: '2026-06-06',
+      globalRoot: join(root, 'noreg-global'), peers: provided,
+    })
+    expect((input.peers ?? []).map(p => p.personality)).toEqual(['alpha', 'zeta']) // sorted, not mutated input
+    expect(provided.map(p => p.personality)).toEqual(['zeta', 'alpha']) // caller array untouched
+  })
+})

package/src/launch/composeSystemPrompt.test.ts

@@ -0,0 +1,98 @@
+// Golden-equivalence test: composeSystemPrompt MUST produce byte-for-byte the
+// same output as the real jq doctrine-merge in claude-start.sh:264-290. Each
+// case runs the ACTUAL jq pipeline (extracted verbatim) and the TS function,
+// then byte-compares. This is the durable form of the Ф3 adversarial-verify
+// (which caught a 1-byte divergence on the empty-global-file case).
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { spawnSync } from 'child_process'
+import { mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { composeSystemPrompt } from './composeSystemPrompt.ts'
+import type { ComposePromptInput } from './types.ts'
+
+let dir: string
+let jqProg: string
+
+// The jq program verbatim from claude-start.sh:274-284.
+const JQ_PROGRAM = `"---",
+"personality: \\($personality | @json)",
+"description: \\($description | @json)",
+"peer-cwd: \\($peer_cwd | @json)",
+"platform: \\($platform | @json)",
+"os_version: \\($os_version | @json)",
+"user: \\($user | @json)",
+"hostname: \\($hostname | @json)",
+"today: \\($today | @json)",
+"---",
+""`
+
+function shq(v: string): string {
+  return `'${v.replace(/'/g, `'\\''`)}'`
+}
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), 'iapeer-csp-'))
+  jqProg = join(dir, 'prog.jq')
+  writeFileSync(jqProg, JQ_PROGRAM)
+})
+afterAll(() => rmSync(dir, { recursive: true, force: true }))
+
+/** Run the exact bash/jq pipeline; `globalDoctrine` undefined = file absent. */
+function bashReference(input: ComposePromptInput): string {
+  const peerPath = join(dir, 'peer.md')
+  writeFileSync(peerPath, input.peerDoctrine)
+  let globalBlock = ''
+  if (input.globalDoctrine !== undefined) {
+    const gp = join(dir, 'global.md')
+    writeFileSync(gp, input.globalDoctrine)
+    globalBlock = `if [ -f ${shq(gp)} ]; then cat ${shq(gp)}; printf "\\n"; fi`
+  }
+  const script = `set -e
+jq -n --raw-output \
+  --arg personality ${shq(input.personality)} \
+  --arg description ${shq(input.description)} \
+  --arg peer_cwd ${shq(input.cwd)} \
+  --arg platform ${shq(input.platform)} \
+  --arg os_version ${shq(input.osVersion)} \
+  --arg user ${shq(input.user)} \
+  --arg hostname ${shq(input.hostname)} \
+  --arg today ${shq(input.today)} \
+  -f ${shq(jqProg)}
+${globalBlock}
+cat ${shq(peerPath)}`
+  const r = spawnSync('bash', ['-c', script], { encoding: 'utf8' })
+  if (r.status !== 0) throw new Error(`bash reference failed: ${r.stderr}`)
+  return r.stdout
+}
+
+const base = {
+  personality: 'arthur',
+  cwd: '/Users/macmini/Peers/arthur',
+  platform: 'darwin',
+  osVersion: '15.5',
+  user: 'macmini',
+  hostname: 'macmini',
+  today: '2026-06-06',
+}
+
+const cases: Array<{ name: string; input: ComposePromptInput }> = [
+  { name: 'basic, no global', input: { ...base, description: 'owner', peerDoctrine: 'Be helpful.\n' } },
+  { name: 'present non-empty global', input: { ...base, description: 'owner', peerDoctrine: 'peer\n', globalDoctrine: 'GLOBAL\n' } },
+  { name: 'EMPTY-but-present global (the 1-byte divergence the verify caught)', input: { ...base, description: 'owner', peerDoctrine: 'peer', globalDoctrine: '' } },
+  { name: 'hostile description: colon + quote + newline', input: { ...base, description: 'a: "b"\nc', peerDoctrine: 'doc\n' } },
+  { name: 'unicode + emoji description', input: { ...base, description: 'Артур 🦊 №2', peerDoctrine: 'док\n', globalDoctrine: 'гл\n' } },
+  { name: 'multiline peer doctrine, no trailing newline', input: { ...base, description: 'd', peerDoctrine: 'line1\nline2' } },
+  { name: 'description with backslash and slash', input: { ...base, description: 'a\\b/c', peerDoctrine: 'x\n' } },
+]
+
+describe('composeSystemPrompt golden-equivalence vs claude-start.sh jq', () => {
+  for (const c of cases) {
+    test(c.name, () => {
+      const ref = bashReference(c.input)
+      const got = composeSystemPrompt(c.input)
+      expect(got).toBe(ref)
+    })
+  }
+})