@mnstry/atelier 0.2.0-alpha.12 → 0.2.0-alpha.13

package/src/knowledge-health/proof/installed-check.mjs

@@ -0,0 +1,100 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import {verifyNativeReadback} from './native-readback.mjs';
+import {checkInstalledWorkshop} from './workshop-check.mjs';
+const root=process.cwd(),packageRoot=path.join(root,'node_modules/@mnstry/atelier'),pkg=JSON.parse(fs.readFileSync(path.join(packageRoot,'package.json'),'utf8')),profile=JSON.parse(fs.readFileSync(process.argv[2],'utf8'));
+const digest=b=>createHash('sha256').update(b).digest('hex'),cases=[],commands=[],gaps=[];
+function cli(args,{cwd=root,input,accept=[0]}={}){
+  const bin=typeof pkg.bin==='string'?pkg.bin:pkg.bin.atelier;assert.ok(bin,'Declared atelier bin required');const full=path.resolve(packageRoot,bin);assert.ok(full.startsWith(packageRoot+path.sep));
+  const o=spawnSync(process.execPath,[full,...args],{cwd,input,encoding:'utf8',timeout:30000,maxBuffer:2*1024*1024});const observed={args,status:o.status,signal:o.signal,stdout:o.stdout??'',stderr:o.stderr??''};commands.push(observed);assert.ok(accept.includes(o.status),JSON.stringify(observed));return observed;
+}
+function gap(id,action){const e=Error(action);e.actionableGap=true;e.gap={id,owner:'Foundation through Reliability and existing KH/AW source owners',action};throw e;}
+async function scenario(id,fn){if(profile.onlyChecks&&!profile.onlyChecks.includes(id))return;try{cases.push({id,status:'passed',observations:await fn()});}catch(e){if(e.actionableGap){gaps.push(e.gap);cases.push({id,status:'actionable-gap',gap:e.gap});}else cases.push({id,status:'failed',error:{name:e.name,message:e.message,stack:e.stack}});}}
+await scenario('declared-exports',async()=>{
+  const resolved=[];
+  for(const [subpath] of Object.entries(pkg.exports)){
+    if(subpath.includes('*')){gaps.push({id:'wildcard-export-enumeration',owner:'Foundation',action:'Provide exact wildcard sample subpaths in release receiving'});continue;}
+    const specifier=subpath==='.'?pkg.name:pkg.name+'/'+subpath.slice(2),url=import.meta.resolve(specifier),file=fileURLToPath(url);assert.ok(fs.realpathSync(file).startsWith(fs.realpathSync(packageRoot)+path.sep));
+    const b=fs.readFileSync(file);if(file.endsWith('.json'))JSON.parse(b);else await import(specifier);resolved.push({specifier,relativePath:path.relative(packageRoot,file),sha256:digest(b)});
+  }
+  return {resolved,count:resolved.length};
+});
+await scenario('declared-bin-and-help',async()=>{assert.equal(cli(['--version']).stdout.trim(),pkg.version);return {version:pkg.version,help:cli(['--help']).stdout};});
+await scenario('public-quickstart',async()=>{
+  assert.equal(process.platform,'darwin','The published shell sequence is qualified here only on macOS');
+  const bin=path.join(root,'node_modules/.bin/atelier');assert.equal(fs.realpathSync(bin),fs.realpathSync(path.resolve(packageRoot,pkg.bin.atelier)));
+  const shellBin=(args,cwd=root)=>{const o=spawnSync(bin,args,{cwd,encoding:'utf8',timeout:30000,maxBuffer:2*1024*1024});const observed={invocation:'installed npm bin symlink',args,status:o.status,signal:o.signal,stdout:o.stdout??'',stderr:o.stderr??''};commands.push(observed);assert.equal(o.status,0,JSON.stringify(observed));return observed;};
+  assert.equal(shellBin(['--version']).stdout.trim(),pkg.version);
+  const init=shellBin(['init','--template','sample-workspace','--target','example']),workspace=path.join(root,'example');
+  return {init,graph:shellBin(['graph'],workspace),project:shellBin(['project'],workspace),scope:'Exact macOS public quickstart command sequence, supported baseline only'};
+});
+await scenario('installed-document-references',async()=>{
+  const references=['README.md','docs/knowledge-graph.md','docs/coauthor-session.md'];
+  const documents=references.map(relativePath=>{const file=fs.realpathSync(path.join(packageRoot,relativePath));assert.ok(file.startsWith(fs.realpathSync(packageRoot)+path.sep));const bytes=fs.readFileSync(file);return {relativePath,bytes:bytes.length,sha256:digest(bytes)};});
+  for(const subpath of ['./graph','./project','./coauthor']){assert.ok(pkg.exports[subpath]);await import(pkg.name+'/'+subpath.slice(2));}
+  return {documents,apiReferences:['@mnstry/atelier/graph','@mnstry/atelier/project','@mnstry/atelier/coauthor'],scope:'Public quickstart references resolve in the actual installed package'};
+});
+await scenario('public-export-fixture',async()=>{const api=await import('@mnstry/atelier'),file=fileURLToPath(import.meta.resolve('@mnstry/atelier/fixtures/atelier-export/sample-studio-offer.v1.json')),value=JSON.parse(fs.readFileSync(file));const report=api.validateAtelierExportDryRun(value);assert.equal(report.accepted,true);assert.equal(report.importable,false);return {fixturePath:path.relative(packageRoot,file),report};});
+await scenario('installed-coauthor-save-reopen-and-drift',async()=>{
+  // Reuses the established Foundation coauthor consumer smoke's CLI sequence,
+  // with only the declared bin and public invented consumer source.
+  const workspace=path.join(root,'coauthor-example');fs.mkdirSync(workspace);assert.equal(spawnSync('git',['init','--quiet',workspace]).status,0);fs.writeFileSync(path.join(workspace,'.gitignore'),'.atelier-local/\n');
+  const source='An invented authoring packet.\n',sourceFile=path.join(workspace,'packet.md');fs.writeFileSync(sourceFile,source);
+  const good=(op,input)=>JSON.parse(cli(['coauthor',op],{cwd:workspace,input:JSON.stringify(input)}).stdout).state;
+  const config={id:'public-devday-baseline',fields:[{id:'example-answer',source:{ref:'packet.md',digest:digest(source)}}]};
+  const initial=good('start',{config}),answer=good('event',{sessionId:config.id,event:{id:'original-answer',expectedRevision:0,type:'answer',text:'Fixture participant: please preserve these original words.'}}),saved=good('event',{sessionId:config.id,event:{id:'save-original',expectedRevision:1,type:'save'}});assert.equal(saved.phase,'saved');
+  const reopened=good('read',{sessionId:config.id});assert.deepEqual(reopened,saved);assert.equal(fs.readFileSync(sourceFile,'utf8'),source);
+  const stale=cli(['coauthor','event'],{cwd:workspace,input:JSON.stringify({sessionId:config.id,event:{id:'stale',expectedRevision:0,type:'advance'}}),accept:[1]});
+  fs.writeFileSync(sourceFile,'Fixture revised source.\n');const drift=cli(['coauthor','event'],{cwd:workspace,input:JSON.stringify({sessionId:config.id,event:{id:'drift',expectedRevision:saved.revision,type:'advance'}}),accept:[1]});assert.deepEqual(good('read',{sessionId:config.id}),saved);
+  return {initial,answer,saved,reopened,stale,drift,sourceOwnerApplication:false,nativeWorkbench:false};
+});
+await scenario('installed-knowledge-example-and-agent-output',async()=>{
+  if(!pkg.exports['./knowledge']||!profile.knowledgeExample)gap('installed-knowledge-health-example','Published package lacks the required declared knowledge API or source-owner-bound normal example entry. Supply exact Dev Day release and knowledgeExample template/command bindings.');
+  const workspace=path.join(root,'knowledge-example'),init=cli(['init','--template',profile.knowledgeExample.template,'--target',workspace]);
+  const binding=profile.knowledgeExample;
+  for(const key of ['graphArgs','checkArgs','contextArgs'])assert.ok(Array.isArray(binding[key])&&binding[key].length,'Source owner must bind actual installed CLI arguments: '+key);
+  const graph=cli(binding.graphArgs,{cwd:workspace}),check=cli(binding.checkArgs,{cwd:workspace}),context=cli(binding.contextArgs,{cwd:workspace});
+  // Results are raw real package observations. Semantic applicability and human
+  // understanding are not inferred from successful subprocess exits.
+  assert.ok(graph.stdout.length+graph.stderr.length>0);assert.ok(check.stdout.length+check.stderr.length>0);assert.ok(context.stdout.length+context.stderr.length>0);
+  return {init,graph,check,context,scope:'Actual published invented template and installed CLI; raw statuses retained, no Dev Day guided-journey pass inferred.'};
+});
+await scenario('installed-public-graph-project-baseline',async()=>{
+  const workspace=path.join(root,'public-graph-example'),init=cli(['init','--template','sample-workspace','--target',workspace]);
+  const graphCommand=cli(['graph'],{cwd:workspace}),projectCommand=cli(['project'],{cwd:workspace});
+  const graphApi=await import('@mnstry/atelier/graph'),projectApi=await import('@mnstry/atelier/project');
+  if(typeof graphApi.buildCanonicalGraph!=='function'||typeof projectApi.resolveProjectConfig!=='function')gap('graph-agent-api-binding','Source owner must bind actual declared graph/project API names for this version.');
+  const project=projectApi.resolveProjectConfig({cwd:workspace,argv:['--project',path.join(workspace,'atelier.project.json')]}),graph=graphApi.buildCanonicalGraph(project);
+  assert.ok(Array.isArray(graph.nodes));assert.ok(Array.isArray(graph.edges));assert.ok(Array.isArray(graph.errors));assert.equal(graph.errors.length,0);
+  return {init,graphCommand,projectCommand,graph,agentCIOutput:'Actual machine-readable canonical graph; structural evidence only, no model/provider or semantic acceptance.'};
+});
+const docs=[];for(const candidate of ['README.md','docs/knowledge.md','docs/coauthor.md','docs/coauthor-session.md','docs/upgrade.md','docs/graph.md','docs/knowledge-graph.md','docs/release-engineering.md']){const full=path.join(packageRoot,candidate);if(fs.existsSync(full)){const b=fs.readFileSync(full);docs.push({path:candidate,sha256:digest(b),bytes:b.length});}}
+for(const id of ['assessment-to-guided-authoring','full-native-finding-reference','preview-owning-source-correction-readback-reassessment','keyboard-focus-undo','native-withdrawal-recovery','participant-usefulness'])gaps.push({id,owner:id==='participant-usefulness'?'Facilitator/participant':'Foundation and existing AW Integration/Journey',action:'Receive exact public Dev Day installed entry/bindings and native allocation; inherited native or fixture proof cannot satisfy installed or human evidence.'});
+const bindings=profile.deliveryBindings;
+if(bindings){
+  await scenario('owner-installed-journey',async()=>{
+    assert.ok(pkg.exports[bindings.exportSubpath],'Journey must use a declared package export');const specifier=bindings.exportSubpath==='.'?pkg.name:pkg.name+'/'+bindings.exportSubpath.slice(2),api=await import(specifier);assert.equal(typeof api[bindings.functionName],'function');
+    const output=await api[bindings.functionName]({...bindings.publicInput,consumerRoot:root,publicInventedOnly:true,participantAssertions:'fixture'});
+    assert.equal(output.packageVersion,pkg.version);assert.ok(Array.isArray(output.steps));
+    const required=['assessment','evidence-orientation','original-contribution','interpretation-disagreement-perspective-pause','preview','owner-correction','exact-readback','reopen-reassessment'];
+    for(const id of required){const step=output.steps.find(s=>s.id===id);assert.ok(step,'Missing installed step '+id);assert.equal(step.status,'passed');assert.ok(step.evidence,'Independent command/readback evidence required for '+id);}
+    assert.equal(output.humanAcceptance,false);
+    if(!bindings.nativeExportSubpath||!pkg.exports[bindings.nativeExportSubpath])gap('installed-native-draft-export','Source owner must expose the actual received native Drafts API as a declared export for independent readback.');
+    const nativeSpecifier=bindings.nativeExportSubpath==='.'?pkg.name:pkg.name+'/'+bindings.nativeExportSubpath.slice(2),draft=await import(nativeSpecifier);
+    const nativeReadback=verifyNativeReadback(draft,output.nativeCapture,root);
+    if(!bindings.reassessmentExportSubpath||!pkg.exports[bindings.reassessmentExportSubpath])gap('independent-installed-reassessment','Source owner must bind an actual declared reassessment export for independent current-source evaluation.');
+    const reassessmentSpecifier=bindings.reassessmentExportSubpath==='.'?pkg.name:pkg.name+'/'+bindings.reassessmentExportSubpath.slice(2),assessor=await import(reassessmentSpecifier);assert.equal(typeof assessor[bindings.reassessmentFunctionName],'function');
+    const reassessed=await assessor[bindings.reassessmentFunctionName]({...bindings.publicInput,consumerRoot:root,workspaceRelative:output.nativeCapture.workspaceRelative,publicInventedOnly:true});
+    assert.deepEqual(reassessed,output.reassessment);assert.equal(reassessed.currency,'current');
+    return {output,nativeReadback,independentReassessment:reassessed,scope:'Installed runner plus independent native API/file readback and reassessment; rendered collector/verifier and human protocol remain separate'};
+  });
+}
+await scenario('aw-installed-workshop',()=>checkInstalledWorkshop({pkg,root,profile,gap}));
+const deliveryQualified=false; // Never promote an installed runner's own claims to native/human acceptance.
+const installedMachineJourneyQualified=cases.some(c=>c.id==='owner-installed-journey'&&c.status==='passed');
+process.stdout.write(JSON.stringify({package:{name:pkg.name,version:pkg.version},selectedChecks:profile.onlyChecks??'all',cases,commands,docs,gaps,counts:{passed:cases.filter(c=>c.status==='passed').length,failed:cases.filter(c=>c.status==='failed').length,actionableGaps:cases.filter(c=>c.status==='actionable-gap').length},installedMachineJourneyQualified,deliveryQualified,humanAcceptance:false,nativeCaptureRequired:true,ownerBindingsSupplied:!!bindings})+'\n');
+if(cases.some(c=>c.status==='failed'))process.exitCode=1;

package/src/knowledge-health/proof/native-readback.mjs

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+// These are the already received Drafts v1 command/v2 disposition identities.
+// The release owner must expose the actual native supplier as a declared export.
+// This verifier adds no store, model, application route or accepted canonical.
+export function verifyNativeReadback(draft,capture,consumerRoot){
+  assert.equal(draft.DISPOSITION_VERSION,'authoring-workbench.contribution-disposition/v2');
+  assert.ok(capture&&capture.workspaceRelative&&capture.sourceRelative);
+  assert.equal(path.isAbsolute(capture.workspaceRelative),false);assert.equal(path.isAbsolute(capture.sourceRelative),false);
+  const root=fs.realpathSync(path.resolve(consumerRoot,capture.workspaceRelative));assert.ok(root.startsWith(fs.realpathSync(consumerRoot)+path.sep));
+  const source=fs.realpathSync(path.resolve(root,capture.sourceRelative));assert.ok(source.startsWith(root+path.sep));
+  const q=capture.contribution,record=capture.disposition;assert.deepEqual(record.contribution,q);assert.equal(record.schema,draft.DISPOSITION_VERSION);
+  assert.deepEqual(Object.keys(record.context.findingReference).sort(),['id','checkId','checkVersion','planSha256','readSetSha256','comparisonSha256'].sort());
+  const store=draft.createDraftStore({workspaceRoot:root,storeId:q.binding.storeId,actorBindingId:q.binding.actorBindingId,sourceReader:()=>({revision:capture.currentSourceRevision,digest:sha(fs.readFileSync(source))})});
+  try{
+    const original=store.readContribution(q.binding,q.id,q.revision),context=store.lookupDisposition(q.binding,record.id);
+    assert.deepEqual(original.contribution,q);assert.equal(context.status,'committed');assert.deepEqual(context.readback.record,record);
+    assert.equal(context.receipt.recordDigest,draft.commandDigest(record));assert.equal(context.receipt.contributionDigest,draft.commandDigest(q));assert.deepEqual(context.receipt.binding,q.binding);
+    assert.equal(context.readback.findingReferenceCoverage,'supplied-fingerprints');assert.deepEqual(context.readback.contributionReadback,original);
+    assert.equal(original.ledgerReadback.actor,q.binding.actorBindingId);assert.deepEqual(original.ledgerReadback.record,q);assert.notEqual(original.ledgerReadback.eventId,context.receipt.eventId);
+    assert.equal(original.draftReadback.draftRevision,q.draftRevision);assert.equal(original.draftReadback.value.digest,q.valueDigest);assert.equal(sha(original.draftReadback.value.text),q.valueDigest);assert.deepEqual(original.draftReadback.sourceBase,q.sourceBase);
+    const saves=[];
+    for(const operation of capture.operations??[]){
+      const command=operation.command,found=store.lookupOperation(q.binding,command.operationId);assert.equal(found.status,'committed');
+      assert.equal(found.receipt.commandDigest,draft.commandDigest(command));assert.equal(found.receipt.operationId,command.operationId);assert.equal(found.receipt.previousDraftRevision,command.expectedDraftRevision);assert.deepEqual(found.receipt.editor,command.editor);assert.deepEqual(found.receipt.sourceBase,command.sourceBase);
+      const readback=store.readRevision(q.binding,found.receipt.draftRevision);assert.equal(readback.value.text,command.value.text);assert.equal(readback.value.digest,sha(command.value.text));assert.equal(found.receipt.valueDigest,readback.value.digest);saves.push({command,found,readback});
+    }
+    assert.ok(saves.length,'Actual installed draft operation and independent original-ID readback required');
+    assert.ok(capture.sourceApply?.owningRoute,'Existing source-owning route must be identified');assert.equal(capture.sourceApply.participantAssertion,'fixture');assert.equal(sha(fs.readFileSync(source)),capture.sourceApply.afterSha256);
+    assert.equal(sha(capture.sourceApply.beforeBytes),capture.sourceApply.beforeSha256);assert.notEqual(capture.sourceApply.beforeSha256,capture.sourceApply.afterSha256);
+    assert.equal(capture.sourceApply.beforeSha256,q.sourceBase.digest);
+    return {result:'native-readback-consistent',original,context,saves,actualCurrentSourceSha256:sha(fs.readFileSync(source)),owningRoute:capture.sourceApply.owningRoute,scope:'Independent installed native API/file readback on this disposable consumer; does not certify rendered input, source applicability or participant acceptance.',humanAcceptance:false};
+  }finally{store.close();}
+}

package/src/knowledge-health/proof/rehearse.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import assert from 'node:assert/strict';
+import {randomUUID} from 'node:crypto';
+import {fileURLToPath} from 'node:url';
+import {hash,readJson,pin,run,npm,files} from './common.mjs';
+const [inputPath,outputPath]=process.argv.slice(2);assert.ok(inputPath&&outputPath,'Usage: node tools/rehearse.mjs EXACT_INPUT.json NEW_RESULT.json');
+assert.equal(fs.existsSync(outputPath),false,'A prior result may not be overwritten');
+const profile=readJson(inputPath),source=profile.source;
+assert.ok(['baseline','delivery'].includes(profile.purpose));assert.equal(source.name,'@mnstry/atelier');assert.match(source.version,/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/);
+assert.ok(['tarball','registry'].includes(source.kind));assert.match(source.integrity,/^sha512-[A-Za-z0-9+/]+={0,2}$/);
+if(profile.captureTarball&&source.kind==='registry'){
+  const destination=path.join(path.dirname(path.resolve(outputPath)),'tarballs'),filename=source.name.replace(/^@/,'').replace('/','-')+'-'+source.version+'.tgz';
+  assert.equal(fs.existsSync(path.join(destination,filename)),false,'Retained tarball may not be overwritten; use a new result directory');
+}
+if(profile.purpose==='delivery'){assert.ok(profile.candidate?.commit&&profile.candidate?.tree,'Release owner candidate required');assert.match(profile.candidate.commit,/^[a-f0-9]{40}$/);assert.match(profile.candidate.tree,/^[a-f0-9]{40}$/);}
+const toolHome=path.dirname(fileURLToPath(import.meta.url)),snapshot=path.resolve(outputPath)+'.harness-source';
+assert.equal(fs.existsSync(snapshot),false,'A prior source snapshot may not be overwritten');fs.mkdirSync(snapshot,{recursive:true});
+const harnessFiles=['rehearse.mjs','common.mjs','installed-check.mjs','native-readback.mjs','workshop-check.mjs'].map(name=>{const original=path.join(toolHome,name),retained=path.join(snapshot,name);fs.copyFileSync(original,retained);return {originalPath:original,...pin(retained)};});
+const root=fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()),'atelier-devday-consumer-')),ownerMark=randomUUID(),observations=[];
+fs.writeFileSync(path.join(root,'.devday-owner'),ownerMark);fs.mkdirSync(path.join(root,'config'));fs.mkdirSync(path.join(root,'cache'));
+fs.writeFileSync(path.join(root,'config/user.npmrc'),'# Empty consumer configuration\n');fs.writeFileSync(path.join(root,'config/global.npmrc'),'# Empty consumer configuration\n');
+fs.writeFileSync(path.join(root,'package.json'),JSON.stringify({name:'atelier-public-devday-consumer',private:true,type:'module'})+'\n');
+const result={startedAt:new Date().toISOString(),input:pin(inputPath),harnessFiles,purpose:profile.purpose,source,host:{platform:process.platform,arch:process.arch,node:process.version},cacheInitiallyEmpty:files(path.join(root,'cache')).length===0,noPublisherNpmConfig:true,observations,claims:{registryInstall:false,tarballInstall:false,installedJourney:false,nativeInput:false,humanAcceptance:false,allPlatforms:false},deliveryQualified:false};
+let retainedTarball=null;
+try{
+  let target;
+  if(source.kind==='registry'){
+    assert.equal(source.registry,'https://registry.npmjs.org');
+    const viewed=npm(['view',source.name+'@'+source.version,'name','version','engines','bin','exports','dist','gitHead','--json'],root);observations.push({step:'registry-metadata',...viewed});
+    const metadata=JSON.parse(viewed.stdout);assert.equal(metadata.name,source.name);assert.equal(metadata.version,source.version);assert.equal(metadata.dist.integrity,source.integrity);
+    result.registryMetadata=metadata;result.registryMetadataSha256=hash(viewed.stdout);result.sourceIdentity={registryGitHead:metadata.gitHead??null,candidate:profile.candidate??null};
+    target=source.name+'@'+source.version;
+  }else{
+    assert.ok(source.path);assert.match(source.sha256,/^[a-f0-9]{64}$/);target=path.resolve(path.dirname(path.resolve(inputPath)),source.path);const b=fs.readFileSync(target);assert.equal(hash(b),source.sha256);assert.equal('sha512-'+hash(b,'sha512','base64'),source.integrity);
+    result.tarball=pin(target);result.sourceIdentity={candidate:profile.candidate??null};
+  }
+  const install=npm(['install',target,'--ignore-scripts','--no-audit','--no-fund','--save-exact','--prefer-online'],root);observations.push({step:'install',...install});
+  const installedRoot=path.join(root,'node_modules/@mnstry/atelier'),installed=readJson(path.join(installedRoot,'package.json')),consumer=readJson(path.join(root,'package.json')),lock=readJson(path.join(root,'package-lock.json'));
+  assert.equal(installed.name,source.name);assert.equal(installed.version,source.version);assert.equal('overrides' in consumer,false);assert.equal(lock.packages['node_modules/@mnstry/atelier'].integrity,source.integrity);
+  const tree=npm(['ls','--all','--json'],root);observations.push({step:'dependency-tree',...tree});assert.equal(JSON.parse(tree.stdout).problems?.length??0,0);
+  result.claims.registryInstall=source.kind==='registry';result.claims.tarballInstall=source.kind==='tarball';
+  result.installation={packageJson:pin(path.join(installedRoot,'package.json')),packageLock:pin(path.join(root,'package-lock.json')),exports:installed.exports,bin:installed.bin,engines:installed.engines,files:files(installedRoot),noOverrides:true,installScriptsRun:false};
+  fs.copyFileSync(path.join(snapshot,'installed-check.mjs'),path.join(root,'installed-check.mjs'));
+  fs.copyFileSync(path.join(snapshot,'native-readback.mjs'),path.join(root,'native-readback.mjs'));
+  fs.copyFileSync(path.join(snapshot,'workshop-check.mjs'),path.join(root,'workshop-check.mjs'));
+  fs.writeFileSync(path.join(root,'profile.json'),JSON.stringify(profile)+'\n');
+  const check=run(process.execPath,[path.join(root,'installed-check.mjs'),path.join(root,'profile.json')],{cwd:root,timeout:120000,accept:[0,1]});observations.push({step:'installed-check',...check});
+  result.installedChecks=JSON.parse(check.stdout);
+  assert.equal(check.status,0,'An actual installed check failed; see installedChecks and raw command output');
+  result.claims.registryInstall=source.kind==='registry';result.claims.tarballInstall=source.kind==='tarball';
+  if(profile.captureTarball&&source.kind==='registry'){
+    const destination=path.join(path.dirname(path.resolve(outputPath)),'tarballs');fs.mkdirSync(destination,{recursive:true});
+    const packed=npm(['pack',source.name+'@'+source.version,'--ignore-scripts','--json','--pack-destination='+destination],root);observations.push({step:'retain-published-tarball',...packed});
+    const packedRow=JSON.parse(packed.stdout)[0],p=path.join(destination,packedRow.filename),b=fs.readFileSync(p);assert.equal('sha512-'+hash(b,'sha512','base64'),source.integrity);
+    retainedTarball={...pin(p),integrity:source.integrity,origin:'Published registry baseline; not source-owner Dev Day candidate'};result.retainedTarball=retainedTarball;
+  }
+  result.deliveryQualified=profile.purpose==='delivery'&&result.installedChecks.deliveryQualified===true;
+  result.result='completed-with-gaps';if(result.deliveryQualified)result.result='delivery-qualified';
+}catch(error){result.result='failed';result.error={name:error.name,message:error.message,observation:error.observation??null,stack:error.stack};}
+finally{
+  assert.equal(fs.readFileSync(path.join(root,'.devday-owner'),'utf8'),ownerMark);fs.rmSync(root,{recursive:true});result.cleanup={root,removed:!fs.existsSync(root),scope:'Only marker-owned clean consumer and cache'};result.finishedAt=new Date().toISOString();
+  fs.mkdirSync(path.dirname(path.resolve(outputPath)),{recursive:true});fs.writeFileSync(outputPath,JSON.stringify(result,null,2)+'\n',{flag:'wx'});
+}
+process.stdout.write(JSON.stringify({output:path.resolve(outputPath),result:result.result,purpose:result.purpose,registryInstall:result.claims.registryInstall,tarballInstall:result.claims.tarballInstall,deliveryQualified:result.deliveryQualified,cleanup:result.cleanup,retainedTarball,error:result.error?.message??null},null,2)+'\n');
+if(result.result==='failed')process.exitCode=1;

package/src/knowledge-health/proof/validate-participant.mjs

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+const [input,output]=process.argv.slice(2);assert.ok(input&&output);assert.equal(fs.existsSync(output),false,'Retain original report');
+const bytes=fs.readFileSync(input),record=JSON.parse(bytes),issues=[];
+assert.ok(['not-observed','observed'].includes(record.status));assert.equal(record.acceptance,'not-established');
+if(record.status==='observed'){
+  for(const key of ['participantCode','recordingChoice','observedAt','packageVersion','packageIntegrity','exampleSourceBeforeSha256'])if(typeof record[key]!=='string'||!record[key].trim())issues.push('Missing actual '+key);
+  if(!record.evidenceRefs?.length)issues.push('No actual observation evidence references');
+  if(!record.baseline?.explanation)issues.push('Baseline explanation missing');
+  if(!record.understandingAfter?.explanation)issues.push('After-task explanation missing');
+  if(!record.contribution?.originalWords&&!record.contribution?.reason)issues.push('Contribution or refusal reason missing');
+  if(!record.usefulness?.participantWords&&!record.usefulness?.reason)issues.push('Participant usefulness judgment or non-observation reason missing');
+  if(record.reassessment?.observed&&!record.reassessment?.exactReadbackEvidence)issues.push('Reassessment marked observed without exact readback evidence');
+}
+const report={inputSha256:createHash('sha256').update(bytes).digest('hex'),status:record.status,result:issues.length?'incomplete':'record-shape-consistent',issues,humanAcceptance:'not-established',collectorAuthenticityVerified:false};
+fs.writeFileSync(output,JSON.stringify(report,null,2)+'\n',{flag:'wx'});process.stdout.write(JSON.stringify(report)+'\n');if(issues.length)process.exitCode=2;

package/src/knowledge-health/proof/verify-native-capture.mjs

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import assert from 'node:assert/strict';
+import {readJson,pin,run} from './common.mjs';
+// Separate native receiving check; not a clean-consumer package import or a driver.
+// Reuses the existing Authoring journey verifier at an exact supplied source hash.
+const [bindingPath,output]=process.argv.slice(2);assert.ok(bindingPath&&output);assert.equal(fs.existsSync(output),false);
+const b=readJson(bindingPath);assert.equal(pin(b.verifier.path).sha256,b.verifier.sha256);assert.equal(pin(b.capture.path).sha256,b.capture.sha256);
+const capture=readJson(b.capture.path);assert.equal(capture.mode,'integrated-capture');assert.equal(capture.candidate.commit,b.candidate.commit);assert.equal(capture.candidate.tree,b.candidate.tree);assert.equal(capture.admission.installedCommit,b.candidate.commit);assert.equal(capture.admission.installedTree,b.candidate.tree);
+assert.equal(capture.humanObservation.status,'not-observed','Automated rehearsal does not create human judgments');
+const verifierReport=output+'.authoring-report.json';
+let command,report,error;
+try{command=run(process.execPath,[b.verifier.path,'--scenario',capture.scenario,'--candidate',b.candidate.commit,'--input',b.capture.path,'--report',verifierReport],{cwd:process.cwd(),accept:[0,1,2]});if(fs.existsSync(verifierReport))report=readJson(verifierReport);}catch(e){error=e.observation??{message:e.message};}
+const out={binding:pin(bindingPath),verifier:b.verifier,capture:b.capture,candidate:b.candidate,package:b.package,command,error,verifierReport:report,checksConsistent:command?.status===0,productAcceptance:'not-established',humanAcceptance:'not-established',actualCollectorHonestyCertified:false};
+fs.writeFileSync(output,JSON.stringify(out,null,2)+'\n',{flag:'wx'});process.stdout.write(JSON.stringify({output,checksConsistent:out.checksConsistent,productAcceptance:out.productAcceptance})+'\n');if(!out.checksConsistent)process.exitCode=2;

package/src/knowledge-health/proof/workshop-check.mjs

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {fileURLToPath} from 'node:url';
+const sha=value=>createHash('sha256').update(value).digest('hex');
+
+// This receiving adapter calls the actual AW supplier signature after it is
+// shipped. It never copies that supplier module or its examples into a consumer.
+export async function checkInstalledWorkshop({pkg,root,profile,gap}){
+  const binding=profile.awWorkshop;
+  if(!binding||!pkg.exports[binding.exportSubpath])gap('aw-coherent-installed-entry','Foundation must first ship the received coherent AW exercise through an actual declared export. Supplier source qualification is not an installed entry.');
+  const specifier=binding.exportSubpath==='.'?pkg.name:pkg.name+'/'+binding.exportSubpath.slice(2),api=await import(specifier);
+  if(typeof api[binding.functionName]!=='function')gap('aw-coherent-installed-function','The actual installed export does not contain the received AW exercise function; return its exact version/entry to Foundation.');
+  const exportedFile=fs.realpathSync(fileURLToPath(import.meta.resolve(specifier))),packageRoot=fs.realpathSync(path.join(root,'node_modules/@mnstry/atelier'));assert.ok(exportedFile.startsWith(packageRoot+path.sep));
+  const graphAPI=await import('@mnstry/atelier/graph'),projectAPI=await import('@mnstry/atelier/project'),coauthorAPI=await import('@mnstry/atelier/coauthor/store'),rows=[];
+  assert.deepEqual(binding.outcomes.slice().sort(),['revision','note','disagreement','perspective-only','pause'].sort());
+  for(const outcome of binding.outcomes){
+    const workspace=path.join(root,'aw-workshop-'+outcome);assert.equal(fs.existsSync(workspace),false);
+    const output=await api[binding.functionName](workspace,{outcome});
+    assert.equal(output.packageVersion,pkg.version);assert.equal(output.outcome,outcome);assert.equal(output.publicInventedOnly,true);assert.equal(output.participantChoice,'fixture');assert.equal(output.humanAcceptance,false);
+    const actual=fs.realpathSync(workspace);assert.ok(actual.startsWith(fs.realpathSync(root)+path.sep));
+    const sourceFile=fs.realpathSync(path.join(actual,'records/checklist.md'));assert.ok(sourceFile.startsWith(actual+path.sep));const sourceBytes=fs.readFileSync(sourceFile);assert.equal(sha(sourceBytes),output.sourceReadbackSha256);
+    const store=coauthorAPI.createCoauthorStore({workspaceRoot:actual}),reopened=store.read('invented-workshop-'+outcome);
+    if(typeof store.close==='function')store.close();
+    assert.deepEqual(reopened.saved.map(s=>s.text),[output.originalWords,output.interpretation,outcome]);assert.notEqual(output.originalWords,output.interpretation);
+    const independentProject=projectAPI.resolveProjectConfig({cwd:actual,argv:['--project',path.join(actual,'atelier.project.json')],env:{},writeLocalState:false}),graph=graphAPI.buildCanonicalGraph(independentProject);assert.equal(graph.ok,true);
+    assert.equal(graph.nodes.length,output.afterGraph.nodes);assert.equal(graph.edges.length,output.afterGraph.edges);
+    assert.equal(output.ownerCorrection,outcome==='revision');assert.equal(output.reopenedSame,true);assert.equal(output.pauseRecoveryPreserved,true);assert.equal(output.unconfirmedInterpretationSaveRefused,true);assert.equal(output.duplicateSaveNoAdditionalEffect,true);
+    if(outcome==='revision'){assert.ok(sourceBytes.toString('utf8').includes('    supports: ["devday:workshop"]'));assert.ok(graph.edges.some(e=>e.source==='devday:checklist'&&e.type==='supports'&&e.target==='devday:workshop'));assert.equal(output.sourceDriftWriteRefused,true);}else assert.ok(sourceBytes.toString('utf8').includes('    supports: []'));
+    // Source runner reports do not substitute for independent native UI,
+    // same-check assessment and typed disposition evidence. Keep those gaps.
+    rows.push({outcome,output,independent:{sourceSha256:sha(sourceBytes),reopened,graph},scope:'Actual installed fixture exercise and independent current source/coauthor/graph readback; not native UI or semantic/human acceptance'});
+  }
+  return {installedExport:{specifier,path:path.relative(packageRoot,exportedFile),sha256:sha(fs.readFileSync(exportedFile))},rows,fullInstalledKnowledgeHealthJourneyQualified:false,nativeTypedDispositionQualified:false,humanAcceptance:false,remaining:['Actual same-check assessment/current evidence with owner-bound typed reference','Normal shipped guided host/native caller and keyboard/recovery capture','Actual human observations'],sourceModuleInjected:false};
+}

package/src/knowledge-health/rule-identity.mjs

@@ -0,0 +1,44 @@
+export const ruleIdentity = Object.freeze({
+  "profile": "source-qualified-required-direction/r1",
+  "commit": "fcfdbe5ded672d41c717f49e0cfdf68b6060834d",
+  "tree": "400e181cd0cb55976f3ef7ab1a1405531dacd521",
+  "files": [
+    {
+      "path": "src/knowledge/plan.mjs",
+      "bytes": 4609,
+      "sha256": "7ee8d7d20fcc85264dd484b129eae9a1ab4424b47aae0cce764f9e769fe32336",
+      "blob": "b029609a678354f188980acb8954030daa817582"
+    },
+    {
+      "path": "src/knowledge/context.mjs",
+      "bytes": 12590,
+      "sha256": "29a73bc8e1afa498f1ed11e158379317cf738a898a68930d95b90b1f1f395d0d",
+      "blob": "7d2be260883267277050c6f7f1f0b0cd6888e5a4"
+    },
+    {
+      "path": "src/graph/graph.mjs",
+      "bytes": 9934,
+      "sha256": "1f01fbeab7e6fcaed127c8fe84c9a48b08f1fec13d21f486c48726715a5bbb92",
+      "blob": "6bce4e1213098457097e025f8ead53e6b4403336"
+    },
+    {
+      "path": "src/graph/knowledge-graph.mjs",
+      "bytes": 65477,
+      "sha256": "94895598d388e80a70b7bbe92ad57138dccd94896699a6c472e635d885b1139f",
+      "blob": "283ef86ad08a6360bc006cc75ca5cedb2718e14d"
+    },
+    {
+      "path": "templates/knowledge-workspace/knowledge-plan.schema.json",
+      "bytes": 6557,
+      "sha256": "71a6777af291b20a90635be3d3d13fdb4a9bca1104b4ef364a7b7c0e8c8100a0",
+      "blob": "4781dcda5f91f450544fb37e30a48ce9db8a1d5a"
+    }
+  ],
+  "releaseVersion": null,
+  "scope": "Native source authority only: the commit and tree name where these rule and schema files were read, and each file is pinned by its blob. This is not a release candidate identity; a package version label or a later commit is not implied.",
+  "supersededQualification": {
+    "commit": "b1bdc9279a99f7c884ddfdfe0e2a24315d6f3666",
+    "tree": "2797f44baf89007d3808675d897e55a943fc0d65",
+    "note": "The supplier qualified against this earlier commit. The five pinned files are byte-identical there and at the source authority above."
+  }
+})

package/src/knowledge-health/workshop-composition.mjs

@@ -0,0 +1,19 @@
+import path from 'node:path'
+import { resolveProjectConfig } from '../project/config.mjs'
+import { createKnowledgeSessions } from '../knowledge/sessions.mjs'
+import { inspectPublicWorkshop, publicWorkshopProfile, preparePublicWorkshopHandoff } from './workshop-profile.mjs'
+
+// A callable default over the same session/store used by /knowledge. No new
+// ledger, model, receipt algorithm, source writer, editor or server is opened.
+export function createPublicWorkshopComposition({ workspaceRoot }) {
+  const project = resolveProjectConfig({ cwd: workspaceRoot,
+    argv: ['--project', path.join(workspaceRoot, 'atelier.project.json')], env: {}, writeLocalState: false })
+  const sessions = createKnowledgeSessions(project)
+  return { ...sessions,
+    inspect: () => inspectPublicWorkshop({ workspaceRoot }),
+    profile: () => sessions.workshopProfile(),
+    prepareHandoff: id => preparePublicWorkshopHandoff(sessions.read(id)),
+    authority: Object.freeze({ savedMeaning: 'private-draft-only', directWrite: false,
+      typedFindingDisposition: false, sourceEditsApplied: false }) }
+}
+export { inspectPublicWorkshop, publicWorkshopProfile, preparePublicWorkshopHandoff }

package/src/knowledge-health/workshop-profile.mjs

@@ -0,0 +1,176 @@
+import { canonicalize } from '../attestation/jcs.mjs'
+import { contentDigest } from '../coauthor/session.mjs'
+import { assessKnowledgeHealthWorkshop } from './workshop.mjs'
+
+// A consumer profile of the existing knowledge-session descriptor and coauthor
+// fields. These are private drafts, not typed native finding-disposition receipts.
+export const PUBLIC_WORKSHOP_FLOW = Object.freeze({
+  id: 'workshop', title: 'Workshop',
+  description: 'Read the finding, retain your words, and choose your response.',
+  prompts: [
+    ['original-words', 'What do you make of this finding?', 'Your wording is retained exactly. A missing relationship does not decide readiness.'],
+    ['interpretation', 'Optional interpretation', 'Leave it empty, or record a separate interpretation. Proposed wording requires confirmation.'],
+    ['choice', 'Which response do you choose?', 'Choose note, perspective-only, disagreement or pause. Review is a separate optional action.'],
+  ],
+})
+export const PUBLIC_WORKSHOP_CHOICES = Object.freeze(['note', 'perspective-only', 'disagreement', 'pause'])
+const LEGACY_WORKSHOP_CHOICES = [...PUBLIC_WORKSHOP_CHOICES, 'revision']
+export const PUBLIC_PARTICIPANT_PROFILE = 'four-choice-separate-review-r1'
+export const PUBLIC_WORKSHOP_REVIEW_FLOW = Object.freeze({ id: 'workshop-review', title: 'Review selected declaration',
+  prompts: [['authored-revision', 'Selected draft declaration', 'Save the selected declaration as a private draft. Source-owner editing remains separate.']] })
+
+export function inspectPublicWorkshop({ workspaceRoot }) {
+  return assessKnowledgeHealthWorkshop({ workspaceRoot })
+}
+
+export function publicWorkshopProfile(workspaceRoot) {
+  const observation = inspectPublicWorkshop({ workspaceRoot })
+  const a = observation.assessment, f = a.findings?.[0], e = a.evidence
+  if (a.status !== 'needs-attention' || a.coverage !== 'complete' || a.currency !== 'current'
+    || a.refusal !== null || a.findings.length !== 1 || !f.actionable
+    || f.source.id !== 'devday:checklist' || f.declaration.id !== 'kg.relations.supports'
+    || e.relationId !== 'checklist-workshop' || e.questionId !== 'workshop-readiness'
+    || f.declaration.quote !== '[]') throw new Error('public workshop finding unavailable')
+  const findingReference = { id: f.referenceKey, checkId: f.check.id, checkVersion: f.check.version,
+    planSha256: e.planSha256, readSetSha256: e.readSetSha256, comparisonSha256: e.comparisonSha256 }
+  if (Object.values(findingReference).some(v => typeof v !== 'string' || !v)
+    || [e.planSha256, e.readSetSha256, e.comparisonSha256].some(v => !/^[a-f0-9]{64}$/.test(v)))
+    throw new Error('public workshop finding fingerprints unavailable')
+  const context = { ...structuredClone(observation.context), findingReference,
+    workshop: structuredClone(observation.workshop), finding: structuredClone(f),
+    meaning: 'ordinary-public-coauthor-drafts', participantResponseProfile: PUBLIC_PARTICIPANT_PROFILE, typedFindingDisposition: false,
+    sourceApply: 'source-owner-copy-only', semanticSupport: 'unassessed' }
+  return { flow: PUBLIC_WORKSHOP_FLOW, context, ref: 'records/checklist.md',
+    sourceDigest: f.source.sha256, contextDigest: contentDigest(canonicalize(context)) }
+}
+
+// Validate only this consumer's ordinary draft fields. The owning engine still
+// owns revisions, confirmation, event identity, saves, receipts and recovery.
+function validateLegacyPublicWorkshopEvent(record, state, event) {
+  if (record.flow !== PUBLIC_WORKSHOP_FLOW.id || !['answer', 'propose'].includes(event?.type)) return
+  const field = state.fields[state.index]?.id
+  if (field === 'choice' && !LEGACY_WORKSHOP_CHOICES.includes(event.text))
+    throw new Error('choose an exact public workshop response')
+  if (field === 'authored-revision') {
+    const choice = state.saved.find(s => s.fieldId === 'choice')?.text
+    if (event.text !== (choice === 'revision' ? '["devday:workshop"]' : 'none'))
+      throw new Error('revision wording must match the retained explicit choice')
+  }
+}
+
+function prepareLegacyPublicWorkshopHandoff(session) {
+  const { record, state, current } = session
+  if (!current || record.flow !== PUBLIC_WORKSHOP_FLOW.id || state.phase !== 'complete')
+    throw new Error('a complete current public workshop draft is required')
+  const values = Object.fromEntries(state.saved.map(s => [s.fieldId, s.text]))
+  if (values.choice !== 'revision' || values['authored-revision'] !== '["devday:workshop"]')
+    throw new Error('an explicitly retained revision choice is required')
+  const anchor = record.context.workshop.binding.field
+  return { sessionId: record.id, viewId: 'knowledge-workshop', path: 'records/checklist.md',
+    action: 'copy.repoPath', actor: record.author,
+    intent: 'Source owner reviews one supporting declaration.', directWrite: false, applyEndpoint: null,
+    diff: { source: record.context.workshop.binding.source, anchor, replacement: values['authored-revision'] },
+    proposal: { directWrite: false, applyEndpoint: null,
+      reason: 'Retained participant wording; source-owner editing and readback remain explicit.',
+      originalWords: values['original-words'], interpretation: values.interpretation, choice: values.choice,
+      authoredRevision: values['authored-revision'], findingReference: record.context.findingReference,
+      source: record.context.workshop.binding.source, anchor,
+      readSet: record.context.assessment.evidence.readSet,
+      savedDraftReceipts: state.saved.map(s => s.receipt), sourceEditsApplied: false,
+      typedFindingDisposition: false, semanticAcceptance: false } }
+}
+
+
+// An inert consumer encoding lets the existing nonempty-text draft store retain
+// an explicitly empty interpretation. It changes no owning draft schema.
+export function encodePublicWorkshopInterpretation(text) {
+  checkWords(text, true)
+  return JSON.stringify({ text })
+}
+export function decodePublicWorkshopInterpretation(value) {
+  const parsed = JSON.parse(value)
+  if (!parsed || Array.isArray(parsed) || Object.keys(parsed).join(',') !== 'text')
+    throw new Error('one separately labeled interpretation required')
+  checkWords(parsed.text, true)
+  return parsed.text
+}
+function checkWords(text, optional = false) {
+  if (typeof text !== 'string' || (!optional && !text.trim())
+    || Buffer.byteLength(text, 'utf8') > 512 || Buffer.from(text, 'utf8').toString('utf8') !== text)
+    throw new Error('lossless participant wording exceeds its 512 UTF-8 byte limit')
+}
+export function validatePublicWorkshopEvent(record, state, event) {
+  if (record.context?.participantResponseProfile !== PUBLIC_PARTICIPANT_PROFILE)
+    return validateLegacyPublicWorkshopEvent(record, state, event)
+  if (!['answer', 'propose'].includes(event?.type)) return
+  const field = state.fields[state.index]?.id
+  if (record.flow === 'workshop-review') {
+    if (field !== 'authored-revision' || event.text !== '["devday:workshop"]')
+      throw new Error('only the explicitly selected workshop declaration is supported')
+    return
+  }
+  if (record.flow !== 'workshop') throw new Error('unsupported participant flow')
+  if (field === 'original-words') {
+    if (event.type === 'propose') throw new Error('interpretation must not replace original words')
+    checkWords(event.text)
+  } else if (field === 'interpretation') decodePublicWorkshopInterpretation(event.text)
+  else if (field === 'choice' && (event.type === 'propose' || !PUBLIC_WORKSHOP_CHOICES.includes(event.text)))
+    throw new Error('choose one of the four participant responses yourself; Review is separate')
+}
+export function readPublicWorkshopContribution(session) {
+  const { record, state } = session
+  if (record.flow !== 'workshop' || record.context?.participantResponseProfile !== PUBLIC_PARTICIPANT_PROFILE)
+    throw new Error('four-response participant session required; legacy history stays readable')
+  const saved = Object.fromEntries(state.saved.map(value => [value.fieldId, value]))
+  const lastAnswer = field => state.answers.filter(value => value.fieldId === field).at(-1)
+  const currentChoice = state.fields[state.index]?.id === 'choice' ? state.proposal : null
+  return { sessionId: record.id, originalContributionId: lastAnswer('original-words')?.eventId ?? null,
+    originalChoiceId: lastAnswer('choice')?.eventId ?? null,
+    originalWords: saved['original-words']?.text ?? lastAnswer('original-words')?.text ?? null,
+    interpretation: saved.interpretation ? decodePublicWorkshopInterpretation(saved.interpretation.text) : null,
+    interpretationRecorded: Boolean(saved.interpretation),
+    choice: saved.choice?.text ?? currentChoice?.text ?? null,
+    choiceStatus: saved.choice && session.owningReadbacks?.verified === true ? 'confirmed'
+      : currentChoice ? 'unconfirmed' : 'not-recorded',
+    receipts: state.saved.map(value => value.receipt),
+    owningReadbacks: session.owningReadbacks ?? null,
+    findingReference: structuredClone(record.context.findingReference),
+    typedFindingDisposition: false, semanticAcceptance: false }
+}
+export function publicWorkshopReviewProfile(workspaceRoot, participant) {
+  const contribution = readPublicWorkshopContribution(participant)
+  if (!participant.current || participant.state.phase !== 'complete'
+    || contribution.choiceStatus !== 'confirmed' || !PUBLIC_WORKSHOP_CHOICES.includes(contribution.choice)
+    || !contribution.originalContributionId || !contribution.originalChoiceId)
+    throw new Error('current contribution and both owning readbacks required before separate Review')
+  const profile = publicWorkshopProfile(workspaceRoot)
+  if (canonicalize(profile.context.findingReference) !== canonicalize(participant.record.context.findingReference))
+    throw new Error('finding changed; refresh before selecting a new draft')
+  const context = { ...profile.context, participant: structuredClone(contribution) }
+  return { ...profile, flow: PUBLIC_WORKSHOP_REVIEW_FLOW, context,
+    contextDigest: contentDigest(canonicalize(context)) }
+}
+export function preparePublicWorkshopHandoff(session) {
+  if (session.record.flow !== 'workshop-review') return prepareLegacyPublicWorkshopHandoff(session)
+  const { record, state, current } = session
+  const selected = state.saved.find(value => value.fieldId === 'authored-revision')
+  const participant = record.context.participant
+  if (!current || state.phase !== 'complete' || session.owningReadbacks?.verified !== true
+    || !participant || participant.choiceStatus !== 'confirmed'
+    || !selected || selected.text !== '["devday:workshop"]')
+    throw new Error('current selected draft and both owning readbacks required')
+  const anchor = record.context.workshop.binding.field
+  return { sessionId: record.id, viewId: 'knowledge-workshop', path: 'records/checklist.md',
+    action: 'copy.repoPath', actor: record.author, intent: 'Source owner reviews one supporting declaration.',
+    directWrite: false, applyEndpoint: null,
+    diff: { source: record.context.workshop.binding.source, anchor, replacement: selected.text },
+    proposal: { directWrite: false, applyEndpoint: null, sourceEditsApplied: false,
+      originalWords: participant.originalWords, interpretation: participant.interpretation,
+      choice: participant.choice, originalContributionId: participant.originalContributionId,
+      originalChoiceId: participant.originalChoiceId, contributionSessionId: participant.sessionId,
+      authoredRevision: selected.text, findingReference: record.context.findingReference,
+      source: record.context.workshop.binding.source, anchor, readSet: record.context.assessment.evidence.readSet,
+      savedDraftReceipts: [...participant.receipts, selected.receipt],
+      selectedDraftReceipt: selected.receipt, declarationBytes: { encoding: 'utf8', before: anchor.quote, after: selected.text },
+      typedFindingDisposition: false, semanticAcceptance: false } }
+}