@atmem/architect 0.0.0-stage → 0.2.0

package/src/approval-applications.mjs

@@ -0,0 +1,82 @@
+import {existingDeployment} from './deployment-ownership.mjs';
+import {sha256} from '@noble/hashes/sha2.js';
+const canonical=v=>Array.isArray(v)?v.map(canonical):plain(v)?Object.fromEntries(Object.keys(v).sort().map(k=>[k,canonical(v[k])])):v;
+const bytes=v=>new TextEncoder().encode(v).length;
+const plain=v=>v!==null&&typeof v==='object'&&!Array.isArray(v)&&[Object.prototype,null].includes(Object.getPrototypeOf(v));
+const fail=()=>{throw Error('Invalid approval application declaration; no fields were discarded.');};
+const exact=(v,keys)=>{if(!plain(v)||Object.keys(v).length!==keys.length||keys.some(k=>!Object.hasOwn(v,k)))fail();};
+const integer=(v,min,max)=>Number.isSafeInteger(v)&&v>=min&&v<=max;
+function json(value,depth=0){
+ if(depth>32)fail();
+ if(typeof value==='string'){try{encodeURIComponent(value);}catch{fail();}}
+ else if(Array.isArray(value))value.forEach(v=>json(v,depth+1));
+ else if(plain(value))Object.values(value).forEach(v=>json(v,depth+1));
+ else if(value!==null&&typeof value!=='boolean'&&!Number.isSafeInteger(value))fail();
+}
+function schema(v,depth,budget){
+ if(depth>8||--budget.count<0||!plain(v))fail();
+ const shapes={object:['type','properties','required'],array:['type','items','maxItems'],string:['type','minBytes','maxBytes'],integer:['type','minimum','maximum'],boolean:['type'],enum:['type','values']};
+ if(!Object.hasOwn(shapes,v.type))fail();exact(v,shapes[v.type]);
+ if(v.type==='object'){
+  if(!plain(v.properties)||Object.keys(v.properties).length<1||Object.keys(v.properties).length>32||Object.keys(v.properties).some(k=>!/^[A-Za-z][A-Za-z0-9_]{0,79}$/.test(k))||!Array.isArray(v.required)||new Set(v.required).size!==v.required.length||v.required.some(k=>typeof k!=='string'||!Object.hasOwn(v.properties,k)))fail();
+  Object.values(v.properties).forEach(s=>schema(s,depth+1,budget));
+ }else if(v.type==='array'){if(!integer(v.maxItems,1,64))fail();schema(v.items,depth+1,budget);}
+ else if(v.type==='string'){if(!integer(v.minBytes,0,64000)||!integer(v.maxBytes,v.minBytes,64000))fail();}
+ else if(v.type==='integer'){if(!Number.isSafeInteger(v.minimum)||!Number.isSafeInteger(v.maximum)||v.minimum>v.maximum)fail();}
+ else if(v.type==='enum'){if(!Array.isArray(v.values)||v.values.length<1||v.values.length>64||new Set(v.values).size!==v.values.length||v.values.some(s=>typeof s!=='string'||bytes(s)<1||bytes(s)>256))fail();}
+}
+const IDENTITY={aws:['REGION','POOL_ID','CLIENT_ID','AUTH_ORIGIN','AUTH_SCOPE'],azure:['TENANT_ID','API_CLIENT_ID','SPA_CLIENT_ID'],gcp:['PROJECT_NUMBER','REGION','SERVICE_NAME'],ibm:['APPID_TENANT_ID','APPID_CLIENT_ID','APPID_ISSUER','AUTH_SCOPE']};
+export function validateApprovalProfile(v){
+ if(v?.format==='approval-application-template-v1')return validateApprovalTemplate(v);
+ json(v);if(bytes(JSON.stringify(v))>64000)fail();
+ exact(v,['format','provider','componentId','environment','accountId','publicOrigin','operationKind','identitySettings','payloadContract','destinationContract']);
+ if(v.format!=='approval-application-v1'||!Object.hasOwn(IDENTITY,v.provider)||typeof v.componentId!=='string'||bytes(v.componentId)<1||bytes(v.componentId)>512||/[\x00-\x1f]/.test(v.componentId)||!['staging','production','qualification'].includes(v.environment)||!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(v.accountId)||!['document','draft','account_change'].includes(v.operationKind))fail();
+ try{
+  const p=new URL(v.publicOrigin),tail=v.publicOrigin.slice(v.publicOrigin.indexOf('://')+3);
+  if(typeof v.publicOrigin!=='string'||/[^\x21-\x7e]/.test(v.publicOrigin)||/[/?#]/.test(tail)||p.username||p.password||!p.hostname||p.port&&(!integer(Number(p.port),1,65535))||p.protocol!=='https:'&&!(p.protocol==='http:'&&['localhost','127.0.0.1','[::1]'].includes(p.hostname)))fail();
+ }catch{fail();}
+ exact(v.identitySettings,IDENTITY[v.provider]);if(Object.values(v.identitySettings).some(s=>typeof s!=='string'||bytes(s)<1||bytes(s)>2000))fail();
+ const p=v.payloadContract;exact(p,['version','id','source','result']);if(p.version!==1||typeof p.id!=='string'||!/^[a-z][a-z0-9-]{0,79}$/.test(p.id)||bytes(JSON.stringify(p))>64000)fail();
+ const budget={count:256};for(const side of ['source','result']){schema(p[side],0,budget);if(p[side].type!=='object')fail();}
+ const d=v.destinationContract;const keys=['id','endpointSha256','scope','mappingVersion'];if(Object.hasOwn(d||{},'payloadContractSha256'))keys.push('payloadContractSha256');exact(d,keys);
+ if(typeof d.id!=='string'||!/^[a-z0-9-]{1,80}$/.test(d.id)||typeof d.endpointSha256!=='string'||!/^[0-9a-f]{64}$/.test(d.endpointSha256)||typeof d.scope!=='string'||d.scope.length<1||d.scope.length>200||/[^\x21-\x7e]/.test(d.scope)||!integer(d.mappingVersion,1,10000)||d.payloadContractSha256!==undefined&&!/^[0-9a-f]{64}$/.test(d.payloadContractSha256))fail();
+ if(d.payloadContractSha256!==undefined){const hash=Array.from(sha256(new TextEncoder().encode(JSON.stringify(canonical(p)))),b=>b.toString(16).padStart(2,'0')).join('');if(hash!==d.payloadContractSha256)fail();}
+ return structuredClone(v);
+}
+export function outputReference(v){
+ exact(v,['nativeOutput']);const r=v.nativeOutput;exact(r,['componentId','provider','environment','name']);
+ if(typeof r.componentId!=='string'||bytes(r.componentId)<1||bytes(r.componentId)>512||/[\x00-\x1f]/.test(r.componentId)||!['aws','azure','gcp','ibm','tools'].includes(r.provider)||!['staging','production','qualification'].includes(r.environment)||typeof r.name!=='string'||!/^[A-Za-z][A-Za-z0-9_]{0,79}$/.test(r.name)||/secret|password|credential|private_?key/i.test(r.name))fail();
+ return r;
+}
+export function approvalReferences(v){
+ const refs=[];
+ if(plain(v.publicOrigin))refs.push({path:'publicOrigin',...outputReference(v.publicOrigin)});
+ for(const section of ['identitySettings','destinationContract'])for(const[key,value]of Object.entries(v[section]||{}))if(plain(value))refs.push({path:section+'/'+key,...outputReference(value)});
+ return refs;
+}
+function validateApprovalTemplate(v){
+ json(v);if(bytes(JSON.stringify(v))>64000)fail();const trial=structuredClone(v);trial.format='approval-application-v1';
+ const refs=approvalReferences(v);if(!refs.length)fail();
+ for(const r of refs){
+  if(r.environment!==v.environment||r.path.startsWith('identitySettings/')&&r.provider!==v.provider)fail();
+  if(r.path==='publicOrigin')trial.publicOrigin='https://unresolved.invalid';
+  else if(r.path.startsWith('identitySettings/'))trial.identitySettings[r.path.split('/')[1]]='UNRESOLVED_NATIVE_OUTPUT';
+  else if(['destinationContract/endpointSha256','destinationContract/scope'].includes(r.path))trial.destinationContract[r.path.split('/')[1]]=r.path.endsWith('endpointSha256')?'0'.repeat(64):'unresolved';
+  else fail();
+ }
+ validateApprovalProfile(trial);return structuredClone(v);
+}
+export function approvalProfiles(project){
+ const selected=[];
+ for(const node of project.nodes||[]){
+  if(node.data?.approvalProfile===undefined||node.data.approvalProfile===null)continue;
+  const profile=validateApprovalProfile(node.data.approvalProfile);
+  if(node.data.kind==='note'||node.data.binding||node.data.implementation!=='approval-workflow'||node.data.provider!==profile.provider||node.id!==profile.componentId||existingDeployment(node)||node.data.origin!==undefined&&node.data.origin!=='proposed')throw Error('Approval application must bind its exact proposed component/provider; preserve existing ownership.');
+  for(const ref of approvalReferences(profile)){
+   const source=project.nodes.find(n=>n.id===ref.componentId);
+   if(!source||source.data.kind==='note'||source.data.provider!==ref.provider)throw Error('Native output reference must retain an existing graph component/provider; no source was substituted.');
+  }
+  selected.push({node,profile});
+ }
+ return selected;
+}

package/src/approval-spec-kit.mjs

@@ -0,0 +1,30 @@
+import {approvalProfiles,approvalReferences} from './approval-applications.mjs';
+import {resourceAddress} from './identifiers.mjs';
+export function applyApprovalTasks(project,files,tasks){
+ for(const {node,profile}of approvalProfiles(project)){
+  const root='terraform/applications/'+resourceAddress(node.id)+'/',deferred=profile.format==='approval-application-template-v1',metadata=deferred?'application-template.json':'application-profile.json';
+  const parent=tasks.find(t=>t.id.startsWith('TASK-RESOURCE-')&&t.componentIds?.includes(node.id));
+  if(!parent)throw Error('Selected application lost its component implementation task.');
+  const paths=Object.keys(files).filter(p=>p.startsWith(root));parent.files=[...new Set([...(parent.files||[]),...paths])];
+  parent.steps.push('Read '+root+metadata+', api.py and assembly-status.json. This is shared API source only; implement provider resources and the complete domain/worker behavior without deleting requirements or clearing work gates.');
+  const id='TASK-APP-ASSEMBLY-'+resourceAddress(node.id);
+  parent.dependsOn=[...new Set([...(parent.dependsOn||[]),id])];
+  tasks.push({id,phase:'Implementation',title:'Implement the selected approval application source: '+node.data.label,dependsOn:['TASK-SETUP','TASK-SECURITY-DESIGN'],componentIds:[node.id],requirementIds:parent.requirementIds||[],files:paths,steps:[
+   'Retain exact component/provider/environment/account and complete requirements; reconcile '+profile.environment+' against the intended deployment environment.',
+   'Build the emitted API image using the exact lock and native profile. Review native identity/database/API-role and worker-role environment bindings; keep credentials outside source.',
+   'Implement a real domain processor and concrete worker entrypoint using create_native_worker; use the profile-bound destination and membership_key for explicitly admitted native users. Do not substitute fixture behavior or metadata-selected imports.',
+   'Run clean local HTTP/queue/SQL/TLS positive and negative source checks including changed policy, authorization, idempotency and unknown effects. Record fixture boundaries; the dependent component/integration tasks still own provider resources and real destination compatibility.'
+  ],outputs:['Explicit runtime/profile input contract','Concrete domain source and worker entrypoint','Artifact-bound local source/integration evidence'],acceptance:['All linked requirements retain their original text/ownership.','API/worker/domain source has independent executable checks.','Provider linkage, schema/mocks and whole-system acceptance remain separate dependent work.']});
+  if(deferred){
+   const refs=approvalReferences(profile),bindingId='TASK-APP-BINDING-'+resourceAddress(node.id);
+   const sourceTasks=[...new Set(refs.map(ref=>tasks.find(t=>t.id.startsWith('TASK-RESOURCE-')&&t.componentIds?.includes(ref.componentId))?.id))];
+   if(sourceTasks.includes(undefined))throw Error('Application output source lost its component task.');
+   tasks.push({id:bindingId,phase:'Implementation',title:'Resolve public runtime inputs: '+node.data.label,dependsOn:[...new Set([id,parent.id,...sourceTasks])],componentIds:[...new Set([node.id,...refs.map(r=>r.componentId)])],requirementIds:parent.requirementIds||[],files:[root+metadata,root+'resolve-profile.py',root+'workflow_bindings.py'],steps:[
+    'Build source independently of unresolved outputs. When the owned resources or explicit local fixtures supply their outputs, review exact component/provider/environment and source digests; do not invent native IDs or put credentials in the public ledger.',
+    'Run python -I '+root+'resolve-profile.py --outputs /ABSOLUTE/PUBLIC-OUTPUT-LEDGER.json --out /ABSOLUTE/FRESH-BINDING-DIRECTORY. Mount that bundle read-only as runtime-binding before starting the API; reject missing, stale or mismatched receipts.',
+    'Record structural resolution separately from real source/cloud identity, authorization and operating acceptance. Local fixtures must remain labelled; no cloud operation is authorized by this task.'
+   ],outputs:['Fresh application-profile.json and matching binding-receipt.json outside source control','Exact input/artifact digests and disclosed fixture boundaries'],acceptance:['No fallback or fixed ownership/policy change.','Unresolved and mismatched bundles fail before native runtime setup.','Connected acceptance uses the exact resolved application declaration.']});
+   for(const task of tasks)if(task.id==='TASK-E2E'||task.id.startsWith('TASK-ACCEPTANCE-')&&task.componentIds?.includes(node.id))task.dependsOn=[...new Set([...task.dependsOn,bindingId])];
+  }
+ }
+}

package/src/architecture-activity.css

@@ -0,0 +1,28 @@
+.build-design-button { gap:6px; white-space:normal; }
+.conversation-activity { min-width:0; }
+.turn-activity { min-width:0; margin:5px 0 12px; color:var(--muted); font-size:12px; }
+.turn-activity-row { display:flex; gap:8px; align-items:center; min-width:0; }
+.turn-activity-toggle { display:flex; align-items:center; min-width:0; flex:1; gap:5px; border:0; border-radius:5px; padding:5px 2px; min-height:30px; background:transparent; color:inherit; font:inherit; text-align:left; cursor:pointer; }
+.turn-activity-toggle:hover { color:var(--ink); }
+.turn-activity-toggle:focus-visible,.turn-inline-action:focus-visible { outline:2px solid var(--action); outline-offset:3px; }
+.turn-activity-label { flex-shrink:0; }
+.turn-latest { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.turn-chevron { margin-left:auto; padding-left:4px; }
+.turn-state-icon { display:inline-block; width:14px; text-align:center; flex-shrink:0; }
+.turn-state-icon.is-working { animation:turn-working 1.5s linear infinite; }
+.turn-inline-action { flex-shrink:0; border:0; background:transparent; color:var(--muted); text-decoration:underline; font:inherit; min-height:30px; padding:4px; cursor:pointer; }
+.turn-activity-details { margin:2px 0 0 7px; padding:2px 0 2px 14px; border-left:1px solid var(--line); overflow-wrap:anywhere; }
+.turn-activity-details ol { list-style:none; margin:0; padding:0; }
+.turn-activity-details li { padding:4px 0; margin:0; }
+.turn-activity-details p { margin:3px 0; }
+.turn-selection { font-size:11px; color:var(--muted); margin-bottom:8px; }
+.turn-activity-details .chat-markdown { color:var(--ink); }
+.turn-activity-details pre { white-space:pre-wrap; overflow-wrap:anywhere; }
+.legacy-activity { border-block:1px solid var(--line); margin:10px 0; color:var(--muted); font-size:12px; }
+.legacy-activity > summary { padding:9px 2px; cursor:pointer; }
+.legacy-activity > p { margin:4px 0 8px; }
+.turn-activity.has-error .turn-activity-label { color:var(--color-error,#a82837); }
+@keyframes turn-working { to { transform:rotate(360deg); } }
+@media (prefers-reduced-motion:reduce) { .turn-state-icon.is-working { animation:none; } }
+
+@media (max-width:480px) { .turn-activity-toggle,.turn-inline-action { min-height:40px; } }

package/src/architecture-activity.mjs

@@ -0,0 +1,63 @@
+export const ACTIVITY_KINDS=['context_started','context_ready','pass_started','model_started','model_message','model_checked','response_repair','tool_started','tool_finished','tool_cached','response_ready','failed','cancelled'];
+export function architectureTurns(project){
+ const value=project.extensions?.architectureActivity;
+ if(value===undefined)return [];
+ if(value.version!==1||!Array.isArray(value.turns)||value.turns.length>1000)throw Error('Unsupported or oversized architecture activity history. Keep the original project file.');
+ const seen=new Set();
+ for(const t of value.turns){if(t?.requestIds!==undefined&&(!Array.isArray(t.requestIds)||t.requestIds.length>1000||t.requestIds.some(id=>typeof id!=='string'||id.length>100)))throw Error('Invalid architecture request association.');if(!t||typeof t.id!=='string'||!/^[a-f0-9-]{36}$/.test(t.id)||seen.has(t.id)||typeof t.model!=='string'||typeof t.provider!=='string'||!['submitted','response_received','failed','cancelled'].includes(t.clientStatus))throw Error('Invalid architecture turn identity.');seen.add(t.id);}
+ return value.turns;
+}
+export function recordArchitectureTurn(project,owner,turn){
+ if(project.id!==owner)return project;
+ const turns=architectureTurns(project);
+ if(turns.some(t=>t.id===turn.id))throw Error('Architecture turn is already recorded; no request was replayed.');
+ const value={version:1,turns:[...turns,{...turn,clientStatus:'submitted'}]};architectureTurns({extensions:{architectureActivity:value}});
+ return {...project,extensions:{...project.extensions,architectureActivity:value}};
+}
+export function finishArchitectureTurn(project,owner,id,clientStatus,detailsAvailable){
+ if(project.id!==owner)return project;
+ const turns=architectureTurns(project);if(!turns.some(t=>t.id===id))return project;
+ const value={version:1,turns:turns.map(t=>t.id===id?{...t,clientStatus,...(detailsAvailable===undefined?{}:{detailsAvailable})}:t)};architectureTurns({extensions:{architectureActivity:value}});
+ return {...project,extensions:{...project.extensions,architectureActivity:value}};
+}
+// Exact request/reply associations keep activity inside the conversation. Older
+// unbound records stay in turn order before the next associated turn; never guess
+// that an unrelated reply belongs to them or discard historical activity.
+export function architectureConversation(project,messages){
+ let turns;try{turns=architectureTurns(project);}catch(error){return [...messages.map((message,index)=>({kind:'message',message,index})),{kind:'activity-error',error:error.message}];}
+ const positions=turns.map(turn=>{
+  const requests=messages.flatMap((m,i)=>m.role==='user'&&turn.requestIds?.includes(m.requestId)?[i]:[]);
+  if(requests.length)return Math.max(...requests)+1;
+  const reply=messages.findIndex(m=>m.activityId===turn.id);return reply<0?null:reply;
+ });
+ const slots=new Map();turns.forEach((turn,i)=>{
+  const at=positions[i]??positions.slice(i+1).find(p=>p!==null)??messages.length;
+  const entries=slots.get(at)||[];entries.push({kind:'activity',turn,number:i+1,unassociated:positions[i]===null});slots.set(at,entries);
+ });
+ return Array.from({length:messages.length+1},(_,i)=>[...(slots.get(i)||[]),...(i<messages.length?[{kind:'message',message:messages[i],index:i}]:[])]).flat();
+}
+export function mergeArchitectureActivity(current,incoming){
+ const map=new Map(current.map(e=>[e.sequence,e]));
+ for(const e of incoming){
+  if(!Number.isSafeInteger(e.sequence)||e.sequence<1||!ACTIVITY_KINDS.includes(e.kind)||typeof e.text!=='string'||e.text.length>16000)throw Error('The service returned unsupported activity details.');
+  if(map.has(e.sequence)&&JSON.stringify(map.get(e.sequence))!==JSON.stringify(e))throw Error('A recorded activity event changed identity.');
+  map.set(e.sequence,e);
+ }
+ return [...map.values()].sort((a,b)=>a.sequence-b.sequence);
+}
+export async function readArchitectureActivity(session,projectId,id,after,signal,fetcher=fetch){
+ const r=await fetcher('/api/architect/activity',{method:'POST',headers:{'Content-Type':'application/json',Authorization:'Bearer '+session.token},body:JSON.stringify({projectId,activityId:id,after}),signal});
+ if(!r.ok){const error=Error(r.status===404?'Detailed activity is not recorded in this service for this turn.':'Architecture activity could not be loaded.');error.status=r.status;throw error;}
+ const value=await r.json();if(value.id!==id||value.projectId!==projectId||!Array.isArray(value.events))throw Error('Activity does not belong to this project and turn.');return value;
+}
+
+export function architectureChatEntries(project,messages){
+ const entries=[];
+ for(const entry of architectureConversation(project,messages)){
+  if(entry.kind==='activity'&&entry.unassociated){
+   const previous=entries.at(-1);if(previous?.kind==='legacy-activity')previous.entries.push(entry);
+   else entries.push({kind:'legacy-activity',id:'legacy:'+entry.turn.id,entries:[entry]});
+  }else entries.push(entry);
+ }
+ return entries;
+}

package/src/architecture-work.mjs

@@ -0,0 +1,176 @@
+import {approvalReferences} from './approval-applications.mjs';
+// Shared context/dependency model. Currency means exact context agreement, never
+// proof that a claimed implementation, test, account plan or deployment succeeded.
+import {engineeringConversation} from './engineering-client.mjs';
+import {externalIdentity} from './external-identities.mjs';
+export const WORK_VERSION=2;
+export const WORK_KINDS=['responsibility','delivery-unit','interface','implementation','assumption','decision','evidence','requirement'];
+const clone=value=>JSON.parse(JSON.stringify(value));
+const order=(a,b)=>a<b?-1:a>b?1:0;
+const plain=value=>value!==null&&typeof value==='object'&&!Array.isArray(value);
+export function canonicalWork(value){
+ return JSON.stringify(value,(_,v)=>plain(v)?Object.fromEntries(Object.keys(v).sort().map(k=>[k,v[k]])):v);
+}
+function text(value,max,name){if(typeof value!=='string'||!value.trim()||[...value].length>max)throw Error(`Invalid ${name}; no content was truncated.`);return value;}
+function only(value,keys,name){if(!plain(value)||Object.keys(value).some(k=>!keys.includes(k)))throw Error(`Invalid ${name} shape; retain the original file.`);}
+function ref(value){return text(value,240,'work reference');}
+function array(value,max,name){if(!Array.isArray(value)||value.length>max)throw Error(`Invalid or oversized ${name}; no records were discarded.`);}
+function assertWorkJSON(v,depth=0){if(depth>40)throw Error('Architecture work is nested too deeply.');if(v===null||typeof v==='string'||typeof v==='boolean')return;if(typeof v==='number'&&Number.isFinite(v))return;if(Array.isArray(v)){v.forEach(x=>assertWorkJSON(x,depth+1));return;}if(plain(v)&&[Object.prototype,null].includes(Object.getPrototypeOf(v))){Object.values(v).forEach(x=>assertWorkJSON(x,depth+1));return;}throw Error('Work data must be lossless finite JSON values.');}
+
+export function emptyArchitectureWork(){return {version:WORK_VERSION,records:[],intents:[],snapshots:[],bindings:[],history:[],artifactMappings:[]};}
+export function validateArchitectureWork(value){
+ if(value===undefined)return emptyArchitectureWork();
+ if(value.version===1){only(value,['version','records','intents','snapshots','bindings','history'],'legacy architecture work');value={...value,version:WORK_VERSION,artifactMappings:[]};}
+ only(value,['version','records','intents','snapshots','bindings','history','artifactMappings'],'architecture work');
+ if(value.version!==WORK_VERSION)throw Error('Unsupported architecture work version; retain the file and use a compatible reader.');
+ for(const key of ['records','intents','snapshots','bindings','history','artifactMappings'])array(value[key],key==='snapshots'?4000:1000,key);
+ const unique=(items,key,name)=>{const seen=new Set();for(const item of items){const id=ref(item[key]);if(seen.has(id))throw Error(`Duplicate ${name}: ${id}`);seen.add(id);}};
+ unique(value.records,'id','work record');unique(value.intents,'id','engineering intent');unique(value.snapshots,'id','context snapshot');unique(value.bindings,'ref','context binding');
+ for(const r of value.records){
+  only(r,['id','kind','title','description','source','agreement','dependsOn','data'],'work record');
+  if(!WORK_KINDS.includes(r.kind)||!['user','agent','import'].includes(r.source)||!['proposed','accepted'].includes(r.agreement))throw Error('Record explicit work kind, provenance and agreement.');
+  text(r.id,200,'work record ID');text(r.title,200,'work title');if(typeof r.description!=='string'||[...r.description].length>16000||!plain(r.data))throw Error('Invalid work description/data; no content was truncated.');
+  array(r.dependsOn,100,'work dependencies');r.dependsOn.forEach(ref);if(new Set(r.dependsOn).size!==r.dependsOn.length)throw Error('Duplicate work dependency.');
+  if(r.kind==='implementation'&&r.data.files!==undefined){array(r.data.files,200,'implementation files');for(const file of r.data.files){text(file,500,'implementation path');if(file.startsWith('/')||/^[A-Za-z]:/.test(file)||/[\x00-\x1f]/.test(file)||file.includes('\\')||file.split('/').some(p=>!p||p==='.'||p==='..'))throw Error('Implementation paths must be relative project files.');}}
+ }
+ for(const i of value.intents){
+  only(i,['id','sessionId','sequence','text','status'],'engineering intent');text(i.sessionId,100,'session ID');text(i.text,80000,'engineering intent');
+  if(!Number.isSafeInteger(i.sequence)||i.sequence<1||!['accepted','pending','uncertain'].includes(i.status))throw Error('Invalid engineering intent identity/status.');
+  if(i.id!==`${i.sessionId}:${i.sequence}`)throw Error('Engineering intent identity differs from its session/sequence.');
+ }
+ const snapshots=new Map(value.snapshots.map(s=>[s.id,s]));
+ for(const s of value.snapshots){only(s,['id','ref','value'],'context snapshot');ref(s.ref);if(!plain(s.value)||s.value.id!==s.ref)throw Error('Invalid context snapshot value.');}
+ for(const b of [...value.bindings,...value.history]){
+  only(b,['ref','snapshotIds','recordedAt','recordedBy','scope'],'context binding');array(b.snapshotIds,2000,'binding sources');b.snapshotIds.forEach(ref);
+  if(new Set(b.snapshotIds).size!==b.snapshotIds.length||!b.snapshotIds.length||b.snapshotIds.some(id=>!snapshots.has(id)))throw Error('A context binding needs unique retained source snapshots.');
+  const refs=b.snapshotIds.map(id=>snapshots.get(id).ref);if(new Set(refs).size!==refs.length||!refs.includes(b.ref))throw Error('A binding must retain its own source exactly once.');
+  if(b.scope!=='context_review_only'||!['user','agent','import'].includes(b.recordedBy)||!/^\d{4}-\d\d-\d\dT/.test(b.recordedAt)||!Number.isFinite(Date.parse(b.recordedAt)))throw Error('Context review is distinct from executed evidence.');
+ }
+ unique(value.artifactMappings,'id','artifact mapping receipt');
+ for(const m of value.artifactMappings){
+  only(m,['id','receiptSha256','sessionId','runId','artifactId','artifactSha256','proposalSha256','contextId','contextRevision','contextSha256','definitionSha256','records','files','sourceSnapshotIds','recordedAt','scope'],'artifact mapping');
+  for(const key of ['id','sessionId','runId','artifactId','contextId'])text(m[key],100,key);
+  for(const key of ['receiptSha256','artifactSha256','proposalSha256','contextSha256','definitionSha256'])if(!/^[a-f0-9]{64}$/.test(m[key]))throw Error('Artifact references require exact SHA-256 digests.');
+  if(m.scope!=='artifact_file_binding_only'||!Number.isSafeInteger(m.contextRevision)||m.contextRevision<1||!Number.isFinite(Date.parse(m.recordedAt)))throw Error('Artifact file binding is distinct from execution or acceptance.');
+  array(m.records,200,'artifact records');if(!m.records.length)throw Error('Empty artifact mapping receipt.');
+  validateArchitectureWork({...emptyArchitectureWork(),records:m.records});
+  if(m.records.some(r=>r.source!=='agent'||r.agreement!=='proposed'))throw Error('Artifact mappings remain proposed.');
+  array(m.files,2000,'artifact file bindings');const paths=new Set();
+  for(const file of m.files){only(file,['path','bytes','sha256'],'artifact file binding');if(paths.has(file.path)||!Number.isSafeInteger(file.bytes)||file.bytes<0||!/^[a-f0-9]{64}$/.test(file.sha256))throw Error('Invalid artifact file binding.');paths.add(file.path);}
+  for(let i=0;i<m.files.length;i+=200)validateArchitectureWork({...emptyArchitectureWork(),records:[{id:'file-paths',kind:'implementation',title:'File paths',description:'',source:'agent',agreement:'proposed',dependsOn:[],data:{files:m.files.slice(i,i+200).map(f=>f.path)}}]});
+  array(m.sourceSnapshotIds,4000,'artifact basis');const refs=new Set();
+  for(const id of m.sourceSnapshotIds){const source=snapshots.get(id);if(!source||refs.has(source.ref))throw Error('Artifact basis must retain unique exact source snapshots.');refs.add(source.ref);}
+  if(!refs.has('project:identity'))throw Error('Artifact basis must retain its project identity.');
+ }
+ assertWorkJSON(value);
+ const encoded=JSON.stringify(value);if(new TextEncoder().encode(encoded).length>1_500_000)throw Error('Architecture work history exceeds its storage bound; retain/archive it before adding more. Nothing was discarded.');
+ return clone(value);
+}
+const stateOf=project=>validateArchitectureWork(project.extensions?.architectureWork);
+function store(project,state){validateArchitectureWork(state);return {...project,extensions:{...project.extensions,architectureWork:state}};}
+
+export function architectureSources(project,state=stateOf(project)){
+ const entries=[];const add=(id,kind,title,value,dependsOn=[])=>entries.push({id,kind,title,value:clone(value),dependsOn:[...new Set([...(id==='project:identity'?[]:['project:identity']),...dependsOn])].sort()});
+ add('project:identity','identity','Project identity',{id:project.id||null});
+ const annotations=(project.nodes||[]).filter(n=>n.data.kind==='note').map(n=>{const {inputPosition,outputPosition,config,provider,origin,...data}=n.data;return {id:n.id,data:{description:'',...data}};}).sort((a,b)=>order(a.id,b.id));
+ add('intent:project','intent','Project intent',{text:project.requirements||'',...Object.fromEntries(['brief','useCases','facts','workflow','domain'].filter(k=>project[k]!==undefined).map(k=>[k,project[k]])),...(annotations.length?{annotations}:{}),...(project.extensions?.terraformState?{terraformState:project.extensions.terraformState}:{})});
+ add('selection:provider','selection','Selected target provider',{provider:project.provider||'tools'});
+ const global=['intent:project','selection:provider',...state.intents.map(i=>'intent:'+i.id)];
+ for(const i of state.intents)add('intent:'+i.id,'intent','Engineering request '+i.sequence,i);
+ for(const r of project.needs||[])add('requirement:'+r.id,'requirement',r.statement,r);
+ for(const a of project.assumptions||[])add('assumption:'+a.id,'assumption',a.statement,a);
+ for(const q of project.openQuestions||[])add('question:'+q.id,'question',q.question,q);
+ for(const d of project.decisions||[])add('decision:'+d.id,'decision',d.title||d.subject||d.id,d,(d.requirementIds?.length?d.requirementIds:(project.needs||[]).filter(r=>!d.links?.length||r.links?.some(id=>d.links.includes(id))).map(r=>r.id)).map(id=>'requirement:'+id));
+ for(const n of project.nodes||[]){
+  if(n.data.kind==='note')continue;
+  const {inputPosition,outputPosition,...meaning}=n.data;
+  const linked=(rows,type)=>rows.filter(r=>r.links?.includes(n.id)).map(r=>type+':'+r.id);
+  const decisions=(project.decisions||[]).filter(d=>d.status==='Accepted'&&(!d.links?.length||d.links.includes(n.id))).map(d=>'decision:'+d.id);
+  const identity=externalIdentity(project,n.id);
+  add('block:'+n.id,'responsibility',n.data.label,{...meaning,...(identity?{externalProvenance:identity}:{})},[...global,...(n.data.approvalProfile?approvalReferences(n.data.approvalProfile).map(ref=>'block:'+ref.componentId):[]),...linked(project.needs||[],'requirement'),...linked(project.assumptions||[],'assumption'),...linked(project.openQuestions||[],'question'),...decisions]);
+ }
+ for(const e of project.edges||[]){
+  const {id,source,target,label}=e;
+  const visual=new Set(['id','type','sourceHandle','targetHandle','style','markerStart','markerEnd','animated','selected','hidden','labelStyle','labelBgStyle','labelShowBg','labelBgPadding','labelBgBorderRadius']);
+  add('interface:'+id,'interface',label||id,Object.fromEntries(Object.entries(e).filter(([key])=>!visual.has(key))),['block:'+source,'block:'+target]);
+ }
+ for(const r of state.records)add('work:'+r.id,r.kind,r.title,r,[...global,...r.dependsOn]);
+ if(new Set(entries.map(e=>e.id)).size!==entries.length)throw Error('Duplicate architecture source identity.');
+ return entries.sort((a,b)=>order(a.id,b.id));
+}
+function context(entries,target){
+ const byId=new Map(entries.map(e=>[e.id,e])),values=new Map(),missing=new Set(),pending=[target];
+ while(pending.length){const id=pending.pop();if(values.has(id)||missing.has(id))continue;const entry=byId.get(id);if(!entry){missing.add(id);continue;}values.set(id,entry);pending.push(...entry.dependsOn);}
+ return {values,missing:[...missing].sort()};
+}
+export function architectureWork(project){
+ const state=stateOf(project),sources=architectureSources(project,state),snapshots=new Map(state.snapshots.map(s=>[s.id,s]));
+ const bindings=new Map(state.bindings.map(b=>[b.ref,b]));
+ const currentValues=new Map(sources.map(e=>[e.id,canonicalWork(e)])),previousValues=new Map(state.snapshots.map(s=>[s.id,canonicalWork(s.value)]));
+ const entities=sources.map(entry=>{
+  const current=context(sources,entry.id),binding=bindings.get(entry.id),previous=new Map((binding?.snapshotIds||[]).map(id=>{const s=snapshots.get(id);return [s.ref,previousValues.get(s.id)];}));
+  const changed=binding?[...new Set([...current.values.keys(),...previous.keys()])].filter(id=>currentValues.get(id)!==previous.get(id)).sort():[];
+  return {...entry,contextStatus:current.missing.length?'missing':!binding?'unreviewed':changed.length?'changed':'current',changedRefs:changed,missingRefs:current.missing,review:binding?{recordedAt:binding.recordedAt,recordedBy:binding.recordedBy,scope:binding.scope}:null};
+ });
+ // Preserve deleted targets as visible orphans, including the original snapshots.
+ for(const b of state.bindings)if(!entities.some(e=>e.id===b.ref))entities.push({id:b.ref,kind:'removed',title:b.ref,contextStatus:'missing',changedRefs:[],missingRefs:[b.ref],review:{recordedAt:b.recordedAt,recordedBy:b.recordedBy,scope:b.scope}});
+ return {format:'atmem.architecture-work',version:WORK_VERSION,projectId:project.id||null,entities,
+  boundary:'Context currency and recorded mappings only. Evidence entries are claims/references, not independently verified execution or acceptance. Free-form engineering intent conservatively affects every work mapping until explicitly reconciled.'};
+}
+export function workContextIdentity(project,target){
+ const current=context(architectureSources(project),target);
+ return canonicalWork({sources:Object.fromEntries(current.values),missing:current.missing});
+}
+export function captureWorkSources(state,entries){
+ const snapshots=[...state.snapshots],ids=[];let next=1;
+ for(const s of snapshots){const n=Number(/^basis-(\d+)$/.exec(s.id)?.[1]);if(Number.isSafeInteger(n))next=Math.max(next,n+1);}
+ for(const value of [...entries].sort((a,b)=>order(a.id,b.id))){
+  let snapshot=snapshots.find(s=>s.ref===value.id&&canonicalWork(s.value)===canonicalWork(value));
+  if(!snapshot){snapshot={id:'basis-'+next++,ref:value.id,value:clone(value)};snapshots.push(snapshot);}ids.push(snapshot.id);
+ }
+ return {snapshots,ids};
+}
+export function applyArchitectureChange(project,owner,change){
+ if(project.id!==owner)return project;
+ if(change.kind==='propose')return proposeWorkRecords(project,change.records);
+ if(change.kind==='review')return reviewWorkContext(project,change.ref,{expectedContext:change.expectedContext});
+ throw Error('Unknown architecture work change.');
+}
+export function reviewWorkContext(project,target,{recordedBy='user',now=new Date(),expectedContext}={}){
+ if(!project.id)throw Error('Save the project identity before recording context review.');
+ const state=stateOf(project),current=context(architectureSources(project,state),target);
+ if(expectedContext!==undefined&&expectedContext!==canonicalWork({sources:Object.fromEntries(current.values),missing:current.missing}))throw Error('Work context changed; inspect its current sources before reviewing.');
+ if(current.missing.length||!current.values.size)throw Error('Resolve missing work references before recording context review.');
+ const snapshots=[...state.snapshots],ids=[];
+ let next=1;for(const s of snapshots){const n=Number(/^basis-(\d+)$/.exec(s.id)?.[1]);if(Number.isSafeInteger(n))next=Math.max(next,n+1);}
+ for(const [id,value] of [...current.values].sort(([a],[b])=>order(a,b))){
+  let snapshot=snapshots.find(s=>s.ref===id&&canonicalWork(s.value)===canonicalWork(value));
+  if(!snapshot){snapshot={id:'basis-'+next++,ref:id,value};snapshots.push(snapshot);}ids.push(snapshot.id);
+ }
+ const binding={ref:target,snapshotIds:ids,recordedAt:now.toISOString(),recordedBy,scope:'context_review_only'};
+ const previous=state.bindings.find(b=>b.ref===target);
+ return store(project,{...state,snapshots,bindings:[...state.bindings.filter(b=>b.ref!==target),binding],history:[...state.history,...(previous?[previous]:[])]});
+}
+export function proposeWorkRecords(project,records){
+ const state=stateOf(project);array(records,200,'work proposal');const byId=new Map(state.records.map(r=>[r.id,r]));
+ for(const row of records){
+  assertWorkJSON(row);
+  if(byId.has(row.id))throw Error('A work proposal cannot overwrite an existing mapping; revise it explicitly.');
+  byId.set(row.id,{...clone(row),source:'agent',agreement:'proposed'});
+ }
+ return store(project,{...state,records:[...byId.values()]});
+}
+export function synchronizeEngineeringIntent(project,sessionId,events,owner=project.id){
+ if(project.id!==owner)return project;
+ text(sessionId,100,'session ID');const state=stateOf(project),byId=new Map(state.intents.map(i=>[i.id,i]));let changed=false;
+ const rank={pending:0,uncertain:1,accepted:2};
+ for(const entry of engineeringConversation(events).filter(e=>e.role==='user')){
+  const id=`${sessionId}:${entry.id}`,old=byId.get(id);
+  if(old&&old.text!==entry.text)throw Error('Saved engineering intent changed identity; retain both histories for reconciliation.');
+  const status=old&&rank[old.status]>rank[entry.status]?old.status:entry.status;
+  const value={id,sessionId,sequence:entry.id,text:entry.text,status};
+  if(canonicalWork(old)!==canonicalWork(value)){byId.set(id,value);changed=true;}
+ }
+ const sessions=new Map([...new Set([...state.intents.map(i=>i.sessionId),sessionId])].map((id,index)=>[id,index]));
+ return changed?store(project,{...state,intents:[...byId.values()].sort((a,b)=>sessions.get(a.sessionId)-sessions.get(b.sessionId)||a.sequence-b.sequence)}):project;
+}

package/src/artifact-work.mjs

@@ -0,0 +1,103 @@
+// Backend-issued file/context bindings remain proposed architecture metadata.
+// This is not a signature, execution result or business acceptance mechanism.
+import {architectureSources,canonicalWork,captureWorkSources,synchronizeEngineeringIntent,validateArchitectureWork} from './architecture-work.mjs';
+import {findCredentials} from './project-file.mjs';
+
+const hash=async text=>[...new Uint8Array(await crypto.subtle.digest('SHA-256',new TextEncoder().encode(text)))].map(b=>b.toString(16).padStart(2,'0')).join('');
+const same=(a,b)=>canonicalWork(a)===canonicalWork(b);
+const sourceMap=(project,ids)=>architectureSources(project).filter(e=>!ids.has(e.id));
+function contextProject(file){
+ // Context comparison must use the exact saved semantics. The legacy diagram
+ // importer normalizes runtime settings and recognized adapter enums; applying
+ // those compiler transformations here could hide a newly supplied contract.
+ if(!['atmem.ai-architect.project','atforma.project'].includes(file.format)||!file.meta||!Array.isArray(file.design?.nodes)||!Array.isArray(file.design?.edges))throw Error('Invalid saved architecture context.');
+ const d=file.discovery||{};
+ return {id:file.meta.id,provider:file.design.provider||'tools',requirements:d.problem||'',nodes:file.design.nodes,edges:file.design.edges,
+  ...Object.fromEntries(['brief','useCases','facts','workflow'].filter(k=>d[k]!==undefined).map(k=>[k,d[k]])),...(file.meta.domain?{domain:file.meta.domain}:{}),
+  needs:file.requirements||[],assumptions:file.assumptions||[],openQuestions:file.openQuestions||[],decisions:file.decisions||[],extensions:file.extensions||{}};
+}
+
+export async function verifyArtifactWork(receipt){
+ if(receipt?.status!=='prepared'||typeof receipt.content!=='string'||new TextEncoder().encode(receipt.content).length>6_000_000||await hash(receipt.content)!==receipt.sha256)throw Error('The mapping receipt digest did not match. No mappings were changed.');
+ const payload=JSON.parse(receipt.content);
+ const keys=['format','version','projectId','sessionId','runId','artifactId','artifactSha256','proposalSha256','context','events','proposal','files','definitionSha256','boundary'];
+ if(Object.keys(payload).some(k=>!keys.includes(k))||keys.some(k=>!(k in payload))||payload.format!=='atmem.architecture-proposal'||payload.version!==1||payload.boundary!=='artifact_file_binding_only')throw Error('Unsupported artifact mapping receipt.');
+ if(payload.context?.projectId!==payload.projectId||typeof payload.context?.content!=='string'||await hash(payload.context.content)!==payload.context.sha256)throw Error('The saved context digest did not match this receipt.');
+ if(findCredentials(payload).length)throw Error('Mapping receipt contains data that looks like a credential.');
+ return {id:receipt.id,receiptSha256:receipt.sha256,payload};
+}
+
+export function applyArtifactWork(project,owner,verified,{now=new Date()}={}){
+ if(project.id!==owner)return project;
+ const {id,receiptSha256,payload:p}=verified;
+ if(p.projectId!==owner||p.context?.projectId!==owner||p.boundary!=='artifact_file_binding_only')throw Error('This mapping receipt belongs to a different project.');
+ if(p.proposal?.version!==1||!Array.isArray(p.proposal.records)||!p.proposal.records.length||p.proposal.records.length>200||Object.keys(p.proposal).some(k=>!['version','records'].includes(k)))throw Error('Invalid artifact work proposal.');
+ const records=p.proposal.records.map(r=>({...r,source:'agent',agreement:'proposed'})),ids=new Set(records.map(r=>'work:'+r.id));
+ if(ids.size!==records.length)throw Error('Repeated work mapping identity.');
+ let basis=contextProject(JSON.parse(p.context.content));
+ if(basis.id!==owner)throw Error('Saved mapping context belongs to another project.');
+ // Merge exact durable client events on both sides; a late reply never replaces
+ // newer local requirements, another session's intent or a switched project.
+ basis=synchronizeEngineeringIntent(basis,p.sessionId,p.events,owner);
+ const current=synchronizeEngineeringIntent(project,p.sessionId,p.events,owner);
+ if(!same(sourceMap(current,ids),sourceMap(basis,ids)))throw Error('The design changed since this package was built. Regenerate against the current requirements before linking mappings.');
+ const state=validateArchitectureWork(current.extensions?.architectureWork);
+ const existing=state.artifactMappings.find(m=>m.id===id);
+ if(existing){if(existing.receiptSha256!==receiptSha256||!same(existing.records,records)||existing.artifactSha256!==p.artifactSha256)throw Error('A mapping receipt cannot change identity.');return current;}
+ const byId=new Map(state.records.map(r=>[r.id,r]));
+ for(const record of records){
+  const old=byId.get(record.id);
+  if(old){
+   const prior=state.artifactMappings.findLast(m=>m.records.some(r=>r.id===record.id));
+   if(!prior||old.source!=='agent'||old.agreement!=='proposed'||!same(old,prior.records.find(r=>r.id===record.id))||prior.sessionId!==p.sessionId)throw Error('A generated mapping conflicts with an existing or accepted record. Keep both histories and resolve the identity explicitly.');
+  }
+  byId.set(record.id,record);
+ }
+ const sourceState={...state,records:[...byId.values()]};
+ const sources=architectureSources({...current,extensions:{...current.extensions,architectureWork:sourceState}});
+ const known=new Set(sources.map(s=>s.id));
+ for(const record of records){
+  if(record.dependsOn.some(ref=>!known.has(ref)))throw Error('The proposal names a missing requirement, block, interface or work reference.');
+  const paths=record.data?.files||[];
+  if(record.kind==='implementation'&&!paths.length)throw Error('Implementation mappings must name captured artifact files.');
+  if(!Array.isArray(paths)||new Set(paths).size!==paths.length||paths.some(path=>!p.files.some(f=>f.path===path)))throw Error('A proposed mapping lacks an actual artifact file binding.');
+ }
+ const captured=captureWorkSources(state,sourceMap(current,ids));
+ const mapping={id,receiptSha256,sessionId:p.sessionId,runId:p.runId,artifactId:p.artifactId,artifactSha256:p.artifactSha256,proposalSha256:p.proposalSha256,
+  contextId:p.context.id,contextRevision:p.context.revision,contextSha256:p.context.sha256,definitionSha256:p.definitionSha256,
+  records,files:p.files,sourceSnapshotIds:captured.ids,recordedAt:now.toISOString(),scope:'artifact_file_binding_only'};
+ const next={...sourceState,snapshots:captured.snapshots,artifactMappings:[...state.artifactMappings,mapping]};
+ const validated=validateArchitectureWork(next);
+ return {...current,extensions:{...current.extensions,architectureWork:validated}};
+}
+
+export function artifactWorkProjection(project){
+ const state=validateArchitectureWork(project.extensions?.architectureWork),sources=architectureSources(project),byId=new Map(sources.map(s=>[s.id,s]));
+ const mappings=state.artifactMappings.map(m=>{
+  const ids=new Set(m.records.map(r=>'work:'+r.id)),expected=m.sourceSnapshotIds.map(id=>state.snapshots.find(s=>s.id===id).value);
+  const before=new Map(expected.map(s=>[s.id,s])),after=new Map(sources.filter(s=>!ids.has(s.id)).map(s=>[s.id,s]));
+  const changedRefs=[...new Set([...before.keys(),...after.keys()])].filter(ref=>!same(before.get(ref),after.get(ref))).sort();
+  for(const record of m.records)if(!same(byId.get('work:'+record.id)?.value,record))changedRefs.push('work:'+record.id);
+  const newer=state.artifactMappings.findLast(x=>x.sessionId===m.sessionId).artifactId!==m.artifactId;
+  return {...m,contextStatus:newer?'superseded':changedRefs.length?'changed':'current',changedRefs:[...new Set(changedRefs)]};
+ });
+ const coverage=sources.filter(s=>['requirement','responsibility','interface'].includes(s.kind)&&!s.id.startsWith('work:')).map(source=>{
+  const references=[];
+  for(const mapping of mappings.filter(m=>m.contextStatus==='current'))for(const record of mapping.records.filter(r=>r.kind==='implementation')){
+   const pending=[...record.dependsOn],seen=new Set();let linked=false;
+   while(pending.length){
+    const ref=pending.pop();if(seen.has(ref))continue;seen.add(ref);if(ref===source.id)linked=true;
+    const entry=byId.get(ref);
+    // Broad change dependencies (for example an unscoped ADR) are not claims
+    // that one implementation covers every requirement in that context.
+    if(ref.startsWith('work:'))pending.push(...(entry?.value.dependsOn||[]));
+    else if(ref.startsWith('block:'))pending.push(...(project.needs||[]).filter(r=>r.links?.includes(ref.slice(6))).map(r=>'requirement:'+r.id));
+    else if(ref.startsWith('interface:')&&entry)pending.push('block:'+entry.value.source,'block:'+entry.value.target);
+   }
+   if(linked)references.push({recordId:record.id,artifactId:mapping.artifactId,files:record.data.files||[]});
+  }
+  return {ref:source.id,title:source.title,status:references.length?'file_reference_linked':'unmapped',references};
+ });
+ return {format:'atmem.architecture-artifact-mappings',version:1,projectId:project.id,mappings,coverage,
+  boundary:'References to server-bound artifact files and saved context, not execution, acceptance or compiler coverage. Reopened project metadata is not an authenticated receipt; use the owning session service to reverify it.'};
+}