@awebai/oats 0.24.1 → 0.24.2

package/capabilities/oats-aweb/lib/captured-execution.mjs

@@ -0,0 +1,91 @@
+// Execution-only consumption of the kernel's selected private snapshots.
+// This establishes correspondence/custody, NOT native human/team authority.
+// No kernel index, source checkout, ambient team/root, or credential is read.
+import fs from 'node:fs';
+import {dirname,isAbsolute,resolve} from 'node:path';
+import {parseBindingJson,BINDING_WIRE_LIMITS} from './binding-wire.mjs';
+import {INVOCATION_LIMITS,sameInvocationJson as same} from './invocation-shape.mjs';
+import {validateAwebBinding,validateAwebInvocationContext} from './portable-binding.mjs';
+const CAPABILITY='oats.aweb';
+const RECEIPT_LIMITS={bytes:256*1024,depth:32,entries:16384};
+const markers=['OATS_BINDING_FILE','OATS_INVOCATION_CONTEXT_FILE','OATS_SOURCE_RECEIPT_FILE'];
+const invalid=()=>{throw Object.assign(new Error('invalid captured aweb execution input'),{code:'invalid-binding'});};
+const absentAuthority=()=>{throw Object.assign(new Error('captured aweb action requires an admitted instance intent'),{code:'authorization-required'});};
+const absolute=p=>typeof p==='string'&&!p.includes('\0')&&isAbsolute(p)&&resolve(p)===p;
+const keys=(value,names)=>value!==null&&typeof value==='object'&&!Array.isArray(value)&&Object.keys(value).length===names.length&&names.every(k=>Object.hasOwn(value,k));
+const statKey=s=>['dev','ino','size','mtimeNs','ctimeNs'].map(k=>String(s[k])).join(':');
+function physical(file){
+  if(!absolute(file))invalid();
+  for(let p=file;;p=dirname(p)){
+    const s=fs.lstatSync(p,{bigint:true});
+    if(s.isSymbolicLink()||(p!==file&&!s.isDirectory()))invalid();
+    if(dirname(p)===p)return s;
+  }
+}
+/** Pin the physical named file to its open descriptor BEFORE every bounded
+ * read, including when an ancestor was redirected only during open(). */
+function snapshot(file,limits){
+  let fd;
+  try{
+    physical(file);
+    const uid=typeof process.getuid==='function'?BigInt(process.getuid()):null;
+    const privateFile=s=>s.isFile()&&s.nlink===1n&&s.size<=BigInt(limits.bytes)&&(s.mode&0o7777n)===0o600n&&(uid===null||s.uid===uid);
+    const before=fs.lstatSync(file,{bigint:true});
+    if(!privateFile(before)||typeof fs.constants.O_NOFOLLOW!=='number'||typeof fs.constants.O_NONBLOCK!=='number')invalid();
+    fd=fs.openSync(file,fs.constants.O_RDONLY|fs.constants.O_NOFOLLOW|fs.constants.O_NONBLOCK);
+    const check=()=>{
+      physical(file);const named=fs.lstatSync(file,{bigint:true}),opened=fs.fstatSync(fd,{bigint:true});
+      if(!privateFile(named)||!privateFile(opened)||statKey(named)!==statKey(before)||statKey(opened)!==statKey(named))invalid();
+    };
+    check();const bytes=Buffer.alloc(Number(before.size));
+    for(let n=0;n<bytes.length;){check();const count=fs.readSync(fd,bytes,n,Math.min(32768,bytes.length-n),n);if(!count)invalid();n+=count;}
+    check();return {value:parseBindingJson(bytes,limits),identity:statKey(before)};
+  }catch{invalid();}finally{if(fd!==undefined)fs.closeSync(fd);}
+}
+function freeze(value){if(value&&typeof value==='object'){for(const v of Object.values(value))freeze(v);Object.freeze(value);}return value;}
+function validateSourceReceipt(receipt,context,binding){
+  if(!keys(receipt,['schemaVersion','kind','home','work','context','agent','instance','sourceIdentity','role','executionBinding','responsibleHuman','binding']))invalid();
+  const i=context.instance;
+  if(!i||receipt.schemaVersion!==1||receipt.kind!==context.subject.kind||receipt.home!==i.home||receipt.work!==i.work||receipt.context!==context.executionBinding.deployment||receipt.agent!==i.agent||receipt.instance!==i.name||typeof receipt.role!=='string'||!receipt.role.trim()||!same(receipt.executionBinding,context.executionBinding)||!same(receipt.responsibleHuman,context.responsibleHuman)||!same(receipt.binding,binding))invalid();
+  if(context.action.kind!=='hook'||!['spawn','retire'].includes(context.action.name)||!same(receipt.sourceIdentity,context.subject.kind==='persistent'?context.subject.soul.identity:null))invalid();
+}
+/** Absence is explicitly legacy. Any supplied input requires the full selected
+ * binding+invocation pair; invalid-present can never select legacy behavior.
+ * assertCurrent is for every native boundary, not a new admission mechanism. */
+export function loadCapturedAwebExecution(env=process.env){
+  if(!markers.some(k=>Object.hasOwn(env,k)))return {kind:'legacy'};
+  if(!Object.hasOwn(env,markers[0])||!Object.hasOwn(env,markers[1]))invalid();
+  const files=markers.filter(k=>Object.hasOwn(env,k)).map(k=>env[k]);if(new Set(files).size!==files.length)invalid();
+  const inputs=files.map((p,i)=>snapshot(p,[BINDING_WIRE_LIMITS,INVOCATION_LIMITS,RECEIPT_LIMITS][i]));
+  let binding,context;
+  try{binding=validateAwebBinding(inputs[0].value);context=validateAwebInvocationContext(inputs[1].value,binding);}catch{invalid();}
+  if(inputs[2])validateSourceReceipt(inputs[2].value,context,binding);
+  const assertCurrent=()=>{
+    files.forEach((p,i)=>{const current=snapshot(p,[BINDING_WIRE_LIMITS,INVOCATION_LIMITS,RECEIPT_LIMITS][i]);if(current.identity!==inputs[i].identity||!same(current.value,inputs[i].value))invalid();});
+  };
+  assertCurrent();
+  return {kind:'captured',binding:freeze(binding),context:freeze(context),sourceReceipt:inputs[2]?freeze(inputs[2].value):null,assertCurrent};
+}
+/** Exact entrypoint and retained instance, not OATS_META/current config, choose
+ * the actor's target. The kernel still owns admission and replay. */
+export function requireCapturedAwebAction(loaded,event,manifest,{env=process.env,cwd=process.cwd()}={}){
+  if(loaded.kind!=='captured'||manifest.capability!==CAPABILITY)invalid();
+  const {context}=loaded,a=context.action,i=context.instance;
+  if(a.kind==='hook'){
+    if(a.capability!==CAPABILITY||a.name!==event||!Object.hasOwn(manifest.hooks||{},event))invalid();
+  }else if(a.kind==='command'){
+    if(a.name!==event||!Object.hasOwn(manifest.commands||{},event)||(a.capability!==CAPABILITY&&a.namespace!==manifest.command))invalid();
+  }else invalid();
+  if(!i||!context.intent)absentAuthority();
+  if(cwd!==i.home)invalid();
+  for(const [key,value] of Object.entries({OATS_HOME:i.home,OATS_INSTANCE_HOME:i.home,OATS_INSTANCE:i.name,OATS_AGENT:i.agent,OATS_CONTEXT:context.executionBinding.deployment,OATS_DEPLOYMENT:context.executionBinding.deployment,OATS_RESOLUTION:context.executionBinding.resolution.id,OATS_CAPABILITY:CAPABILITY}))if(Object.hasOwn(env,key)&&env[key]!==value)invalid();
+  if(a.kind==='hook'&&Object.hasOwn(env,'OATS_EVENT')&&env.OATS_EVENT!==event)invalid();
+  const directories=[i.home,i.work,context.executionBinding.deployment].map(p=>{
+    try{physical(p);const s=fs.lstatSync(p,{bigint:true});if(!s.isDirectory())invalid();return {path:p,dev:s.dev,ino:s.ino};}catch{invalid();}
+  });
+  const assertCurrent=()=>{
+    loaded.assertCurrent();
+    for(const d of directories){try{physical(d.path);const s=fs.lstatSync(d.path,{bigint:true});if(!s.isDirectory()||s.dev!==d.dev||s.ino!==d.ino)invalid();}catch{invalid();}}
+  };
+  assertCurrent();return {binding:loaded.binding,context,sourceReceipt:loaded.sourceReceipt,assertCurrent};
+}

package/capabilities/oats-aweb/lib/captured-native.mjs

@@ -0,0 +1,91 @@
+// Selected-input adapter over EXISTING native aw commands. No account/grant
+// protocol, credential copying, private kernel index or second admission store.
+import fs from 'node:fs';
+import {join} from 'node:path';
+import {parseBindingJson,BINDING_WIRE_LIMITS} from './binding-wire.mjs';
+const fail=(code,message)=>{throw Object.assign(new Error(message),{code});};
+function identityDirectory(home,{required=true}={}){
+ const path=join(home,'.aw');
+ try{const s=fs.lstatSync(path);if(!s.isDirectory()||s.isSymbolicLink()||fs.realpathSync(path)!==path)fail('needs-configuration','native identity directory must be physical and local to its selected home');return path;}
+ catch(e){if(e.code==='ENOENT'&&!required)return null;if(e.code==='needs-configuration')throw e;fail('needs-configuration','the selected home needs an initialized native aw identity');}
+}
+/** `run` is the same bounded, argv-only, redacting native runner used by legacy
+ * hooks. The execution consumer and each call retain the original snapshots.
+ * This function is not callable as a substitute for kernel admission. */
+export function runCapturedNative({selected,event,settings,run,env=process.env}){
+ const {context,binding,assertCurrent}=selected,{home,name}=context.instance,team=binding.payload.privateTeam?.id;
+ let meta=context.priorReceipt===null?null:JSON.parse(JSON.stringify(context.priorReceipt)),invitationToken=null;
+ const roots=new Map();
+ const nativeIdentity=(dir,options)=>{
+  const path=identityDirectory(dir,options);
+  if(!path){if(roots.has(join(dir,'.aw')))fail('invalid-binding','native identity directory disappeared during the captured action');return null;}
+  const s=fs.lstatSync(path),stamp=`${s.dev}:${s.ino}`,prior=roots.get(path);
+  if(prior!==undefined&&prior!==stamp)fail('invalid-binding','native identity directory changed during the captured action');
+  roots.set(path,stamp);return path;
+ };
+ const refusal=(code,message)=>({exitCode:1,output:{...(meta?{meta}:{}),status:'needs-configuration',problems:[{code,message}],warning:`oats-aweb: ${message}; retain the home and any recorded partial effects`}});
+ try{
+  assertCurrent();
+  if(!/^[a-z0-9][a-z0-9._-]{0,127}$/i.test(name)||!team)fail('needs-configuration','exact native alias and private-team selection are required');
+  if(settings.delivery!=='session')fail('needs-configuration','captured delivery must be session');
+  if(binding.payload.wider.length)fail('needs-configuration','selected wider memberships need their explicitly qualified native setup; they were not omitted');
+  // A global override may select a different actor even with an exact cwd.
+  // Do not clear/replace it or borrow that identity to make setup pass.
+  if(env.AWEB_IDENTITY_HOME)fail('needs-configuration','captured setup requires native per-directory identity context, not an external AWEB_IDENTITY_HOME override');
+  const call=(args,cwd=home,{secret=false,allowNativeRemoval=false}={})=>{
+   assertCurrent();nativeIdentity(cwd,{required:false});
+   const out=run(['aw',...args],cwd,45000,{secretSafe:true});
+   assertCurrent();
+   if(allowNativeRemoval){
+    try{fs.lstatSync(join(cwd,'.aw'));nativeIdentity(cwd,{required:false});}catch(e){if(e.code!=='ENOENT')throw e;}
+   }else nativeIdentity(cwd,{required:false});
+   try{return parseBindingJson(Buffer.from(out),BINDING_WIRE_LIMITS);}catch{if(secret)fail('provider-unavailable','native invitation response is unavailable');fail('provider-unavailable','native command returned no bounded JSON observation');}
+  };
+  const plain=(args)=>{assertCurrent();nativeIdentity(home);run(['aw',...args],home,60000,{secretSafe:true});assertCurrent();nativeIdentity(home);};
+  const observe=()=>{
+   nativeIdentity(home);
+   const who=call(['--team',team,'whoami','--json']);
+   const status=call(['--team',team,'workspace','status','--json']),ws=status.workspace;
+   if(who.alias!==name||typeof who.did!=='string'||!/^did:key:[A-Za-z0-9]+$/.test(who.did)||status.selected_team!==team||!ws||ws.alias!==name||ws.workspace_path!==home)fail('needs-configuration','native alias, team and workspace must match the selected instance home');
+   if(invitationToken&&who.did.includes(invitationToken))fail('provider-unavailable','native identity response cannot be safely recorded');
+   if(meta?.did!==undefined&&meta.did!==who.did)fail('needs-configuration','native identity changed from the recorded setup; explicit reconciliation is required');
+   return who.did;
+  };
+  if(event==='setup'){
+   if(!nativeIdentity(home,{required:false}))return{exitCode:0,output:{status:'needs-configuration',problems:[{code:'needs-configuration',message:'use explicit captured spawn with existing native authority in the selected deployment; setup does not provision accounts or teams'}]}};
+   observe();return{exitCode:0,output:{status:'ready',problems:[],scope:'native home association only; no account or private-grant attestation'}};
+  }
+  if(event==='roster'){
+   observe();const result=call(['id','team','members','--team-id',team,'--json']);return{exitCode:0,output:result};
+  }
+  if(event==='spawn'){
+   if(meta!==null||nativeIdentity(home,{required:false}))fail('needs-configuration','existing or uncertain native setup requires explicit reconciliation; no duplicate enrollment');
+   // Deployment is an explicit retained context, never an ambient root search.
+   // Native aw itself decides whether its existing identity may issue an invite.
+   const authority=context.executionBinding.deployment;nativeIdentity(authority);
+   meta={team,delivery:'session',pending:'invite'};
+   const invitation=call(['team','invite','--team-id',team,'--json'],authority,{secret:true});
+   if(typeof invitation?.token!=='string'||!invitation.token)fail('provider-unavailable','native invitation returned no token');
+   invitationToken=invitation.token;
+   meta.pending='join';
+   // Native aw mints the child's own identity; OATS never reads/copies a key.
+   const joined=call(['team','join',invitation.token,'--name',name,'--json'],home,{secret:true});
+   // Never echo server strings or a token disguised as an alias into metadata.
+   if(joined?.alias!==name||joined?.team_id!==team)fail('provider-unavailable','native join did not confirm the exact requested alias and team');
+   meta={team,alias:name,delivery:'session',pending:'connect'};
+   plain(['--team',team,'init','--do-not-touch-agents-md']);
+   const did=observe();meta={team,alias:name,delivery:'session',did,pending:'wake-register'};
+   plain(['wake','register','--home',home,'--identity-home',join(home,'.aw'),'--delivery','session']);
+   meta={team,alias:name,delivery:'session',did};
+   return{exitCode:0,output:{meta,env:{AWEB_DELIVERY:'session'},brief:`Comms: your own native aweb identity is ${name} on ${team}. Notification delivery: external (session); registration is durable, not proof of broker delivery or model consumption. Use aw mail/aw chat from this instance home.`}};
+  }
+  if(event==='retire'){
+   if(!meta||meta.alias!==name||meta.team!==team||meta.delivery!=='session'||typeof meta.did!=='string')fail('needs-configuration','recorded owned native identity is required for cleanup; absence is not proof of no effects');
+   observe();plain(['wake','deregister','--home',home]);
+   const result=call(['--team',team,'workspace','delete',name,'--json'],home,{allowNativeRemoval:true});
+   if(result?.alias!==name||typeof result.deleted_at!=='string')fail('provider-unavailable','native self-delete outcome is unconfirmed');
+   return{exitCode:0,output:{meta:{...meta,retired:true,aliasReusable:result.alias_released===true},...(result.alias_released===true?{}:{warning:'oats-aweb: workspace deleted; alias release was not confirmed'})}};
+  }
+  fail('needs-configuration','this captured native entrypoint is unsupported');
+ }catch(e){return refusal(['needs-configuration','invalid-binding','authorization-required'].includes(e?.code)?e.code:'provider-unavailable',['needs-configuration','invalid-binding','authorization-required'].includes(e?.code)?e.message:'native action failed or is uncertain');}
+}

package/capabilities/oats-aweb/lib/invocation-shape.mjs

@@ -0,0 +1,135 @@
+// Provider-side consumption checks for the kernel-owned CapturedInvocationContext1.
+// Decoded JSON only: no source/config parsing, artifact lookup or authorization.
+// The kernel must verify retained authority before invoking provider code.
+import { isAbsolute, join, resolve } from 'node:path';
+export const INVOCATION_LIMITS=Object.freeze({bytes:512*1024,depth:32,entries:16384});
+export const PRIOR_RECEIPT_LIMITS=Object.freeze({bytes:128*1024,depth:24,entries:8192});
+const fail=()=>{throw Object.assign(new Error('invalid captured invocation'),{code:'invalid-binding'});};
+const obj=value=>value!==null && typeof value==='object' && !Array.isArray(value);
+const canonical=value=>value===null || typeof value!=='object'?JSON.stringify(value):Array.isArray(value)?`[${value.map(canonical).join(',')}]`:`{${Object.keys(value).sort().map(key=>`${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+export const sameInvocationJson=(a,b)=>canonical(a)===canonical(b);
+const same=sameInvocationJson;
+function keys(value,allowed,required=allowed) {if(!obj(value)) fail();for(const key of Object.keys(value)) if(!allowed.includes(key)) fail();for(const key of required) if(!Object.hasOwn(value,key)) fail();}
+function text(value,empty=false) {if(typeof value!=='string' || (!empty && !value.length) || value.includes('\0')) fail();}
+function list(value) {if(!Array.isArray(value)) fail();return value;}
+function absolute(value) {text(value);if(!isAbsolute(value) || resolve(value)!==value) fail();}
+function path(value,root=false) {text(value);if(root && value==='.') return;if(value.startsWith('/') || value.includes('\\') || value.split('/').some(part=>!part || part==='.' || part==='..')) fail();}
+function hash(value) {if(typeof value!=='string' || !/^sha256-[a-f0-9]{64}$/.test(value)) fail();}
+function integrity(value,format) {keys(value,['format','value']);if(value.format!==format) fail();hash(value.value);}
+function capability(value) {text(value);if(!/^(?:@?[a-z0-9][a-z0-9._-]*[./])[a-z0-9][a-z0-9._/-]*$/.test(value)) fail();}
+function repository(value) {
+  if(value?.kind==='canonical-remote') {keys(value,['kind','remote']);text(value.remote);}
+  else if(value?.kind==='provider-repository') {keys(value,['kind','provider','host','id']);text(value.provider);text(value.host);text(value.id);}
+  else fail();
+}
+function soulIdentity(value) {
+  if(value?.kind==='git-soul') {keys(value,['kind','repository','exportPath']);repository(value.repository);path(value.exportPath);}
+  else if(value?.kind==='local-soul') {keys(value,['kind','source','exportPath']);text(value.source);if(!value.source.startsWith('path:')) fail();path(value.exportPath,true);}
+  else fail();
+}
+function artifact(value) {
+  if(value?.kind==='soul') {keys(value,['kind','identity','integrity']);soulIdentity(value.identity);}
+  else if(value?.kind==='capability') {keys(value,['kind','capability','integrity']);capability(value.capability);}
+  else if(value?.kind==='resource') keys(value,['kind','integrity']);
+  else fail();
+  integrity(value.integrity,'oats.tree-exec.v1');
+}
+function resolution(value) {keys(value,['schemaVersion','id']);if(value.schemaVersion!==1) fail();hash(value.id);}
+function incarnation(value) {if(typeof value!=='string' || !/^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(value)) fail();}
+function intent(value,instance) {
+  if(value===null) return;
+  keys(value,['schemaVersion','executionId','incarnationId','attempt']);incarnation(value.incarnationId);
+  if(value.schemaVersion!==1 || typeof value.executionId!=='string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value.executionId) || !Number.isSafeInteger(value.attempt) || value.attempt<1) fail();
+  if(instance===null || value.incarnationId!==instance.incarnationId) fail();
+}
+function origin(value) {
+  keys(value,['kind','document','pointer','span'],['kind','document','pointer']);
+  if(!['soul-requirement','soul-default','workspace-default','import-adoption','operator','package-dependency','work-target','migration-evidence','provider-binding','workspace-admission','member-backlink','source-export','manifest-default'].includes(value.kind)) fail();
+  text(value.pointer,true);if(!/^(?:\/(?:[^~]|~[01])*)*$/.test(value.pointer)) fail();
+  const doc=value.document;
+  if(doc?.kind==='source') {keys(doc,['kind','source','revision','path','integrity']);text(doc.source);text(doc.revision);path(doc.path);integrity(doc.integrity,'oats.bytes.v1');}
+  else if(doc?.kind==='deployment') {keys(doc,['kind','path','integrity']);path(doc.path);integrity(doc.integrity,'oats.bytes.v1');}
+  else if(doc?.kind==='operator') {keys(doc,['kind','id']);text(doc.id);}
+  else if(doc?.kind==='record') {keys(doc,['kind','ref']);resolution(doc.ref);}
+  else if(doc?.kind==='artifact') {keys(doc,['kind','owner','path','integrity']);artifact(doc.owner);path(doc.path);integrity(doc.integrity,'oats.bytes.v1');}
+  else fail();
+  if(Object.hasOwn(value,'span')) {keys(value.span,['start','end']);if(!Number.isSafeInteger(value.span.start) || !Number.isSafeInteger(value.span.end) || value.span.start<0 || value.span.end<value.span.start) fail();}
+}
+function origins(value) {list(value).forEach(origin);}
+function subject(value) {
+  if(value?.kind==='helper') {
+    keys(value,['kind','provider','definition','name']);artifact(value.provider);
+    keys(value.definition,['owner','path','kind']);artifact(value.definition.owner);path(value.definition.path,true);
+    if(value.provider.kind!=='capability' || !same(value.provider,value.definition.owner) || !['file','directory','manifest','skill','runtime-package'].includes(value.definition.kind)) fail();
+    if(typeof value.name!=='string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value.name)) fail();return value.name;
+  }
+  if(value?.kind!=='persistent') fail();keys(value,['kind','soul']);const s=value.soul;
+  keys(s,['identity','revision','alias','sourceArtifact','definition','projection']);soulIdentity(s.identity);artifact(s.sourceArtifact);
+  if(s.sourceArtifact.kind!=='soul' || !same(s.identity,s.sourceArtifact.identity)) fail();
+  if(typeof s.alias!=='string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(s.alias)) fail();path(s.definition);
+  keys(s.projection,['roots']);list(s.projection.roots).forEach(value=>path(value,true));
+  if(!s.projection.roots.length || !s.projection.roots.some(root=>root==='.' || s.definition===root || s.definition.startsWith(`${root}/`))) fail();
+  for(let i=1;i<s.projection.roots.length;i++) if(Buffer.compare(Buffer.from(s.projection.roots[i-1]),Buffer.from(s.projection.roots[i]))>=0) fail();
+  if(s.identity.exportPath!=='.' && !s.definition.startsWith(`${s.identity.exportPath}/`)) fail();
+  const r=s.revision;
+  if(r?.kind==='local') {
+    keys(r,['kind','source','integrity','provenance','repository'],['kind','source','integrity','provenance']);text(r.source);if(!r.source.startsWith('path:')) fail();integrity(r.integrity,'oats.tree-exec.v1');
+    if(!same(r.integrity,s.sourceArtifact.integrity)) fail();
+    if(s.identity.kind==='local-soul') {if(r.source!==s.identity.source || Object.hasOwn(r,'repository')) fail();}
+    else {repository(r.repository);if(!same(r.repository,s.identity.repository)) fail();}
+  } else {
+    keys(r,['identity','remote','selector','commit','provenance']);repository(r.identity);text(r.remote);text(r.selector);
+    if(s.identity.kind!=='git-soul' || !same(r.identity,s.identity.repository) || !/^[a-f0-9]{40}$/.test(r.commit)) fail();
+    if(r.identity.kind==='canonical-remote' && r.identity.remote!==r.remote) fail();
+  }
+  origins(r.provenance);if(!r.provenance.length) fail();return s.alias;
+}
+function context(value) {
+  if(value?.kind==='workspace') {keys(value,['kind','identity','observation']);keys(value.identity,['repository','path']);repository(value.identity.repository);if(value.identity.path!=='oats-workspace.yaml') fail();origin(value.observation);return {kind:'workspace',identity:value.identity};}
+  if(value?.kind==='standalone') {keys(value,['kind','key']);if(value.key!==null) text(value.key);return value;}
+  fail();
+}
+function human(value) {if(value===null) return;keys(value,['provider','id']);text(value.provider);text(value.id);}
+function messaging(value,selectedContext,responsibleHuman) {
+  if(value?.enabled===false) {keys(value,['schemaVersion','enabled']);if(responsibleHuman!==null) fail();}
+  else {
+    keys(value,['schemaVersion','enabled','privateKey','wider','provenance']);if(value.enabled!==true) fail();
+    keys(value.privateKey,['provider','human','context']);capability(value.privateKey.provider);human(value.privateKey.human);
+    if(value.privateKey.human===null || !same(value.privateKey.human,responsibleHuman) || !same(value.privateKey.context,selectedContext) || (selectedContext.kind==='standalone' && selectedContext.key===null)) fail();
+    list(value.wider).forEach(row=>{keys(row,['provider','id']);text(row.id);if(row.provider!==value.privateKey.provider) fail();});
+    for(let i=1;i<value.wider.length;i++) if(Buffer.compare(Buffer.from(canonical(value.wider[i-1])),Buffer.from(canonical(value.wider[i])))>=0) fail();
+    origins(value.provenance);
+  }
+  if(value.schemaVersion!==1) fail();
+}
+function action(value) {
+  if(!obj(value)) fail();
+  if(value.kind==='command') {keys(value,['kind','capability','namespace','name'],['kind','name']);if(Object.hasOwn(value,'capability')===Object.hasOwn(value,'namespace')) fail();if(value.capability!==undefined) capability(value.capability);else text(value.namespace);text(value.name);}
+  else if(value.kind==='hook') {keys(value,['kind','capability','name']);capability(value.capability);text(value.name);}
+  else if(value.kind==='operation') {keys(value,['kind','slot','name']);if(!['knowledge','messaging','tasks'].includes(value.slot)) fail();text(value.name);}
+  else if(['inspect','compose'].includes(value.kind)) keys(value,['kind']);
+  else fail();
+}
+export function assertInvocationBounds(value,limits=INVOCATION_LIMITS) {
+  let entries=0;const active=new Set();
+  const visit=(v,depth)=>{
+    if(v===null || typeof v==='string' || typeof v==='boolean') return;
+    if(typeof v==='number') {if(!Number.isFinite(v)) fail();return;}
+    if(typeof v!=='object' || depth>limits.depth || active.has(v)) fail();
+    if(!Array.isArray(v) && Object.getPrototypeOf(v)!==Object.prototype && Object.getPrototypeOf(v)!==null) fail();
+    active.add(v);for(const child of Object.values(v)) {if(++entries>limits.entries) fail();visit(child,depth+1);}active.delete(v);
+  };
+  visit(value,1);if(Buffer.byteLength(JSON.stringify(value),'utf8')>limits.bytes) fail();
+}
+export function validateInvocationShape(value,expected={}) {
+  assertInvocationBounds(value);keys(value,['schemaVersion','executionBinding','subject','instance','intent','context','responsibleHuman','messagingChoice','capability','action','priorReceipt']);
+  if(value.schemaVersion!==1) fail();keys(value.executionBinding,['schemaVersion','deployment','resolution']);if(value.executionBinding.schemaVersion!==1) fail();absolute(value.executionBinding.deployment);resolution(value.executionBinding.resolution);
+  const alias=subject(value.subject);
+  if(value.instance!==null) {keys(value.instance,['home','work','name','agent','incarnationId']);incarnation(value.instance.incarnationId);absolute(value.instance.home);absolute(value.instance.work);text(value.instance.name);text(value.instance.agent);if(value.instance.agent!==alias || value.instance.work!==join(value.instance.home,'work')) fail();}
+  intent(value.intent,value.instance);
+  const selectedContext=context(value.context);human(value.responsibleHuman);messaging(value.messagingChoice,selectedContext,value.responsibleHuman);capability(value.capability);action(value.action);assertInvocationBounds(value.priorReceipt,PRIOR_RECEIPT_LIMITS);
+  if(value.action.capability!==undefined && value.action.capability!==value.capability) fail();
+  if(value.action.kind==='hook' && value.instance===null) fail();
+  for(const field of ['capability','context','action']) if(Object.hasOwn(expected,field) && !same(value[field],expected[field])) fail();
+  return value;
+}

package/capabilities/oats-aweb/lib/portable-binding.mjs

@@ -0,0 +1,146 @@
+import { validateInvocationShape, sameInvocationJson } from './invocation-shape.mjs';
+export const MESSAGING_CONTRACT='oats.aweb.messaging';
+export const MESSAGING_CONTRACT_VERSION=1;
+export const RESPONSIBLE_HUMAN_KEY='/bindings/messaging/responsibleHuman';
+export const PRIVATE_TEAM_KEY='/bindings/messaging/privateTeam';
+export const WIDER_KEY='/bindings/messaging/wider';
+const CAPABILITY='oats.aweb';
+const identifierPattern=/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,95}$/;
+const obj=value=>value!==null && typeof value==='object' && !Array.isArray(value);
+const clone=value=>JSON.parse(JSON.stringify(value));
+const canonical=value=>value===null || typeof value!=='object'?JSON.stringify(value):Array.isArray(value)?`[${value.map(canonical).join(',')}]`:`{${Object.keys(value).sort().map(key=>`${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+const same=(a,b)=>canonical(a)===canonical(b);
+const fail=(code,message)=>{throw Object.assign(new Error(message),{code});};
+function keys(value,allowed,required,label) {
+  if(!obj(value)) fail('invalid-binding',`${label} must be an object`);
+  for(const key of Object.keys(value)) if(!allowed.includes(key)) fail('invalid-binding',`unknown ${label} property: ${key}`);
+  for(const key of required) if(!Object.hasOwn(value,key)) fail('invalid-binding',`${label} requires ${key}`);
+  return value;
+}
+function identifier(value,label='identity') {if(typeof value!=='string' || !identifierPattern.test(value) || ['constructor','__proto__','prototype','toString','valueOf'].includes(value)) fail('invalid-binding',`invalid ${label}`);return value;}
+const pointerKey=value=>String(value).replace(/~/g,'~0').replace(/\//g,'~1');
+export const teamChoiceKey=alias=>`/bindings/messaging/teams/${pointerKey(identifier(alias,'team alias'))}`;
+function originAt(declaration,pointer,kind) {
+  const found=declaration.origins[pointer] ?? declaration.origin;
+  if(!obj(found)) fail('invalid-binding',`missing origin for ${pointer}`);
+  return clone({...found,kind});
+}
+function teamRef(value) {
+  keys(value,['provider','id'],['provider','id'],'aweb team reference');
+  if(value.provider!==CAPABILITY || typeof value.id!=='string' || !/^[^\s:]+:[^\s:]+$/.test(value.id)) fail('invalid-binding','aweb team reference requires provider oats.aweb and canonical team id');
+  return {provider:CAPABILITY,id:value.id};
+}
+function humanRef(value) {
+  keys(value,['provider','id'],['provider','id'],'responsible human');
+  if(value.provider!==CAPABILITY || typeof value.id!=='string' || !value.id.trim()) fail('invalid-binding','responsible human needs a provider-resolvable oats.aweb id');
+  return {provider:CAPABILITY,id:value.id.trim()};
+}
+function exactContext(value) {
+  if(value?.kind==='workspace') {keys(value,['kind','identity','observation'],['kind','identity','observation'],'workspace context');if(!obj(value.identity) || !obj(value.observation)) fail('invalid-binding','workspace context needs qualified identity and observation');return {kind:'workspace',identity:clone(value.identity)};}
+  if(value?.kind==='standalone') {keys(value,['kind','key'],['kind','key'],'standalone context');if(typeof value.key!=='string' || !value.key.trim()) fail('needs-configuration','messaging-enabled standalone preparation needs an explicit context key');return {kind:'standalone',key:value.key.trim()};}
+  fail('invalid-binding','unsupported messaging context');
+}
+function boundContext(value) {
+  if(value?.kind==='workspace') {keys(value,['kind','identity'],['kind','identity'],'bound workspace context');if(!obj(value.identity)) fail('invalid-binding','bound workspace context needs qualified identity');return clone(value);}
+  if(value?.kind==='standalone') {keys(value,['kind','key'],['kind','key'],'bound standalone context');if(typeof value.key!=='string' || !value.key.trim()) fail('invalid-binding','bound standalone context needs an explicit key');return {kind:'standalone',key:value.key.trim()};}
+  fail('invalid-binding','unsupported bound messaging context');
+}
+function declaration(value) {
+  keys(value,['kind','value','origin','origins'],['kind','value','origin','origins'],'messaging declaration');
+  if(!['soul','workspace','adoption','operator'].includes(value.kind) || !obj(value.value) || !obj(value.origin) || !obj(value.origins)) fail('invalid-binding','invalid messaging declaration');
+  return value;
+}
+
+/** Emit messaging provider fields for the kernel's single resolver. Team aliases
+ * are availability data; only the explicit operator wider list is consent. */
+export function normalizeMessagingDeclarations({declarations,context}={}) {
+  if(!Array.isArray(declarations)) fail('invalid-binding','messaging declarations must be an array');
+  const exact=exactContext(context),contextOrigin=context?.kind==='workspace'?clone(context.observation):null,requirements=[],candidates=[],teams={},requested=[],requestedOrigins={},aliases={},aliasOrigins={};let soul=null,privatePolicy=false,privatePolicyOrigin=null;
+  for(const raw of declarations) {
+    const item=declaration(raw);
+    // The kernel supplies complete validated source/workspace/operator
+    // declarations, including other providers' fields. Consume only messaging
+    // fields here; do not impose a second closed schema on the whole document.
+    if(item.kind==='soul') {
+      if(soul) fail('requirement-conflict','multiple soul messaging declarations');soul=item;
+      const list=item.value.teams ?? [];
+      if(!Array.isArray(list) || new Set(list).size!==list.length) fail('invalid-binding','soul teams must be a unique array');
+      for(let index=0;index<list.length;index++) {const alias=identifier(list[index],'soul team alias');requested.push(alias);requestedOrigins[alias]=originAt(item,`/teams/${index}`,'soul-requirement');}
+    } else if(item.kind==='workspace') {
+      const value=item.value.teams;if(value===undefined) continue;if(!obj(value)) fail('invalid-binding','workspace teams must be an object');
+      for(const [alias,ref] of Object.entries(value)) {
+        if(alias==='private') {if(ref!=='per-human') fail('invalid-binding','workspace private team policy must be per-human');privatePolicy=true;privatePolicyOrigin=originAt(item,'/teams/private','workspace-default');continue;}
+        const key=teamChoiceKey(alias),origin=originAt(item,`/teams/${pointerKey(alias)}`,'workspace-default');
+        teams[alias]=key;candidates.push({key,kind:'workspace-default',value:teamRef(ref),origin});
+      }
+    } else if(item.kind==='adoption') {
+      const value=item.value.teamAliases;if(value===undefined) continue;if(!obj(value)) fail('invalid-binding','adoption teamAliases must be an object');
+      for(const [source,target] of Object.entries(value)) {
+        identifier(source,'source team alias');identifier(target,'workspace team alias');
+        if(Object.hasOwn(aliases,source) && aliases[source]!==target) fail('requirement-conflict','adoption team aliases have conflicting mappings');
+        aliases[source]=target;aliasOrigins[source]=originAt(item,`/teamAliases/${pointerKey(source)}`,'import-adoption');
+      }
+    } else {
+      const bindings=item.value.bindings;if(bindings===undefined) continue;
+      if(!obj(bindings)) fail('invalid-binding','operator bindings must be an object');
+      if(Object.hasOwn(bindings,'responsibleHuman')) candidates.push({key:RESPONSIBLE_HUMAN_KEY,kind:'operator',value:humanRef(bindings.responsibleHuman),origin:originAt(item,'/bindings/responsibleHuman','operator')});
+      if(Object.hasOwn(bindings,'privateTeam')) candidates.push({key:PRIVATE_TEAM_KEY,kind:'operator',value:teamRef(bindings.privateTeam),origin:originAt(item,'/bindings/privateTeam','operator')});
+      if(Object.hasOwn(bindings,'wider')) {
+        if(!Array.isArray(bindings.wider) || new Set(bindings.wider).size!==bindings.wider.length) fail('invalid-binding','operator wider consent must be a unique array');
+        candidates.push({key:WIDER_KEY,kind:'operator',value:bindings.wider.map(alias=>identifier(alias,'wider team alias')),origin:originAt(item,'/bindings/wider','operator')});
+      }
+    }
+  }
+  if(!soul) fail('needs-configuration','messaging binding needs one soul declaration');
+  if(exact.kind==='workspace' && !privatePolicy) fail('needs-configuration','messaging workspace must declare private: per-human');
+  const rootOrigin=originAt(soul,'','soul-requirement');
+  requirements.push({key:RESPONSIBLE_HUMAN_KEY,kind:'required',origin:rootOrigin},{key:WIDER_KEY,kind:'required',origin:rootOrigin});
+  return {requirements,candidates,model:{contract:MESSAGING_CONTRACT,version:MESSAGING_CONTRACT_VERSION,context:exact,contextOrigin,requested,requestedOrigins,aliases,aliasOrigins,teams,privatePolicy,privatePolicyOrigin}};
+}
+function selected(choices,key,{optional=false}={}) {
+  const choice=choices?.[key];if(!obj(choice) || !Object.hasOwn(choice,'value') || choice.value===null) {if(optional)return null;fail('needs-configuration',key===RESPONSIBLE_HUMAN_KEY?'an explicit responsible-human binding is required':key===WIDER_KEY?'an explicit wider-membership consent list is required':'a selected wider-team binding is required');}return choice;
+}
+
+export function bindMessagingDomain({model,choices}={}) {
+  if(!obj(model) || model.contract!==MESSAGING_CONTRACT || model.version!==MESSAGING_CONTRACT_VERSION) fail('invalid-binding','invalid normalized messaging model');
+  const humanChoice=selected(choices,RESPONSIBLE_HUMAN_KEY),widerChoice=selected(choices,WIDER_KEY),human=humanRef(humanChoice.value);
+  if(!Array.isArray(widerChoice.value) || new Set(widerChoice.value).size!==widerChoice.value.length) fail('invalid-binding','resolved wider consent must be a unique array');
+  const wider=[],provenance=[humanChoice.selectedBy,widerChoice.selectedBy,model.contextOrigin,model.privatePolicyOrigin].filter(obj).map(clone);
+  for(const sourceAlias of widerChoice.value) {
+    identifier(sourceAlias,'wider team alias');if(!model.requested.includes(sourceAlias)) fail('invalid-binding',`wider consent names undeclared soul alias: ${sourceAlias}`);
+    const workspaceAlias=model.aliases[sourceAlias] ?? sourceAlias,key=model.teams[workspaceAlias];if(!key) fail('needs-configuration','a selected wider alias needs an explicit workspace team mapping');
+    const choice=selected(choices,key),ref=teamRef(choice.value);wider.push(ref);if(obj(choice.selectedBy)) provenance.push(clone(choice.selectedBy));
+    if(obj(model.requestedOrigins[sourceAlias])) provenance.push(clone(model.requestedOrigins[sourceAlias]));
+    if(obj(model.aliasOrigins[sourceAlias])) provenance.push(clone(model.aliasOrigins[sourceAlias]));
+  }
+  wider.sort((a,b)=>Buffer.compare(Buffer.from(canonical(a)),Buffer.from(canonical(b))));
+  for(let index=1;index<wider.length;index++) if(same(wider[index-1],wider[index])) fail('invalid-binding','duplicate resolved wider team');
+  const privateChoice=selected(choices,PRIVATE_TEAM_KEY,{optional:true}),privateTeam=privateChoice?teamRef(privateChoice.value):null;if(privateTeam && wider.some(item=>same(item,privateTeam))) fail('invalid-binding','private team cannot also be a wider team');if(obj(privateChoice?.selectedBy)) provenance.push(clone(privateChoice.selectedBy));
+  const unique=[];for(const item of provenance) if(!unique.some(prior=>same(prior,item))) unique.push(item);
+  const privateKey={provider:CAPABILITY,human,context:clone(model.context)};
+  return {payloadContract:MESSAGING_CONTRACT,payloadVersion:MESSAGING_CONTRACT_VERSION,payload:{responsibleHuman:human,context:clone(model.context),privateTeam,wider},credentialRefs:{},provenance:unique,
+    messagingChoice:{schemaVersion:1,enabled:true,privateKey,wider:clone(wider),provenance:clone(unique)}};
+}
+
+export function validateAwebBinding(binding) {
+  keys(binding,['schemaVersion','capability','payloadContract','payloadVersion','payload','credentialRefs','provenance'],['schemaVersion','capability','payloadContract','payloadVersion','payload','credentialRefs','provenance'],'aweb provider binding');
+  if(binding.schemaVersion!==1 || binding.capability!==CAPABILITY || binding.payloadContract!==MESSAGING_CONTRACT || binding.payloadVersion!==MESSAGING_CONTRACT_VERSION || !obj(binding.payload) || !obj(binding.credentialRefs) || !Array.isArray(binding.provenance)) fail('invalid-binding','invalid aweb provider binding');
+  keys(binding.payload,['responsibleHuman','context','privateTeam','wider'],['responsibleHuman','context','privateTeam','wider'],'aweb binding payload');
+  humanRef(binding.payload.responsibleHuman);boundContext(binding.payload.context);if(!Array.isArray(binding.payload.wider)) fail('invalid-binding','aweb wider teams must be an array');
+  const wider=binding.payload.wider.map(teamRef);for(let index=1;index<wider.length;index++) {if(same(wider[index-1],wider[index])) fail('invalid-binding','duplicate aweb wider team');if(Buffer.compare(Buffer.from(canonical(wider[index-1])),Buffer.from(canonical(wider[index])))>0) fail('invalid-binding','aweb wider teams are not canonical');}
+  if(binding.payload.privateTeam!==null) {
+    const privateTeam=teamRef(binding.payload.privateTeam);
+    if(wider.some(team=>same(team,privateTeam))) fail('invalid-binding','private team cannot also be a wider team');
+  }
+  if(Object.keys(binding.credentialRefs).length) fail('invalid-binding','no credential reference shape is supported by this binding version');
+  return binding;
+}
+
+export function validateAwebInvocationContext(value,binding,expected={}) {
+  validateAwebBinding(binding);
+  validateInvocationShape(value,{...expected,capability:CAPABILITY});
+  const selected=value.context.kind==='workspace'?{kind:'workspace',identity:value.context.identity}:value.context;
+  if(value.messagingChoice.enabled!==true || value.messagingChoice.privateKey.provider!==CAPABILITY || !sameInvocationJson(selected,binding.payload.context)
+    || !sameInvocationJson(value.responsibleHuman,binding.payload.responsibleHuman) || !sameInvocationJson(value.messagingChoice.wider,binding.payload.wider)) fail('invalid-binding','invocation contradicts messaging binding');
+  return value;
+}

package/capabilities/oats-aweb/lib/session-readiness.mjs

@@ -0,0 +1,56 @@
+// Capability-owned operational readiness for the existing HOME delivery route.
+// This is not human-account delegation, private-grant proof or model completion.
+import {execFileSync} from 'node:child_process';
+import {isAbsolute,resolve} from 'node:path';
+import {BINDING_WIRE_LIMITS,parseBindingJson} from './binding-wire.mjs';
+import {sameInvocationJson as same} from './invocation-shape.mjs';
+import {validateAwebBinding,validateAwebInvocationContext} from './portable-binding.mjs';
+// 0.24.1 supplies HOME custody; 0.24.2 also ships the required public projection
+// and same-kernel codec CLI locator. Source presence is not a released version.
+export const HOME_ROUTE_KERNEL_FLOOR='0.24.2';
+const obj=v=>v!==null&&typeof v==='object'&&!Array.isArray(v);
+const missing=message=>({status:'needs-configuration',problems:[{code:'needs-configuration',message}]});
+const error=()=>{throw Object.assign(new Error('selected kernel observation unavailable'),{code:'provider-unavailable'});};
+/** Preserve native HOME/profile/auth/Git; remove only the invoking instance's
+ * OATS selectors so a read-only query cannot accidentally target its parent. */
+export function kernelQueryEnvironment(inherited){
+  const env={...inherited};
+  for(const key of Object.keys(env))if(/^(OATS_(?!HOME_DIR$)|OAS_|PI_AGENT_)/.test(key)||key==='PI_AGENTS_ROOT')delete env[key];
+  return env;
+}
+export function kernelMeetsHomeRouteFloor(version){
+  if(typeof version!=='string'||!/^\d+\.\d+\.\d+$/.test(version))return false;
+  const parts=version.split('.').map(Number),floor=HOME_ROUTE_KERNEL_FLOOR.split('.').map(Number);if(!parts.every(Number.isSafeInteger))return false;
+  for(let i=0;i<3;i++)if(parts[i]!==floor[i])return parts[i]>floor[i];
+  return true;
+}
+/** Use the caller-owned CLI location, never search PATH or import private kernel
+ * indexes. Binding execution must receive the same OATS_CLI_BIN as hooks. */
+export function querySelectedKernel(args,{env=process.env}={}){
+  const cli=env.OATS_CLI_BIN;
+  if(typeof cli!=='string'||!isAbsolute(cli)||resolve(cli)!==cli||cli.includes('\0'))error();
+  let bytes;
+  try{bytes=execFileSync(process.execPath,[cli,...args],{env:kernelQueryEnvironment(env),timeout:10000,maxBuffer:BINDING_WIRE_LIMITS.bytes,stdio:['ignore','pipe','pipe']});}catch{error();}
+  try{return parseBindingJson(bytes,BINDING_WIRE_LIMITS);}catch{error();}
+}
+/** Reads only public version/retained selection. A missing profile projection
+ * stays explicit; no source default, mutable home label or runtime guess. */
+export function assessCapturedSessionReadiness({binding,invocation,settings},{query=querySelectedKernel,env=process.env}={}){
+  if(!binding||!invocation)return missing('selected binding and inline captured invocation are required');
+  validateAwebBinding(binding);validateAwebInvocationContext(invocation,binding);
+  if(!invocation.instance)return missing('an explicit captured instance home is required');
+  if(binding.payload.privateTeam===null)return missing('an explicit private-team binding is required');
+  if(settings.delivery!=='session')return missing('captured messaging requires explicit delivery: session');
+  if(binding.payload.wider.length)return missing('selected wider memberships need their explicitly qualified native setup; they were not omitted');
+  let version,observed;
+  try{version=query(['--version','--json'],{env});}catch{return missing('caller-owned OATS_CLI_BIN and readable kernel version are required');}
+  if(version?.schemaVersion!==1||version?.name!=='@awebai/oats'||!kernelMeetsHomeRouteFloor(version.version))return missing('oats >=0.24.2 is required for captured HOME custody and retained runtime inspection');
+  const b=invocation.executionBinding;
+  try{observed=query(['inspect','--deployment',b.deployment,'--resolution',b.resolution.id,'--json'],{env});}catch{return missing('the exact retained runtime profile must be readable');}
+  if(observed?.schemaVersion!==1||observed?.ok!==true||!same(observed.result?.resolution,b.resolution))return missing('the kernel must report the exact retained resolution');
+  const launch=observed.result.launchSelection;
+  if(!obj(launch)||Object.keys(launch).some(k=>!['runtime','model'].includes(k))||!Object.hasOwn(launch,'model')||(launch.model!==null&&(typeof launch.model!=='string'||!launch.model.trim())))return missing('a retained launchSelection runtime/model observation is required');
+  if(launch.runtime==='pi')return missing('Pi strict print does not support session input; retain messaging and configure an input-capable profile');
+  if(!['claude','codex'].includes(launch.runtime))return missing('a supported input-capable ordinary Claude/Codex profile is required');
+  return {status:'ready',problems:[]};
+}

package/capabilities/oats-aweb/oats.json

@@ -1,9 +1,9 @@
 {
   "capability": "oats.aweb",
   "command": "aweb",
-  "version": "1.10.3",
+  "version": "1.11.0",
   "compatibility": {
-    "oats": ">=0.22.3"
+    "oats": ">=0.24.2"
   },
   "layer": "messaging",
   "description": "Messaging layer via aweb: per-instance team identities + native aw mail/chat skills + cross-machine team roster.",
@@ -64,7 +64,16 @@
   "inject": "injects/aweb.md",
   "commands": {
     "roster": "bin/oats-aweb.mjs roster",
-    "setup": "bin/oats-aweb.mjs setup"
+    "setup": "bin/oats-aweb.mjs setup",
+    "binding-normalize": "bin/oats-aweb-binding.mjs normalize",
+    "binding-bind": "bin/oats-aweb-binding.mjs bind",
+    "binding-check": "bin/oats-aweb-binding.mjs check"
+  },
+  "binding": {
+    "version": 1,
+    "normalize": "binding-normalize",
+    "bind": "binding-bind",
+    "check": "binding-check"
   },
   "hooks": {
     "spawn": {