Files
Agent-Workbench/scripts/retained-experiment-state.mjs
T

67 lines
8.5 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { DatabaseSync } from 'node:sqlite';
import { publicSnapshot,digest,hash } from './retained-host-state.mjs';
import { publicMetadata,compareConfig } from './live-ad/common.mjs';
// Reconciles only explicitly owned additions and declared public edits. Unknown
// old-row changes or unclassified additions are failures, never silently dropped.
export async function auditExperiment({origin,host,boot,frozen,owned,edits=[],registryRevisionDelta=0,configRevisionDelta=0,diagnosticIds=[]}){
assert.equal(host.activity.active,false);assert.equal(host.desktopWindows.count,0);assert.equal(host.identity.pid,frozen.host.identity.pid);assert.equal(host.identity.instanceId,frozen.host.identity.instanceId);
const before=frozen.baseline,after=await publicSnapshot(origin,host.identity.dataRoot),old=frozen.originalPublicMetadata,next=publicMetadata(host.identity.dataRoot);
const sessions=new Set(owned.map(row=>row.sessionId)),projects=new Set(owned.map(row=>row.projectId));
assert.deepEqual(new Set(boot.projects.filter(row=>!frozen.originalProjects.some(old=>old.id===row.id)).map(row=>row.id)),projects);
assert.deepEqual(boot.projects.filter(row=>!projects.has(row.id)),frozen.originalProjects);
assert.deepEqual(after.database.sessionIds.filter(id=>!before.database.sessionIds.includes(id)).sort(),[...sessions].sort());
const configComparison=compareConfig(old.config,next.config);assert.equal(configComparison.current-configComparison.original,configRevisionDelta);
assert.deepEqual(next.modelAttempts.slice(0,old.modelAttempts.length),old.modelAttempts);const newAttempts=next.modelAttempts.slice(old.modelAttempts.length);assert.ok(newAttempts.every(row=>sessions.has(row.sessionId)));
assert.deepEqual(next.modelNetworkDiagnostics.slice(0,old.modelNetworkDiagnostics.length),old.modelNetworkDiagnostics);
assert.deepEqual(new Set(next.modelNetworkDiagnostics.slice(old.modelNetworkDiagnostics.length).map(row=>row.id)),new Set(diagnosticIds));
const previous=structuredClone(old.modelRegistry),actual=structuredClone(next.modelRegistry),changes=[];
assert.equal(actual.revision-previous.revision,registryRevisionDelta);actual.revision=previous.revision;
assert.deepEqual(new Set(actual.connections.map(row=>row.id)),new Set(previous.connections.map(row=>row.id)));assert.equal(actual.connections.length,previous.connections.length);
const orderBefore=previous.connections.map(row=>row.id),orderAfter=actual.connections.map(row=>row.id);
for(const edit of edits){const original=previous.connections.find(row=>row.id===edit.id),current=actual.connections.find(row=>row.id===edit.id);assert.ok(original&&current);
assert.equal(current.revision-original.revision,edit.revisionDelta);assert.ok(current.updatedAt>=original.updatedAt);
assert.equal(current.modelIdentityPolicy,original.modelIdentityPolicy??'record');assert.deepEqual(current.modelIdentityAliases,original.modelIdentityAliases??[]);assert.equal(current.modelIdentityAliasSource,original.modelIdentityAliasSource??'');
changes.push({id:edit.id,originalRevision:original.revision,currentRevision:current.revision,originalUpdatedAt:original.updatedAt,currentUpdatedAt:current.updatedAt});
current.revision=original.revision;current.updatedAt=original.updatedAt;
for(const key of ['modelIdentityPolicy','modelIdentityAliases','modelIdentityAliasSource'])if(!Object.hasOwn(original,key))delete current[key];
assert.deepEqual(current,original);
}
actual.connections=orderBefore.map(id=>actual.connections.find(row=>row.id===id));assert.deepEqual(actual,previous);
assert.deepEqual(after.modelCenter.selected,frozen.center.selected);assert.deepEqual(after.modelCenter.pools,frozen.center.pools);
assert.equal(after.modelCenter.connections.length,frozen.center.connections.length);
for(const original of frozen.center.connections){const current=after.modelCenter.connections.find(row=>row.id===original.id);assert.ok(current);assert.equal(current.hasKey,original.hasKey);assert.equal(current.credentialRevision,original.credentialRevision);}
const exports=new Map(after.exports.map(row=>[row.id,row])),artifacts=new Map(after.persistent.artifacts.map(row=>[row.path,row]));
for(const original of before.exports)assert.deepEqual(exports.get(original.id),original,'Original export '+original.id);
for(const original of before.persistent.artifacts)assert.deepEqual(artifacts.get(original.path),original,'Original artifact '+original.path);
const db=new DatabaseSync(path.join(host.identity.dataRoot,'workbench.sqlite'),{readOnly:true}),addedRows={};let checkedOriginalRows=0;
try{
assert.deepEqual(Object.keys(after.database.tables),Object.keys(before.database.tables));
for(const[table,originals]of Object.entries(before.database.tables)){
const current=after.database.tables[table];assert.equal(current.schemaSha256,originals.schemaSha256);addedRows[table]=current.count-originals.count;
const originalIds=new Set(originals.rows.map(row=>(row.kind??'')+':'+row.id)),currentRows=new Map(current.rows.map(row=>[(row.kind??'')+':'+row.id,row]));
for(const row of originals.rows){
if(table==='projects'){const actual=db.prepare('SELECT * FROM projects WHERE id=?').get(row.id);assert.equal(digest({...actual,position:actual.position-projects.size}),row.sha256);}
else if(table==='sqlite_sequence'){const actual=db.prepare('SELECT * FROM sqlite_sequence WHERE name=?').get('events');assert.equal(actual.seq,after.eventCursor);assert.equal(digest({...actual,seq:before.eventCursor}),row.sha256);}
else if(table==='metadata'&&Object.hasOwn(old,row.id)){const actual=db.prepare('SELECT * FROM metadata WHERE key=?').get(row.id);assert.equal(digest({...actual,value:JSON.stringify(old[row.id])}),row.sha256);}
else{const actual=currentRows.get((row.kind??'')+':'+row.id);assert.ok(actual,table+': missing '+row.id);assert.equal(actual.sha256,row.sha256,table+': changed '+row.id);}checkedOriginalRows++;
}
if(['events','records','sessions'].includes(table)){const columns=table==='records'?'id,kind,session_id,project_id':table==='events'?'id,session_id,project_id':'id,project_id';
for(const row of db.prepare('SELECT '+columns+' FROM '+table).all())if(!originalIds.has((row.kind??'')+':'+row.id)){assert.ok(sessions.has(table==='sessions'?row.id:row.session_id));assert.ok(projects.has(row.project_id));}}
else if(table==='outbox'){for(const row of db.prepare('SELECT outbox.seq,events.session_id FROM outbox JOIN events USING(seq) WHERE outbox.seq>?').all(before.eventCursor))assert.ok(sessions.has(row.session_id));}
else if(table==='metadata')assert.equal(addedRows[table],0);else if(table==='sqlite_sequence')assert.equal(current.count,1);
}
const references=new Map(db.prepare("SELECT payload FROM records WHERE kind='artifact'").all().map(row=>{const value=JSON.parse(row.payload);return[value.relative,value];})),oldPaths=new Set(before.persistent.artifacts.map(row=>row.path));
for(const artifact of after.persistent.artifacts)if(!oldPaths.has(artifact.path)){const reference=references.get(artifact.path);assert.ok(reference&&sessions.has(reference.sessionId));assert.equal(reference.bytes,artifact.bytes);assert.equal(reference.sha256,artifact.sha256);}
}finally{db.close();}
for(const original of before.persistent.files){const actual=after.persistent.files.find(row=>row.path===original.path);assert.ok(actual);
if(original.path==='config.json'&&actual.sha256!==original.sha256){const config=JSON.parse(fs.readFileSync(path.join(host.identity.dataRoot,original.path),'utf8'));assert.deepEqual(config,next.config);assert.equal(hash(JSON.stringify({...config,configRevision:old.config.configRevision},null,2)),original.sha256);}
else assert.equal(actual.sha256,original.sha256);}
return{after,result:{success:true,version:boot.version,pid:host.identity.pid,originalProjects:frozen.originalProjects.length,originalSessions:before.database.sessionIds.length,addedProjects:projects.size,addedSessions:sessions.size,checkedOriginalRows,addedRows,
newArtifactCount:after.persistent.artifacts.length-before.persistent.artifacts.length,originalExports:'exact',originalArtifactBytes:'exact',originalCredentialRow:'exact hash; no decryption or copy',allOldModelAttempts:'exact',newModelAttempts:newAttempts.length,
configComparison,connectionChanges:changes,connectionOrder:{before:orderBefore,after:orderAfter},originalRows:'exact except declared project positions, sequence and validated public metadata',keysReadOrResaved:false}};
}