solopup-memory 0.0.0-stage → 0.21.0-beta.2

package/test-supersede.mjs

@@ -0,0 +1,216 @@
+import {realpathSync} from 'node:fs'
+import {applyWithOwnerFixture as apply} from './fixture-host.mjs'
+/**
+ * supersede（版本替代）与来源标记。跑法：node --test ~/.dsh/plugins/memory/test-supersede.mjs
+ *
+ * 取代是「修正过期事实」的唯一正确做法：再叠一条会让新旧两条同时被注入，
+ * 模型看到矛盾信息。cc-memory 把这叫 anti-patch，MemOS 把它建模成 MemCube 的版本关系。
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import {  storeDirFor, writeMemory } from './index.mjs'
+
+function sandbox() {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), 'dsh-mem-sup-')))
+  const home = join(root, 'home')
+  const cwd = join(root, 'proj')
+  mkdirSync(home, { recursive: true })
+  mkdirSync(cwd, { recursive: true })
+  const prev = process.env.DSH_HOME
+  process.env.DSH_HOME = home
+  return {
+    root,
+    cwd,
+    store: join(home, 'memory'),
+    cleanup() {
+      if (prev === undefined) delete process.env.DSH_HOME
+      else process.env.DSH_HOME = prev
+      rmSync(root, { recursive: true, force: true })
+    },
+  }
+}
+
+function mount(cwd) {
+  const captured = { cwd, tools: [] }
+  apply({
+    systemPrompt: { context: (entry) => (captured.context = entry) },
+    workingDirectory: { get: () => captured.cwd },
+    tools: { register: (definition) => captured.tools.push(definition) },
+    on() {},
+  })
+  return captured
+}
+
+const writeTool = (captured) => captured.tools.find((tool) => tool.name === 'memory_write')
+const fakeExec = (captured) => ({
+  agent: { session: { id: 'sess-test-1' }, options: { model: 'deepseek-flash' } },
+})
+
+// ── supersede 语义 ──────────────────────────────────────────────────────────
+
+test('supersede：旧条目消失、新条目就位，只留一条', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({ type: 'project', dir, line: '- [project] 下一步 S3 — project.md' })
+    const result = writeMemory({
+      type: 'project',
+      dir,
+      line: '- [project] 下一步 S4 — project.md',
+      supersedes: '下一步 S3',
+    })
+
+    assert.equal(result.superseded, '- [project] 下一步 S3 — project.md')
+    const index = readFileSync(result.path, 'utf8')
+    assert.doesNotMatch(index, /S3/)
+    assert.match(index, /S4/)
+    assert.equal(index.split('\n').filter((line) => line.startsWith('- [')).length, 1)
+  } finally {
+    box.cleanup()
+  }
+})
+
+test('supersede 匹配不到时报错，并提示怎么查原文', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({ type: 'project', dir, line: '- [project] 甲 — project.md' })
+    assert.throws(
+      () => writeMemory({ type: 'project', dir, line: '- [project] 乙 — project.md', supersedes: '不存在' }),
+      /没匹配到/,
+    )
+    // 失败不应改动索引
+    const index = readFileSync(join(dir, 'MEMORY.md'), 'utf8')
+    assert.match(index, /甲/)
+    assert.doesNotMatch(index, /乙/)
+  } finally {
+    box.cleanup()
+  }
+})
+
+test('supersede 匹配到多条时拒绝猜测，并把候选列出来', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({ type: 'project', dir, line: '- [project] E01 完成 — project.md' })
+    writeMemory({ type: 'project', dir, line: '- [project] E02 待办 — project.md' })
+    assert.throws(
+      () => writeMemory({ type: 'project', dir, line: '- [project] 新 — project.md', supersedes: 'E0' }),
+      (error) => /匹配到 2 条/.test(error.message) && /E01/.test(error.message),
+    )
+  } finally {
+    box.cleanup()
+  }
+})
+
+test('supersede 跨类型时也把条目挪到新分节', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({ type: 'user', dir, line: '- [user] 旧偏好 — user.md' })
+    const result = writeMemory({
+      type: 'feedback',
+      dir,
+      line: '- [feedback] 旧偏好被纠正 — feedback.md',
+      supersedes: '旧偏好',
+    })
+    const lines = readFileSync(result.path, 'utf8').split('\n')
+    const section = lines.indexOf('## feedback')
+    const entry = lines.findIndex((line) => line.includes('旧偏好被纠正'))
+    assert.ok(section >= 0 && entry > section, '应落在 feedback 分节内')
+    assert.ok(!lines.some((line) => line.includes('- [user] 旧偏好')), '旧条目应已移除')
+  } finally {
+    box.cleanup()
+  }
+})
+
+// ── 来源标记（审计即账本） ──────────────────────────────────────────────────
+
+test('审计记下来源会话、模型、写入行与被取代的行', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({
+      type: 'project',
+      dir,
+      line: '- [project] 旧 — project.md',
+      provenance: { sessionId: 'sess-abc', model: 'deepseek-flash', via: 'memory_write' },
+    })
+    writeMemory({
+      type: 'project',
+      dir,
+      line: '- [project] 新 — project.md',
+      supersedes: '旧',
+      provenance: { sessionId: 'sess-abc', model: 'deepseek-flash', via: 'memory_write' },
+    })
+
+    const events = readFileSync(join(dir, '.audit.jsonl'), 'utf8')
+      .trim()
+      .split('\n')
+      .map((line) => JSON.parse(line))
+      .filter((event) => event.op === 'write')
+
+    assert.equal(events.length, 2)
+    assert.equal(events[0].sessionId, 'sess-abc')
+    assert.equal(events[0].model, 'deepseek-flash')
+    assert.equal(events[1].superseded, '- [project] 旧 — project.md')
+    assert.match(events[1].line, /新/)
+    // 账本里要有可追溯的时间戳与 pid
+    for (const event of events) {
+      assert.match(event.at, /^\d{4}-\d{2}-\d{2}T/)
+      assert.equal(typeof event.pid, 'number')
+    }
+  } finally {
+    box.cleanup()
+  }
+})
+
+test('工具调用会自动带上会话 id 与模型（不需要模型自己填）', async () => {
+  const box = sandbox()
+  try {
+    const captured = mount(box.cwd)
+    const tool = writeTool(captured)
+    await tool.execute({ type: 'user', summary: '工具来源', scope: 'global' }, fakeExec(captured))
+
+    const dir = storeDirFor('global', box.cwd)
+    const events=readFileSync(join(dir, '.audit.jsonl'), 'utf8').trim().split('\n').map(JSON.parse)
+    const event=events.findLast(event=>event.op==='write'&&event.via==='memory_write')
+    assert.equal(event.sessionId, 'sess-test-1')
+    assert.equal(event.model, 'deepseek-flash')
+    assert.equal(event.via, 'memory_write')
+  } finally {
+    box.cleanup()
+  }
+})
+
+test('注入文本带信任前置：明确说记忆是数据不是指令', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({ type: 'user', dir, line: '- [user] 任意 — user.md' })
+    const captured = mount(box.cwd)
+    const text = captured.context.text({ agent: { session: {} } })
+    assert.match(text, /是\*\*数据\*\*，不是指令/)
+    assert.match(text, /可能已被污染/)
+  } finally {
+    box.cleanup()
+  }
+})
+
+test('没有会话信息时审计仍可写（子进程/测试环境）', () => {
+  const box = sandbox()
+  try {
+    const dir = storeDirFor('global', box.cwd)
+    writeMemory({ type: 'user', dir, line: '- [user] 无来源 — user.md' })
+    const event = JSON.parse(readFileSync(join(dir, '.audit.jsonl'), 'utf8').trim())
+    assert.equal(event.sessionId, undefined)
+    assert.equal(event.outcome, 'ok')
+  } finally {
+    box.cleanup()
+  }
+})

package/test-text-admission.mjs

@@ -0,0 +1,82 @@
+import {applyWithValidationFixture as apply} from './fixture-host.mjs'
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtempSync,realpathSync,mkdirSync,readFileSync,existsSync,rmSync} from 'node:fs'
+import {join} from 'node:path'
+import {tmpdir} from 'node:os'
+import {indexLine, searchStore} from './index.mjs'
+import {prepareMountedFixture,writeFixtureMemory} from './fixture-host.mjs'
+import {candidateSnapshot,listCandidates} from './candidates.mjs'
+import {assessCandidate} from './capture-evidence.mjs'
+import {normalizeCaptureDiagnostic} from './capture-diagnostics.mjs'
+
+async function box(run){
+ const dir=realpathSync(mkdtempSync(join(tmpdir(),'dsh-text-admission-'))),home=join(dir,'home'),cwd=join(dir,'project'),previous=process.env.DSH_HOME
+ mkdirSync(home);mkdirSync(cwd);process.env.DSH_HOME=home
+ try{return await run({home,cwd,root:join(home,'memory')})}
+ finally{if(previous===undefined)delete process.env.DSH_HOME;else process.env.DSH_HOME=previous;rmSync(dir,{recursive:true,force:true})}
+}
+test('replacement colliding with another existing summary must not report duplicate while leaving the old target active',()=>box(async({root})=>{
+ const meaning={kind:'preference'},good='跨项目评审先列最重要的两处问题再给办法',bad='跨项目评审先列问题并说明未约定的全部后果'
+ writeFixtureMemory({dir:root,type:'user',scope:'global',summary:good,meaning})
+ const old=writeFixtureMemory({dir:root,type:'user',scope:'global',summary:bad,meaning})
+ const before=readFileSync(join(root,'MEMORY.md'),'utf8'),ledger=readFileSync(join(root,'.candidates.json'),'utf8')
+ assert.throws(()=>writeFixtureMemory({dir:root,type:'user',scope:'global',summary:good,meaning,supersedes:old.indexLine}),e=>e.code==='memory-meaning-duplicate-needs-distinct-summary')
+ assert.equal(readFileSync(join(root,'MEMORY.md'),'utf8'),before);assert.equal(readFileSync(join(root,'.candidates.json'),'utf8'),ledger)
+}))
+test('an explicitly different typed detail cannot silently return duplicate and discard the proposed correction',()=>box(async({root})=>{
+ const meaning={kind:'preference'},summary='评审先列两处问题再给修改办法'
+ const old=writeFixtureMemory({dir:root,type:'user',scope:'global',summary,meaning,detail:'Synthetic original detail with an extra requirement.'})
+ const before=readFileSync(join(root,'user.md'),'utf8')
+ assert.throws(()=>writeFixtureMemory({dir:root,type:'user',scope:'global',summary,meaning,detail:'Synthetic source-faithful corrected detail.',supersedes:old.indexLine}),e=>e.code==='memory-meaning-duplicate-needs-distinct-summary')
+ assert.equal(readFileSync(join(root,'user.md'),'utf8'),before)
+ const duplicate=writeFixtureMemory({dir:root,type:'user',scope:'global',summary,meaning,detail:'Synthetic original detail with an extra requirement.'})
+ assert.equal(duplicate.duplicate,true)
+}))
+test('native write advertises mandatory meaning and rejects missing meaning before persistence',()=>box(async({home,cwd,root})=>{
+ const tools=[],handlers=[]
+ apply({systemPrompt:{context(){}},workingDirectory:{get(){return cwd}},tools:{register(tool){tools.push(tool)}},on(name,handler){handlers.push([name,handler])}},{autoCapture:{enabled:false}})
+ const tool=tools.find(tool=>tool.name==='memory_write')
+ assert.ok(tool.parameters.required.includes('meaning'))
+ // A missing owner is still rejected by the source guard; a schema declaration is not permission to write.
+ await assert.rejects(tool.execute({type:'user',scope:'global',summary:'没有归属来源的长期身份'}),/source-unavailable/)
+ assert.equal(existsSync(join(root,'MEMORY.md')),false)
+}))
+for(const mode of ['changed-conditions','same-conditions','invalid-relations'])test('automatic duplicate interpretation: '+mode,()=>box(async({cwd,root})=>{
+ const summary='跨所有项目的初稿统一使用默认标记 olive-synthetic24'
+ const meaning={kind:'preference',conditions:[{dimension:'document_kind',value:'draft'}]}
+ writeFixtureMemory({dir:root,type:'user',scope:'global',summary,line:indexLine('user',summary),detail:'Synthetic source fixes this choice to drafts, not finished documents.',meaning})
+ prepareMountedFixture()
+ const beforeIndex=readFileSync(join(root,'MEMORY.md'),'utf8'),beforeDetail=readFileSync(join(root,'user.md'),'utf8')
+ const tools=[],handlers=[],session={id:'text-duplicate-'+mode}
+ const ctx={systemPrompt:{context(){}},workingDirectory:{get(){return cwd}},tools:{register(tool){tools.push(tool)}},on(name,handler){handlers.push([name,handler])},llm:{async listProviders(){return[{provider:'fixture',model:'fixture'}]},async prepareCall(){return{config:{},async *stream(request){
+  const prompt=request.messages[0].content[0].text,message=prompt.split('\n').flatMap(line=>{try{const item=JSON.parse(line);return item.role==='user'?[item]:[]}catch{return[]}}).at(-1)
+  const proposed=mode==='same-conditions'?meaning:mode==='invalid-relations'?{kind:'belief',relations:[{target:'b'.repeat(64),stance:'supports'}]}:{kind:'preference'}
+  yield{type:'text-delta',text:JSON.stringify([{type:'user',scope:'global',basis:'explicit',summary,meaning:proposed,evidence:[{messageId:message.id,quote:message.text}]}])};yield{type:'finish',reason:{kind:'stop'}}
+ }}}}}
+ apply(ctx,{autoCapture:{everyTurns:1}})
+ const emit=event=>{for(const [name,handler] of handlers)if(name==='session/event')handler(session,event)}
+ emit({type:'user/message',data:{message:{source:{kind:'user'},content:[{type:'text',text:'我的初稿长期使用默认标记 olive-synthetic24，跨所有项目适用。'}]}}})
+ emit({type:'step/end',data:{}})
+ let state;const until=Date.now()+4000
+ while(Date.now()<until){try{state=JSON.parse(readFileSync(join(root,'.capture-state.json')))}catch{}if(state?.lastCaptureAt&&!state.running)break;await new Promise(resolve=>setTimeout(resolve,20))}
+ assert.equal(state?.running,false);const diagnostic=normalizeCaptureDiagnostic(state.diagnostic)
+ assert.equal(readFileSync(join(root,'MEMORY.md'),'utf8'),beforeIndex)
+ assert.equal(readFileSync(join(root,'user.md'),'utf8'),beforeDetail)
+ const records=candidateSnapshot(root,'global').records
+ assert.equal(records.filter(record=>['recorded','adopted'].includes(record.status)).length,1)
+ assert.deepEqual(records.find(record=>record.status==='recorded').meaning.conditions,meaning.conditions)
+ const hit=searchStore(root,'olive-synthetic24',{context:{document_kind:'final'}})
+ assert.equal(hit.hits.length,0,'A staged broader interpretation must not become effective')
+ if(mode==='changed-conditions'){
+  assert.equal(diagnostic.classification,'pending-review');assert.equal(diagnostic.staged,1);assert.equal(diagnostic.writeFailures,0)
+  assert.equal(listCandidates(root).total,1)
+  assert.ok(readFileSync(join(root,'.audit.jsonl'),'utf8').includes('duplicate-meaning-needs-review'))
+ }else if(mode==='same-conditions'){
+  assert.equal(diagnostic.classification,'already-known');assert.equal(diagnostic.duplicates,1);assert.equal(listCandidates(root).total,0)
+ }else{
+  assert.equal(diagnostic.classification,'admission-rejected');assert.equal(diagnostic.admissionRejected,1);assert.equal(listCandidates(root).total,0)
+ }
+}))
+
+test('automatic source-grounded text cannot become effective without explicit meaning',()=>{const message={id:'synthetic-owner',role:'user',text:'我的长期署名是合成玉叶',hash:'a'.repeat(64)},candidate={type:'user',scope:'global',basis:'explicit',summary:'长期署名合成玉叶',evidence:[{messageId:message.id,quote:message.text}]};assert.equal(assessCandidate(candidate,[message],false).reason,'invalid-meaning');assert.equal(assessCandidate({...candidate,meaning:{kind:'claim'}},[message],false).status,'eligible');assert.equal(assessCandidate({...candidate,basis:'inferred'},[message],false).reason,'invalid-meaning')})

package/test-tool-inputs.mjs

@@ -0,0 +1,13 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {createToolInputTracker} from './tool-inputs.mjs'
+const message=(id,kind='user')=>({id,role:'user',source:{kind},content:[{type:'text',text:'Synthetic owner statement '+id}]})
+function fixture(){const tracker=createToolInputTracker(),session={id:'synthetic-session'},agent={session};return{tracker,session,agent,pre:(turn,step,messages)=>tracker.preStep({agent,turn,step,messages}),admit:(m,seq)=>tracker.event(session,{type:'user/message',seq,data:m}),call:(callId,seq,turn=1,step=1)=>tracker.event(session,{type:'tool/call',seq,data:{callId,turn,step}}),exec:callId=>tracker.forExecution({agent,callId})}}
+test('native call binds to the admitted owner event sequence and declares context-only basis',()=>{const f=fixture(),m=message('a');f.pre(1,1,[m]);f.admit(m,10);f.call('call',11);const proof=f.exec('call');assert.equal(proof.basis,'tool-context');assert.equal(proof.evidence[0].messageId,'synthetic-session:10');assert.match(proof.evidence[0].hash,/^[a-f0-9]{64}$/);assert.match(proof.evidence[0].quote,/owner statement/);assert.equal(JSON.stringify(proof).includes('Synthetic owner statement a'),true)})
+test('a queued or later admitted owner message cannot become evidence for an earlier call',()=>{const f=fixture(),a=message('a'),b=message('b');f.pre(1,1,[a]);f.admit(a,10);f.call('call',11);f.admit(b,12);f.pre(2,1,[b]);assert.deepEqual(f.exec('call').evidence.map(e=>e.messageId),['synthetic-session:10'])})
+test('unadmitted, assistant and synthetic sources do not establish owner evidence',()=>{for(const kind of ['plugin','runtime-context']){const f=fixture(),m=message('a',kind);f.pre(1,1,[m]);f.admit(m,10);f.call('call',11);assert.throws(()=>f.exec('call'),/source-unavailable/)}const f=fixture();f.pre(1,1,[message('a')]);f.call('call',11);assert.throws(()=>f.exec('call'),/source-unavailable/)})
+test('later steps retain roots admitted in the same turn and include a claimed steering input only afterwards',()=>{const f=fixture(),a=message('a'),b=message('b');f.pre(1,1,[a]);f.admit(a,10);f.call('first',11);f.pre(1,2,[b]);f.admit(b,12);f.call('second',13,1,2);assert.equal(f.exec('first').evidence.length,1);assert.equal(f.exec('second').evidence.length,2);f.pre(1,3,[]);f.call('third',14,1,3);assert.equal(f.exec('third').evidence.length,2)})
+test('nested tool execution binds to its native root call and other sessions cannot borrow it',()=>{const f=fixture(),m=message('a');f.pre(1,1,[m]);f.admit(m,10);f.call('outer',11);assert.equal(f.tracker.forExecution({agent:f.agent,callId:'nested',rootCallId:'outer'}).evidence.length,1);assert.throws(()=>f.tracker.forExecution({agent:{session:{id:f.session.id}},callId:'outer'}),/source-unavailable/)})
+test('duplicate native call IDs do not advance the source cutoff',()=>{const f=fixture(),a=message('a'),b=message('b');f.pre(1,1,[a]);f.admit(a,10);f.call('call',11);f.pre(1,2,[b]);f.admit(b,12);f.call('call',13,1,2);assert.deepEqual(f.exec('call').evidence.map(e=>e.messageId),['synthetic-session:10'])})
+test('overflow fails closed instead of silently choosing a subset of owner roots',()=>{const f=fixture(),messages=Array.from({length:4},(_,i)=>message('m'+i));f.pre(1,1,messages);messages.forEach((m,i)=>f.admit(m,i+1));f.call('call',10);assert.throws(()=>f.exec('call'),/source-unavailable/);f.pre(2,1,Array.from({length:65},(_,i)=>message('x'+i)));f.call('overflow',100,2,1);assert.throws(()=>f.exec('overflow'),/source-unavailable/)})
+test('disposal and cancellation invalidate live write lineage',()=>{const f=fixture(),m=message('a');f.pre(1,1,[m]);f.admit(m,10);f.call('call',11);const abort=new AbortController();abort.abort();assert.throws(()=>f.tracker.forExecution({agent:f.agent,callId:'call',signal:abort.signal}),/abort/i);f.tracker.disposeSession(f.session);assert.throws(()=>f.exec('call'),/source-unavailable/)})

package/test-tool-observations.mjs

@@ -0,0 +1,124 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtempSync,realpathSync,mkdirSync,readFileSync,writeFileSync,rmSync} from 'node:fs'
+import {join} from 'node:path'
+import {tmpdir} from 'node:os'
+import {createHash} from 'node:crypto'
+import {createToolInputTracker} from './tool-inputs.mjs'
+import {createObservationTracker,normalizeObservationCertificate,observationRoots,argumentFingerprint} from './tool-observations.mjs'
+import {apply,searchStore,withdrawManagedSource,indexLine} from './index.mjs'
+import {candidateSnapshot} from './candidates.mjs'
+import {prepareSourceRetirement,validateRetiredSource} from './source-retirement.mjs'
+import {writeFixtureMemory,scriptedNativeValidationLlm} from './fixture-host.mjs'
+const hash=value=>createHash('sha256').update(value).digest('hex')
+function fixture(){
+ const inputs=createToolInputTracker(),session={id:'native-observation-session',deriveMessages:()=>messages},agent={session},obs=createObservationTracker((session,callId)=>inputs.forExecution({agent:{session},callId})),messages=[]
+ const pre=(turn=1,step=1,claimed=[])=>{const input={agent,turn,step,messages:claimed};inputs.preStep(input);obs.preStep(input)}
+ const emit=event=>{inputs.event(session,event);obs.event(session,event)}
+ const owner={id:'owner-message',role:'user',source:{kind:'user'},content:[{type:'text',text:'Please check the controlled measurement and keep its output.'}]}
+ pre(1,1,[owner]);emit({type:'user/message',seq:1,data:owner});messages.push(owner)
+ const call=(callId='measure-1',at=2,name='fixture_measure',turn=1,step=1)=>emit({type:'tool/call',seq:at,data:{callId,name,arguments:'{"sample":"A"}',turn,step}})
+ const result=(patch={})=>{const message={id:'result-message',role:'tool',source:{kind:'tool',callId:'measure-1'},toolCallId:'measure-1',content:[{type:'text',text:'controlled_measurement=40'}],...patch.message};const event={type:'tool/result',seq:3,surfaceOp:'append',sourceEventSeqs:[2],data:{turn:1,step:1,message,...patch.data},...patch.event};emit(event);messages.push(event.data.message);return event}
+ const request=()=>obs.request({sessionId:session.id,tools:[{name:'memory_write'}],messages})
+ const ready=()=>{pre(1,2);request();call('save',4,'memory_write',1,2)}
+ const exec=reference=>obs.forExecution({agent,callId:'save'},reference??{callId:'measure-1',quote:'controlled_measurement=40'},inputs.forExecution({agent,callId:'save'}))
+ return{inputs,obs,session,agent,messages,pre,emit,call,result,request,ready,exec}
+}
+test('native event, result ancestry, actual model-visible quote and current surface are all required',()=>{
+ const f=fixture();f.call();f.result();f.ready();const proof=f.exec()
+ assert.equal(proof.observation.kind,'native-tool-result');assert.equal(proof.observation.outcome,'succeeded');assert.equal(proof.observation.quote,'controlled_measurement=40');assert.equal(proof.evidence[0].messageId,f.session.id+':1');assert.equal(observationRoots(proof.observation).length,2)
+ assert.throws(()=>f.exec({callId:'measure-1',quote:'controlled_measurement=70'}),/quote-not-in-result/)
+ assert.throws(()=>f.exec({callId:'measure-1',quote:'40',verified:true}),/invalid-reference/)
+})
+test('pending calls, missing ancestry, result-before-call, forged source and unseen outputs fail closed',()=>{
+ for(const variant of ['pending','ancestry','ordering','source','unseen']){
+  const f=fixture();f.call();if(variant!=='pending')f.result(variant==='ancestry'?{event:{sourceEventSeqs:[1]}}:variant==='ordering'?{event:{seq:1}}:variant==='source'?{message:{source:{kind:'assistant'}}}:{})
+  f.pre(1,2);if(variant!=='unseen')f.request();f.call('save',4,'memory_write',1,2)
+  assert.throws(()=>f.exec(),/source-unavailable/)
+ }
+})
+test('tool error is a checked error output, never a successful measurement',()=>{
+ const f=fixture();f.call();f.result({message:{isError:true,content:[{type:'text',text:'controlled_measurement=40'}]},data:{error:{code:'SYNTHETIC_FAILURE'}}});f.ready();assert.equal(f.exec().observation.outcome,'error')
+})
+test('memory output, duplicate call/result identities and unsafe/oversized payloads cannot be laundered as observations',()=>{
+ for(const variant of ['memory','duplicate-call','duplicate-result','oversize','nontext','secret']){
+  const f=fixture();f.call('measure-1',2,variant==='memory'?'memory_search':'fixture_measure')
+  const patch=variant==='oversize'?{message:{content:[{type:'text',text:'x'.repeat(16385)}]}}:variant==='nontext'?{message:{content:[{type:'image',data:'synthetic'}]}}:variant==='secret'?{message:{content:[{type:'text',text:'OPENAI_API_KEY=sk-synthetic123456789012345678901234567890'}]}}:{}
+  f.result(patch);if(variant==='duplicate-call')f.call('measure-1',4);if(variant==='duplicate-result')f.result({event:{seq:4}});f.pre(1,2);f.request();f.call('save',5,'memory_write',1,2);assert.throws(()=>f.exec(),/source-unavailable/)
+ }
+})
+test('shadowed or mutated results cannot be used even if a previous request contained the original text',()=>{
+ for(const variant of ['mutation','replacement','removal']){
+  const f=fixture();f.call();f.result();f.ready()
+  if(variant==='mutation')f.messages[1]={...f.messages[1],content:[{type:'text',text:'changed_measurement=70'}]}
+  if(variant==='replacement')f.emit({type:'tool/result',seq:5,surfaceOp:{op:'replace',startSeq:3,endSeq:3},sourceEventSeqs:[3],data:{message:{}}})
+  if(variant==='removal')f.messages.splice(1,1)
+  assert.throws(()=>f.exec(),/source-unavailable|surface-changed/)
+ }
+})
+test('other sessions, stale request steps, disposal and cancellation cannot reuse a live certificate',()=>{
+ const f=fixture();f.call();f.result();f.ready();const owner=f.inputs.forExecution({agent:f.agent,callId:'save'})
+ assert.throws(()=>f.obs.forExecution({agent:{session:{id:f.session.id}},callId:'save'},{callId:'measure-1',quote:'40'},owner),/source-unavailable/)
+ f.pre(1,3);f.call('later',5,'memory_write',1,3);assert.throws(()=>f.obs.forExecution({agent:f.agent,callId:'later'},{callId:'measure-1',quote:'40'},owner),/source-unavailable/)
+ const abort=new AbortController();abort.abort();assert.throws(()=>f.obs.forExecution({agent:f.agent,callId:'save',signal:abort.signal},{callId:'measure-1',quote:'40'},owner),/abort/i)
+ f.obs.dispose();assert.throws(()=>f.exec(),/disposed/)
+})
+async function box(run){
+ const base=realpathSync(mkdtempSync(join(tmpdir(),'dsh-native-output-'))),home=join(base,'home'),cwd=join(base,'project'),previous=process.env.DSH_HOME;mkdirSync(home);mkdirSync(cwd);process.env.DSH_HOME=home
+ const handlers=[],tools=[],effects=[],ctx={llm:scriptedNativeValidationLlm(),systemPrompt:{context(entry){ctx.context=entry}},workingDirectory:{get(){return cwd}},tools:{register(tool){tools.push(tool)}},on(name,handler){handlers.push([name,handler])},effect(fn){const dispose=fn();if(typeof dispose==='function')effects.push(dispose)}}
+ try{apply(ctx,{autoCapture:{enabled:false,provider:'fixture',model:'fixture'}});await run({root:join(home,'memory'),ctx,handlers,tools})}finally{for(const dispose of effects)dispose();if(previous===undefined)delete process.env.DSH_HOME;else process.env.DSH_HOME=previous;rmSync(base,{recursive:true,force:true})}
+}
+async function observedWrite(f,{summary='执行观察：控制读数为40',target,callId='measure-live',at=2,output='controlled_measurement=40',error=false}={}){
+ const {handlers,tools}=f,emit=(name,...args)=>{for(const [event,handler]of handlers)if(event===name)handler(...args)},messages=[],session=f.session??(f.session={id:'native-live',deriveMessages:()=>messages}),agent={session};if(f.sessionMessages)messages.push(...f.sessionMessages)
+ session.deriveMessages=()=>messages;f.sessionMessages=messages
+ const owner={id:'owner-'+at,role:'user',source:{kind:'user'},content:[{type:'text',text:'Keep this controlled execution observation '+at}]}
+ emit('agent/pre-step',{agent,turn:at,step:1,messages:[owner]},()=>{});emit('session/event',session,{type:'user/message',seq:at*10,data:owner});messages.push(owner)
+ emit('session/event',session,{type:'tool/call',seq:at*10+1,data:{callId,name:'fixture_measure',arguments:'{"sample":"A"}',turn:at,step:1}})
+ const result={id:'result-'+at,role:'tool',source:{kind:'tool',callId},toolCallId:callId,content:[{type:'text',text:output}],...error?{isError:true}:{}}
+ emit('session/event',session,{type:'tool/result',seq:at*10+2,surfaceOp:'append',sourceEventSeqs:[at*10+1],data:{turn:at,step:1,message:result}});messages.push(result)
+ emit('agent/pre-step',{agent,turn:at,step:2,messages:[]},()=>{});emit('llm/stream',{sessionId:session.id,tools:[{name:'memory_write'}],messages},()=>{})
+ emit('session/event',session,{type:'tool/call',seq:at*10+3,data:{callId:'save-'+at,name:'memory_write',arguments:'{}',turn:at,step:2}})
+ return tools.find(tool=>tool.name==='memory_write').execute({type:'reference',scope:'global',summary,observation:{callId,quote:output},meaning:{kind:'episode',...target?{relations:[{target,stance:'contradicts'}]}:{}}},{agent,callId:'save-'+at})
+}
+test('SDK observed write publishes certificate and owner/call/result roots; current and historical output keep the verification boundary',()=>box(async f=>{
+ await observedWrite(f);const record=candidateSnapshot(f.root,'global').records[0];assert.equal(record.sources.length,3);assert.equal(record.observation.outcome,'succeeded');assert.equal(record.evidence[0].messageId,'native-live:20')
+ for(const view of ['current','history']){const hit=searchStore(f.root,'执行观察',{view}).hits[0];assert.equal(hit.interpretation.observation.quoteChecked,true);assert.equal(hit.interpretation.observation.currentWorldStateVerified,false)}
+ assert.throws(()=>normalizeObservationCertificate({...record.observation,worldVerified:true},record.sessionId),/invalid-certificate/)
+}))
+for(const state of ['unsupported','uncertain'])test('an '+state+' checked observation is never staged without its execution certificate',()=>box(async f=>{
+ f.ctx.llm=scriptedNativeValidationLlm(state)
+ const result=await observedWrite(f);assert.equal(result.status,state==='unsupported'?'rejected':'not-applied');assert.equal(candidateSnapshot(f.root,'global').records.length,0);assert.equal(searchStore(f.root,'执行观察').hits.length,0)
+}))
+for(const at of [20,21,22])test('withdrawing '+at+' (owner/call/result) removes observed evidence even after restoring old files',()=>box(async f=>{
+ await observedWrite(f);const backup=new Map(['MEMORY.md','.candidates.json','.episodes.json'].map(name=>[name,readFileSync(join(f.root,name))]))
+ const p=withdrawManagedSource(f.root,'native-live','native-live:'+at);withdrawManagedSource(f.root,'native-live','native-live:'+at,{apply:true,controlReview:p.controlReview});assert.equal(searchStore(f.root,'执行观察').hits.length,0)
+ for(const [name,body]of backup)writeFileSync(join(f.root,name),body)
+ assert.equal(searchStore(f.root,'执行观察').hits.length,0);assert.equal(searchStore(f.root,'执行观察',{view:'history'}).hits.length,0)
+}))
+test('identical executed reads do not multiply support; execution errors cannot become counterevidence',()=>box(async f=>{
+ writeFixtureMemory({type:'user',scope:'global',dir:f.root,line:indexLine('user','待验证的设备读数假设为70'),meaning:{kind:'belief'}})
+ const target=candidateSnapshot(f.root,'global').records[0].id
+ await observedWrite(f,{target});await observedWrite(f,{target,summary:'再次读取同一受控工具结果仍为40',callId:'measure-second',at:3})
+ const view=searchStore(f.root,'设备读数假设',{task:{affectsDecision:true}}).hits[0].interpretation;assert.equal(view.revision.state,'challenged');assert.equal(view.revision.counterSourceGroups,1);assert.equal(view.revision.nativeOutputRecords,2);assert.equal(view.revision.worldVerified,false)
+ await assert.rejects(observedWrite(f,{target,summary:'失败结果不证明读数与假设矛盾',callId:'measure-error',at:4,error:true}),/invalid-observation-role/)
+ await observedWrite(f,{summary:'工具失败的原生记录仅用于诊断',callId:'measure-error-other',at:5,error:true});assert.equal(searchStore(f.root,'仅用于诊断').hits[0].interpretation.observation.outcome,'error')
+}))
+test('all three original owner roots plus execution call/result survive publication and bounded retirement',()=>box(async f=>{
+ const g=fixture(),owners=[2,3].map(at=>({id:'owner-'+at,role:'user',source:{kind:'user'},content:[{type:'text',text:'Controlled steering input '+at}]}))
+ g.pre(1,1,owners);owners.forEach((owner,i)=>g.emit({type:'user/message',seq:i+2,data:owner}));g.call('measure-1',4);g.result({event:{seq:5,sourceEventSeqs:[4]}});g.pre(1,2);g.request();g.call('save',6,'memory_write',1,2)
+ const proof=g.exec();assert.equal(proof.evidence.length,3)
+ writeFixtureMemory({type:'reference',scope:'global',dir:f.root,line:indexLine('reference','多来源原生观察需要保留全部五个撤回根'),meaning:{kind:'episode'},provenance:proof})
+ const state=JSON.parse(readFileSync(join(f.root,'.candidates.json')));assert.equal(state.records[0].sources.length,5)
+ prepareSourceRetirement(f.root,state,{force:true,indexText:'# empty after removal'});assert.equal(state.retired.length,1);assert.equal(validateRetiredSource(state.retired[0]).sources.length,5)
+}))
+
+test('available references expose actual visible call IDs without treating discovery as proof or executing a tool',()=>{
+ const f=fixture();f.call('transport-generated-A92',2);f.result({message:{source:{kind:'tool',callId:'transport-generated-A92'},toolCallId:'transport-generated-A92'}});f.pre(1,2);f.request();f.call('status',4,'memory_status',1,2)
+ const list=f.obs.availableForExecution({agent:f.agent,callId:'status'});assert.equal(list.items[0].callId,'transport-generated-A92');assert.equal(list.items[0].quotePreview,'controlled_measurement=40');assert.equal(list.items[0].outcome,'succeeded');assert.equal(list.truncated,false)
+ f.messages.splice(1,1);assert.equal(f.obs.availableForExecution({agent:f.agent,callId:'status'}).items.length,0)
+})
+test('equivalent JSON arguments share an execution identity despite whitespace or object-key order',()=>{
+ assert.equal(argumentFingerprint('{ "b":2,"a":{"y":1,"x":0} }'),argumentFingerprint({a:{x:0,y:1},b:2}))
+ assert.notEqual(argumentFingerprint('{"reading":40}'),argumentFingerprint('{"reading":70}'))
+ let nested={};for(let i=0;i<20;i++)nested={nested};assert.throws(()=>argumentFingerprint(nested),/arguments-too-complex/)
+})

package/test-tool-write-guard.mjs

@@ -0,0 +1,23 @@
+import {realpathSync} from 'node:fs'
+/** Direct SDK-facing tool tests. No fixture wrapper manufactures authorization. */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtempSync,mkdirSync,rmSync,existsSync,readFileSync} from 'node:fs'
+import {join} from 'node:path'
+import {tmpdir} from 'node:os'
+import {apply,storeDirFor} from './index.mjs'
+import {candidateSnapshot} from './candidates.mjs'
+import {scriptedNativeValidationLlm} from './fixture-host.mjs'
+async function box(run){const root=realpathSync(mkdtempSync(join(tmpdir(),'tool-write-guard-'))),home=join(root,'home'),previous=process.env.DSH_HOME;mkdirSync(home);process.env.DSH_HOME=home;const handlers=[],tools=[],effects=[],ctx={llm:scriptedNativeValidationLlm(),systemPrompt:{context(){}},workingDirectory:{get:()=>root},tools:{register:tool=>tools.push(tool)},on:(name,handler)=>handlers.push([name,handler]),effect:fn=>{const dispose=fn();if(typeof dispose==='function')effects.push(dispose)}};apply(ctx,{autoCapture:{enabled:false}});const session={id:'synthetic-owner-session'},agent={session,options:{provider:'fixture',model:'synthetic'}},tool=tools.find(tool=>tool.name==='memory_write'),emit=(name,...args)=>{for(const [event,handler] of handlers)if(event===name)handler(...args)},input={id:'owner-input',source:{kind:'user'},role:'user',content:[{type:'text',text:'Synthetic owner statement jade9876'}]},exec={agent,callId:'native-call',rootCallId:'native-call'};const admit=()=>{emit('agent/pre-step',{agent,turn:1,step:1,messages:[input]},()=>({kind:'enter'}));emit('session/event',session,{type:'user/message',seq:10,data:input});emit('session/event',session,{type:'tool/call',seq:11,data:{turn:1,step:1,callId:'native-call'}})};try{return await run({root,dir:join(home,'memory'),tool,exec,emit,input,admit,effects,session})}finally{for(const dispose of effects)dispose();if(previous===undefined)delete process.env.DSH_HOME;else process.env.DSH_HOME=previous;rmSync(root,{recursive:true,force:true})}}
+const args={meaning:{kind:'claim'},type:'user',scope:'global',summary:'Synthetic selected jade9876',detail:'Synthetic detail jade9876'}
+test('SDK tool rejects missing owner history, actor and forged model-supplied evidence',()=>box(async f=>{for(const exec of [f.exec,{}, {agent:{session:{id:'synthetic-other'}}}])await assert.rejects(()=>f.tool.execute({...args,evidence:[{messageId:'forged'}]},exec),/source-unavailable/);assert.equal(existsSync(join(f.dir,'MEMORY.md')),false)}))
+test('SDK tool records native sequence-derived provenance without accepting model-supplied source fields',()=>box(async f=>{f.admit();await f.tool.execute(args,f.exec);const record=candidateSnapshot(f.dir,'global').records[0];assert.equal(record.origin,'tool-context');assert.equal(record.status,'recorded');assert.equal(record.evidence[0].messageId,'synthetic-owner-session:10');assert.equal(record.evidence[0].quote,'Synthetic owner statement jade9876');assert.match(readFileSync(join(f.dir,'user.md'),'utf8'),/candidate:/)}))
+test('unclaimed owner events and non-owner claimed messages cannot authorize memory_write',()=>box(async f=>{f.emit('session/event',f.session,{type:'user/message',seq:10,data:f.input});f.emit('session/event',f.session,{type:'tool/call',seq:11,data:{turn:1,step:1,callId:'native-call'}});await assert.rejects(()=>f.tool.execute(args,f.exec),/source-unavailable/)}))
+test('project decisions cannot silently enter the global library',()=>box(async f=>{f.admit();await assert.rejects(()=>f.tool.execute({...args,type:'project'},f.exec),/project 类型必须/);assert.equal(existsSync(join(f.dir,'MEMORY.md')),false)}))
+test('source tracking is required even when auto capture is disabled',()=>box(async f=>{await assert.rejects(()=>f.tool.execute(args,f.exec),/source-unavailable/);f.admit();await f.tool.execute(args,f.exec);assert.equal(candidateSnapshot(f.dir,'global').records.length,1)}))
+test('short Chinese owner input is valid lineage and uses the scripted semantic acceptance',()=>box(async f=>{f.input.content[0].text='记住红色';f.admit();await f.tool.execute(args,f.exec);const record=candidateSnapshot(f.dir,'global').records[0];assert.equal(record.evidence[0].quote,'记住红色');assert.equal(record.origin,'tool-context');assert.equal(record.status,'recorded')}))
+test('unload refuses a previously authorized tool before any local publication',()=>box(async f=>{f.admit();for(const dispose of f.effects)dispose();await assert.rejects(()=>f.tool.execute(args,f.exec),/inputs-disposed/);assert.equal(existsSync(join(f.dir,'MEMORY.md')),false)}))
+test('cancellation and non-interactive inherited sessions cannot write new source records',()=>box(async f=>{f.admit();const abort=new AbortController();abort.abort();await assert.rejects(()=>f.tool.execute(args,{...f.exec,signal:abort.signal}),/abort/i);f.session.header={parentSession:'synthetic-parent'};await assert.rejects(()=>f.tool.execute(args,f.exec),/source-unavailable/)}))
+
+test('an authorized native write still requires explicit epistemic classification',()=>box(async f=>{f.admit();await assert.rejects(()=>f.tool.execute({...args,meaning:undefined},f.exec),/memory-meaning-required/);assert.equal(existsSync(join(f.dir,'MEMORY.md')),false)}))
+test('native personal facts are durable reported claims with unchanged source identity',()=>box(async f=>{f.input.content[0].text='Synthetic personal statement: my regular signature is Jade and I do editing.';f.admit();await f.tool.execute({...args,summary:'Synthetic regular signature Jade; role editing',meaning:{kind:'claim'}},f.exec);const record=candidateSnapshot(f.dir,'global').records[0];assert.equal(record.meaning.kind,'claim');assert.equal(record.evidence[0].messageId,'synthetic-owner-session:10');assert.equal(record.status,'recorded');assert.equal(record.meaning.verified,undefined)}))

package/test-tool-write-lifecycle.mjs

@@ -0,0 +1,52 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtempSync,rmSync,readFileSync,writeFileSync,existsSync,cpSync,mkdirSync} from 'node:fs'
+import {join} from 'node:path'
+import {tmpdir} from 'node:os'
+import {writeMemory,indexLine,searchStore,withdrawManagedSource,withdrawManagedSourceKey,forgetMemory,adoptCandidate,recoverMemoryPublication,storeRevision,lookupLinks} from './index.mjs'
+import {candidateSnapshot,stageCandidate,withdrawSource,withdrawalPolicy,pruneCandidates,rejectCandidate} from './candidates.mjs'
+import {filterWithdrawn} from './withdrawal.mjs'
+const proof=(n=1)=>({sessionId:'synthetic-owner',basis:'tool-context',via:'memory_write',callHash:String(n).padStart(64,'a'),evidence:[{messageId:'owner-message-'+n,hash:'b'.repeat(64),quote:'Synthetic owner statement for this turn '+n}]})
+const box=run=>{const root=mkdtempSync(join(tmpdir(),'tool-write-life-')),dir=join(root,'memory');mkdirSync(dir);try{return run(dir,root)}finally{rmSync(root,{recursive:true,force:true})}}
+function write(dir,summary='Synthetic selected palette jade9876',options={}){const detail=options.detail??'Synthetic private detail jade9876';return writeMemory({dir,type:'user',scope:'global',summary,detail,line:indexLine('user',summary,options.expires,detail.trim().length>0),provenance:proof(options.n??1),...options})}
+function withdraw(dir,n=1){const plan=withdrawManagedSource(dir,'synthetic-owner','owner-message-'+n,{scope:'global'});return withdrawManagedSource(dir,'synthetic-owner','owner-message-'+n,{scope:'global',apply:true,reviewedIndex:plan.reviewedIndex,candidateRevision:plan.candidateRevision})}
+test('quoted extraction retains its own origin and source withdrawal removes its marked detail',()=>box(dir=>{
+  write(dir,undefined,{provenance:{...proof(),basis:'quoted-extraction',via:'auto-capture'}})
+  assert.equal(candidateSnapshot(dir,'global').records[0].origin,'quoted-extraction')
+  assert.equal(withdraw(dir).effectiveRemoved,1)
+  assert.doesNotMatch(readFileSync(join(dir,'user.md'),'utf8'),/jade9876/)
+}))
+test('short owner context is not sufficient evidence for an automatic quoted extraction',()=>box(dir=>{
+  assert.throws(()=>write(dir,undefined,{provenance:{...proof(),basis:'quoted-extraction',evidence:[{...proof().evidence[0],quote:'记住'}]}}),/short-quote/)
+  assert.equal(existsSync(join(dir,'MEMORY.md')),false)
+}))
+test('tool correction can supersede a quoted extraction and withdraw its prior text independently',()=>box(dir=>{
+  const old=write(dir,undefined,{provenance:{...proof(),basis:'quoted-extraction',via:'auto-capture'}})
+  const next=write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2})
+  assert.equal(candidateSnapshot(dir,'global').records[0].status,'superseded')
+  assert.equal(lookupLinks(dir,{id:old.id}).found,false)
+  assert.match(lookupLinks(dir,{id:next.id}).supersedesLine,/jade9876/)
+  withdraw(dir);assert.equal(lookupLinks(dir,{id:next.id}).supersedesLine,undefined)
+  assert.ok(searchStore(dir,'violet7654').hits.length>0)
+}))
+test('automatic correction cannot silently reaffirm a tool-superseded line',()=>box(dir=>{
+  write(dir);write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2})
+  assert.throws(()=>write(dir,undefined,{provenance:{...proof(3),basis:'quoted-extraction',via:'auto-capture'}}),/withdrawn-content/)
+}))
+test('explicit context write atomically records its original expiry, source and marked detail',()=>box(dir=>{const result=write(dir,undefined,{expires:'2030-03-04'}),snapshot=candidateSnapshot(dir,'global'),record=snapshot.records[0];assert.equal(record.origin,'tool-context');assert.equal(record.status,'recorded');assert.equal(record.indexLine,result.indexLine);assert.match(record.indexLine,/exp:2030-03-04/);assert.match(readFileSync(join(dir,'user.md'),'utf8'),new RegExp('\\[candidate:'+record.id+'\\]'));assert.equal(existsSync(join(dir,'.publication.json')),false)}))
+test('source withdrawal removes indexed and detailed context writes without promoting them to adopted evidence',()=>box(dir=>{write(dir);const record=candidateSnapshot(dir,'global').records[0];assert.throws(()=>adoptCandidate(dir,record.id,{scope:'global'}),/context-only/);assert.throws(()=>withdrawSource(dir,'synthetic-owner','owner-message-1'),/effective-withdrawal/);assert.equal(withdraw(dir).effectiveRemoved,1);assert.doesNotMatch(readFileSync(join(dir,'user.md'),'utf8'),/jade9876/);assert.equal(searchStore(dir,'jade9876').hits.length,0);assert.equal(candidateSnapshot(dir,'global').records[0].status,'withdrawn')}))
+test('expired index identity is withdrawn exactly and cannot survive due to omitted expiry in a formatter',()=>box(dir=>{write(dir,undefined,{expires:'2020-01-01'});assert.equal(withdraw(dir).effectiveRemoved,1);assert.doesNotMatch(readFileSync(join(dir,'MEMORY.md'),'utf8'),/jade9876/)}))
+test('superseded context record does not resurrect when its old Markdown view is restored',()=>box(dir=>{const old=write(dir),body=readFileSync(join(dir,'MEMORY.md'));write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2});const records=candidateSnapshot(dir,'global').records;assert.equal(records[0].status,'superseded');writeFileSync(join(dir,'MEMORY.md'),body);assert.equal(searchStore(dir,'jade9876').hits.length,0);assert.equal(lookupLinks(dir,{id:old.id}).found,false)}))
+test('withdrawing a superseded root clears its old detail while preserving the replacement',()=>box(dir=>{write(dir);write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2});assert.equal(withdraw(dir).effectiveRemoved,1);assert.doesNotMatch(readFileSync(join(dir,'user.md'),'utf8'),/jade9876/);assert.ok(searchStore(dir,'violet7654').hits.length>0)}))
+test('a later cooperating write may remove old masked detail before withdrawal without losing its tombstone',()=>box(dir=>{write(dir);write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2});write(dir,'Unrelated camera preference amber4321',{detail:'Unrelated lens note',n:3});assert.doesNotMatch(readFileSync(join(dir,'user.md'),'utf8'),/jade9876/);assert.equal(withdraw(dir).effectiveRemoved,1);assert.ok(withdrawalPolicy(dir).lineHashes.length>0)}))
+test('manual index removal still permits precise source detail withdrawal',()=>box(dir=>{write(dir);forgetMemory(dir,'jade9876');assert.equal(withdraw(dir).effectiveRemoved,1);assert.doesNotMatch(readFileSync(join(dir,'user.md'),'utf8'),/jade9876/)}))
+test('restored pre-withdrawal body and source ledger are rejected by a retained withdrawal policy',()=>box((dir,root)=>{write(dir);const backup=join(root,'backup');cpSync(dir,backup,{recursive:true});withdraw(dir);const policy=withdrawalPolicy(dir);assert.doesNotMatch(filterWithdrawn(readFileSync(join(backup,'MEMORY.md'),'utf8'),policy,true),/jade9876/);assert.doesNotMatch(filterWithdrawn(readFileSync(join(backup,'user.md'),'utf8'),policy),/jade9876/)}))
+test('a publication interruption cannot expose an effective write before its source after-image is recovered',()=>box(dir=>{assert.throws(()=>write(dir,undefined,{publicationFault:({phase,index})=>{if(phase==='file'&&index===0)throw Error('synthetic-stop')}}),/synthetic-stop/);assert.throws(()=>searchStore(dir,'jade9876'),/publication-needs-recovery/);recoverMemoryPublication(dir,{apply:true});assert.equal(candidateSnapshot(dir,'global').records[0].status,'recorded');assert.ok(searchStore(dir,'jade9876').hits.length>0);assert.equal(withdraw(dir).effectiveRemoved,1)}))
+test('call and source identity tampering cannot turn context records into reviewed candidates',()=>box(dir=>{write(dir);const file=join(dir,'.candidates.json'),raw=JSON.parse(readFileSync(file));raw.records[0].status='adopted';writeFileSync(file,JSON.stringify(raw));assert.throws(()=>candidateSnapshot(dir,'global'),/context-only-status/)}))
+test('no unreviewed topic archive may be silently declared cleaned',()=>box(dir=>{write(dir);writeFileSync(join(dir,'user.archive-20261029.md'),'Synthetic copied jade9876 detail');assert.throws(()=>withdraw(dir),/unreviewed-topic-archive/);assert.match(readFileSync(join(dir,'MEMORY.md'),'utf8'),/jade9876/)}))
+test('new ordinary candidate review remains separate from context-only provenance',()=>box(dir=>{write(dir);const id=stageCandidate(dir,{type:'user',scope:'global',summary:'Synthetic independent new choice cobalt7654',sessionId:'independent-owner',indexRevision:storeRevision(dir),evidence:[{messageId:'independent-message',hash:'c'.repeat(64),quote:'Synthetic separately stated cobalt7654 choice'}]}).id;assert.equal(adoptCandidate(dir,id,{scope:'global'}).candidate.status,'pending')}))
+
+test('pruning rejected inference candidates cannot discard effective or superseded tool lineage',()=>box(dir=>{write(dir);write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2});const id=stageCandidate(dir,{type:'user',scope:'global',summary:'Synthetic pending unrelated thought',sessionId:'proposal-owner',indexRevision:storeRevision(dir),evidence:[{messageId:'proposal-message',hash:'c'.repeat(64),quote:'Synthetic separately stated proposal'}]}).id;rejectCandidate(dir,id);pruneCandidates(dir,{apply:true});const records=candidateSnapshot(dir,'global').records;assert.equal(records.filter(r=>r.origin==='tool-context').length,2);assert.equal(withdraw(dir).effectiveRemoved,1)}))
+test('withdrawing prior context roots removes their historical text from replacement link results',()=>box(dir=>{write(dir);const next=write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2});assert.match(lookupLinks(dir,{id:next.id}).supersedesLine,/jade9876/);withdraw(dir);assert.equal(lookupLinks(dir,{id:next.id}).supersedesLine,undefined);assert.equal(lookupLinks(dir,{id:next.id}).found,true)}))
+test('fresh tool context cannot automatically reaffirm withdrawn content and old source roots remain invalid',()=>box(dir=>{write(dir);withdraw(dir);assert.throws(()=>write(dir),/source-withdrawn/);assert.throws(()=>write(dir,undefined,{n:2}),/withdrawn-content/);assert.equal(candidateSnapshot(dir,'global').records.filter(r=>r.status==='recorded').length,0)}))
+test('explicit independent candidate review can reaffirm a superseded line without converting its old context roots',()=>box(dir=>{write(dir);write(dir,'Synthetic selected palette violet7654',{detail:'Synthetic violet7654 detail',supersedes:'jade9876',n:2});const id=stageCandidate(dir,{type:'user',scope:'global',summary:'Synthetic selected palette jade9876',detail:'Synthetic newly confirmed jade9876 detail',sessionId:'new-independent-owner',indexRevision:storeRevision(dir),evidence:[{messageId:'fresh-owner-message',hash:'c'.repeat(64),quote:'Synthetic explicitly reaffirmed jade9876 choice'}]}).id;const preview=adoptCandidate(dir,id,{scope:'global'});adoptCandidate(dir,id,{scope:'global',apply:true,reviewedIndex:preview.reviewedIndex,candidateRevision:preview.candidateRevision});assert.ok(searchStore(dir,'jade9876').hits.length>0);const prior=candidateSnapshot(dir,'global').records[0];assert.equal(prior.origin,'tool-context');assert.equal(prior.status,'superseded')}))