HologramAgent-DSH-Memory-Port/test/phase-b-g.test.js

/**
 * Phase B · group G — guards.
 *
 * These exist so that adding vectors cannot quietly damage what phase A shipped,
 * and so that the vector *transport* cannot leak into the layers that must stay
 * provider-agnostic.
 *
 * G1  phase A's whole surface still passes (unit + checkpoints) — the golden
 *     fixture and the checkpoint script are the enforcement, this file only
 *     pins the invariant that they are wired up.
 * G2  no embedder ⇒ no outbound HTTP, no extra module loaded.
 * G3  `stablemem_commit` still writes with a dead/absent embedder.
 * G4  media stays out of scope (one modality, `text`).
 * G5  provider-specific identifiers may exist in exactly one file.
 *
 * @module dsh-memory/test/phase-b-g
 */

import assert from 'node:assert/strict'
import { readFileSync, readdirSync } from 'node:fs'
import { join } from 'node:path'
import test from 'node:test'
import { Context } from '@deepseek-ai/cordis'
import { SystemPrompt } from '@deepseek-ai/dsh-system-prompt'
import { ToolRuntime } from '@deepseek-ai/dsh-tools'
import { apply as applyMemory } from '../lib/index.js'
import { BlockStore, MODALITY_TEXT } from '../lib/store.js'

const LIB = new URL('../lib/', import.meta.url).pathname

/** Every .js file under lib/, recursively. */
function libSources() {
  const out = []
  const walk = (dir) => {
    for (const entry of readdirSync(dir, { withFileTypes: true })) {
      const full = join(dir, entry.name)
      if (entry.isDirectory()) walk(full)
      else if (entry.name.endsWith('.js')) out.push(full)
    }
  }
  walk(LIB)
  return out
}

/** A real cordis app carrying the services the plugin injects. */
function makeApp() {
  const ctx = new Context()
  new SystemPrompt(ctx, {})
  new ToolRuntime(ctx, {})
  return ctx
}

// ── G2: no embedder ⇒ no outbound HTTP, no extra deps ─────────────────────
/**
 * Install a `fetch` tripwire for the duration of `body`, then restore it.
 * @param {(count: () => number) => Promise<void>} body
 */
async function withFetchTripwire(body) {
  const original = globalThis.fetch
  let calls = 0
  globalThis.fetch = (...args) => {
    calls += 1
    return Promise.reject(new Error(`unexpected fetch: ${args[0]}`))
  }
  try {
    await body(() => calls)
  } finally {
    globalThis.fetch = original
  }
}

test('G2: with no embedder, recall performs no network I/O', async () => {
  // Any vector transport that tries to work without an embedder goes through here.
  await withFetchTripwire(async (calls) => {
    const store = new BlockStore({ path: ':memory:' }).open()
    store.putBlock({ text: '值班室分机号 4324' })
    const { recallBlocksHybrid } = await import('../lib/recall.js')
    const hits = await recallBlocksHybrid(store, null, '4324', { topK: 3 })
    assert.ok(hits.length >= 1, 'symbol path still recalls')
    assert.equal(calls(), 0, `no embedder must mean zero network calls; saw ${calls()}`)
    store.close()
  })
})

// G2† — every early-degradation path must stay network-free.
//
// Rationale: G5 shipped a guard whose allowlist was silently always-false, and it
// stayed green because nothing ever exercised it. The same shape applies here —
// `recallBlocksHybrid` has FOUR early exits, and a hand-run check of one of them
// proves nothing about the other three. Enumerated as data so a fifth branch
// added later fails this test until it is covered.
const DEGRADATION_PATHS = [
  {
    name: 'embedder is null',
    embedder: () => null,
    expect: 'no_embedder',
  },
  {
    name: 'embedder is undefined',
    embedder: () => undefined,
    expect: 'no_embedder',
  },
  {
    name: 'embedder has no embedText',
    embedder: () => ({ info: () => ({ fingerprint: 'fp', dimension: 3 }) }),
    expect: 'no_embedder',
  },
  {
    // ★ The branch this test was added for: non-null embedder, but it cannot
    // name its own vector space. It must degrade WITHOUT calling embedText —
    // and therefore without any transport being touched.
    name: 'embedder with no info()',
    embedder: () => ({ async embedText() { throw new Error('must not be called') } }),
    expect: 'no_embedder',
  },
  {
    name: 'embedder whose info() has an empty fingerprint',
    embedder: () => ({
      async embedText() { throw new Error('must not be called') },
      info: () => ({ fingerprint: '', dimension: 3 }),
    }),
    expect: 'no_embedder',
  },
  {
    name: 'embedder whose info() has a non-string fingerprint',
    embedder: () => ({
      async embedText() { throw new Error('must not be called') },
      info: () => ({ fingerprint: 42, dimension: 3 }),
    }),
    expect: 'no_embedder',
  },
]

for (const path of DEGRADATION_PATHS) {
  test(`G2†: "${path.name}" degrades to ${path.expect} with zero network calls`, async () => {
    await withFetchTripwire(async (calls) => {
      const store = new BlockStore({ path: ':memory:' }).open()
      try {
        store.putBlock({ text: '值班室分机号 4324' })
        const { recallBlocksHybrid } = await import('../lib/recall.js')
        const hits = await recallBlocksHybrid(store, path.embedder(), '4324', { topK: 3 })
        assert.equal(hits.degraded, path.expect, `expected degraded=${path.expect}`)
        assert.ok(hits.length >= 1, 'symbol path must still recall on every degradation path')
        assert.equal(calls(), 0, `"${path.name}" must not touch the network; saw ${calls()}`)
      } finally {
        store.close()
      }
    })
  })
}

test('G2†: the fingerprint check runs BEFORE embedText is called', async () => {
  // Ordering, pinned directly: a failing-fingerprint embedder must never be
  // asked for a vector. If a refactor moved the call earlier, this fails even
  // though the degraded value would still be 'no_embedder'.
  let embedCalls = 0
  const embedder = {
    async embedText() {
      embedCalls += 1
      return [0, 0, 0]
    },
    info: () => ({ fingerprint: '', dimension: 3 }),
  }
  const store = new BlockStore({ path: ':memory:' }).open()
  try {
    store.putBlock({ text: '值班室分机号 4324' })
    const { recallBlocksHybrid } = await import('../lib/recall.js')
    const hits = await recallBlocksHybrid(store, embedder, '4324', { topK: 3 })
    assert.equal(hits.degraded, 'no_embedder')
    assert.equal(embedCalls, 0, 'embedText must not be called when the space is unnamed')
  } finally {
    store.close()
  }
})

// Scans SOURCE TEXT, not the loaded module. If it imported the module it would
// crash on a missing package and report "load failed" — which is a different
// finding than "a disallowed dependency was added", and the distinction matters
// when triaging.
// ── G3: commit must work with a dead embedder ────────────────────────────
test('G3: stablemem_commit writes even when the embedder throws', async () => {
  const ctx = makeApp()
  const dir = await import('node:fs').then((fs) => fs.mkdtempSync(join('/tmp', 'g3-')))
  try {
    const mem = applyMemory(ctx, { path: join(dir, 'm.db') })
    mem.embedder = {
      async embedText() {
        throw new Error('vector service down')
      },
      info: () => ({ fingerprint: 'fp', dimension: 4 }),
    }
    const result = await ctx.tools.execute({
      callId: 'g3',
      name: 'stablemem_commit',
      arguments: { text: '向量服务挂了也要能写入：端口 2379', source: 'g3' },
      signal: new AbortController().signal,
    })
    assert.equal(result.isError, false, `commit must not fail: ${JSON.stringify(result)}`)
    assert.equal(mem.store.countBlocks(), 1, 'the block must be stored')
    // Recall still works through the symbol path.
    const hits = await mem.recall('2379')
    assert.ok(hits.length >= 1, 'symbol recall must still find it')
  } finally {
    await ctx.fiber.dispose()
    const fs = await import('node:fs')
    fs.rmSync(dir, { recursive: true, force: true })
  }
})

// ── G4: media stays out ──────────────────────────────────────────────────
test('G4: only the text modality is produced', () => {
  const store = new BlockStore({ path: ':memory:' }).open()
  try {
    store.putBlock({ text: 'a note' })
    const rows = store.allBlocks(10)
    assert.equal(rows.length, 1)
    for (const row of rows) {
      assert.equal(row.modality, MODALITY_TEXT, 'no non-text modality may be written')
    }
    // No media payload columns exist at all in this slice, so there is nowhere
    // for bytes to be stored even accidentally.
    const columns = store.columns('memory_blocks')
    for (const forbidden of ['data', 'mime', 'width', 'height']) {
      assert.ok(
        !columns.includes(forbidden),
        `memory_blocks must have no media column; found "${forbidden}" in ${columns.join(',')}`,
      )
    }
  } finally {
    store.close()
  }
})