@awebai/oats 0.24.1 → 0.24.3

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": {

package/docs/design/2026-09-20-redesign-program-board.md

@@ -2,7 +2,7 @@
 
 **Purpose:** the one accurate view of every work stream in the redesign, what is on main, what is in flight, who owns it, and what blocks it. Lead: `oats-expert` (redesign lead). Updated whenever anything merges, is returned, or reality changes. Older per-lane boards are superseded by this file.
 
-**Last update:** 2026-09-20 17:40Z · main `87292f40` · OKF `v2.1.1`
+**Last update:** 2026-09-21 05:00Z · main `04e930e7` · **OATS v0.24.2 published** · OKF v2.1.1 · oats-framework/v1.1.1 · aweb v1.11.0 · oats-knowledge 8d67eab4
 
 Legend: ✅ on main/published · 🔄 in flight (PR/branch) · 🟡 preserved, not adopted · ⬜ not started · ⛔ blocked
 
@@ -10,14 +10,14 @@ Legend: ✅ on main/published · 🔄 in flight (PR/branch) · 🟡 preserved, n
 
 | # | Stream | State | Owner | Next action |
 |---|---|---|---|---|
-| S1 | Knowledge capability contract rework (kernel↔provider boundary, OKF 2.x) | ✅ shipped 0.24 / **OKF 2.1.1 released** (PR4 merged; mirror, catalog ref, soul source bumped) | P | done for this phase; OATS 0.24.1 cut after L's custody fix |
-| S2 | Workspace/Portable Souls adoption of the OATS repos | ✅ PR23 + PR24 merged · ✅ member `oats.yaml` on main in oats-okf/aweb/authoring/jira · ⛔ oats-dev, oats-linear (no push access, human) | M, L, lead | human grants access → push 0434f4ef/8c183c37; then pin imports; then fresh deployment gate |
-| S3 | Messaging capability readiness on the new infrastructure (aweb) | 🔄 codec PR2 + custody WIP · needs profile pin | P | lead pins pilot profile + answers authority question |
-| S4 | Official capabilities `oats.core` / `oats.setup` + explicit default + onboarding `oats-setup-expert` | 🔄 D1 in progress (P, `feat/d1-oats-core-setup`, package → `oats.framework` 1.1.0) · 🔄 D2 in progress (L) · ⬜ D3 | P (D1), L (D2, D3) | review D1/D2 PRs; assign D3 after D2 |
-| S5 | Official marketplace = reviewed list in oats repo | ✅ D4 merged PR26 (`docs/official-marketplace.md`, policy pointer) · ⬜ `oats.core`/`oats.setup` entries after D1 release | M | add entries at D1 release |
-| S6 | Five expert souls created in the oats repo (`souls/<name>/`) | 🔄 assigned to M (`feat/s6-expert-soul-editions`) from the reviewed candidate; `souls/oats-expert` on main | M | review PR; `oats.core` follow-up after D1 |
-| S7 | Centralised per-soul knowledge in `oats-knowledge` (migration + PR-only learning) | 🟡 35 curated concepts uncommitted on local `curation/expert-knowledge`; bootstrap proven on personal repo; `awebai/oats-knowledge` EMPTY, private | lead + human (visibility) | decide visibility; publish curation as PR; point souls' `stores.oats` at it |
-| S8 | Desktop parity (marketplace view, soul creation with `oats.core`, onboarding flow) | ⬜ after S4/S5 | fresh Desktop engineer (blocked: `claude` absent) | pick runtime; spawn |
+| S1 | Knowledge capability contract rework (kernel↔provider boundary, OKF 2.x) | ✅ OATS 0.24.1 / OKF 2.1.1 published | P | done for this phase |
+| S2 | Workspace/Portable Souls adoption of the OATS repos | ✅ workspace + seven indexes + six imports · ✅ **0.24.2 published** (onboard verified from the npm tarball) · 🔄 Antares re-run requested · 🔄 five seams → L, 0.24.3 | lead, L, Antares | re-run report; seams PR |
+| S3 | Messaging capability readiness on the new infrastructure (aweb) | ✅ aweb 1.11.0 released · ✅ **catalog + six editions pin v1.11.0 (0.24.2)** · ⬜ second-operator re-run | P, lead | Antares re-run |
+| S4 | Official capabilities `oats.core` / `oats.setup` + explicit default + onboarding `oats-setup-expert` | ✅ D1, D2, **D3 merged (PR35)**: `oats onboard` verified live (acquire 1.1.1 → setup expert with both caps → scaffold composes the five capability skills, no legacy) · `oats.framework` 1.1.1 tagged | P, L | done; Desktop surfaces → S8 |
+| S5 | Official marketplace = reviewed list in oats repo | ✅ D4 merged · ✅ `oats.framework` 1.1.1 listed (`oats.core`, `oats.setup`, `oats.knowledge-theory` aliases) | M | Desktop view → S8 |
+| S6 | Five expert souls created in the oats repo (`souls/<name>/`) | ✅ five + `oats-setup-expert` on main, all declaring `oats.core`, exported + imported | M, L, lead | legacy `agents/` cutover after S7 proof |
+| S7 | Centralised per-soul knowledge in `oats-knowledge` (migration + PR-only learning) | ✅ **repo PUBLIC; PR #1 merged → main 8d67eab4, 25 accepted concepts**, owners = published souls, validator pinned OKF 2.1.1 · 🔄 fresh-reader proof assigned to Juan's side · ⬜ legacy in-soul knowledge decommission | lead, Antares/Juan | fresh-reader + PR-learning proof; then retire `agents/*/soul/knowledge` |
+| S8 | Desktop parity (marketplace view, soul creation with `oats.core`, onboarding flow) | ⬜ after D3 · **host offered: Juan's machine (has `claude`)** — accepted | fresh Desktop engineer on Juan's host | brief + spawn params after D3 |
 
 ## S1 — Knowledge capability contract rework
 - ✅ Provider-neutral contract, binding wire v1, helper/input contract, retained execution: OATS 0.24.0 + OKF 2.1.0 (f20f8e57) published.
@@ -28,21 +28,32 @@ Legend: ✅ on main/published · 🔄 in flight (PR/branch) · 🟡 preserved, n
 - ✅ **PR23 merged f6d5a89b**: `oats-workspace.yaml` (7 members, `imports: []`), `oats.yaml` (exports souls/oats-expert, oats-package, capabilities/oats-authoring), transitional `souls/oats-expert/` edition, `docs/workspace-adoption.md`, layout tests.
 - ✅ **PR24 merged da38e5a9**: deletion of `skills/oats-portable-setup` + `oats inspect --request` read-only seam (ACCEPTED as the public inspection route); full gate 1621/0.
 - ✅ Member `oats.yaml` merged to main: oats-okf #3 (fec78a20), oats-aweb #1 (069ea2f6), oats-authoring #1 (54183a6a), oats-jira #1 (2f855daf).
-- ⛔ oats-dev (0434f4ef) and oats-linear (8c183c37): neither M nor the lead's GitHub account has push — **human must grant access or push**.
+- ✅ oats-dev#1 (main 6e164ee3) and oats-linear#1 (main a2121e48) merged after Juan granted write access — M's exact commits 0434f4ef / 8c183c37.
 - ⬜ `imports:` pin of `souls/oats-expert` at its published revision (after member indexes).
 - ⬜ Fresh local deployment from the shared definition (P1.5) — the real acceptance gate.
 
+## S2 — second-operator gate report (Antares, Juan's machine, 2026-09-20)
+Fresh dir, local `@awebai/oats@0.24.1`, no prior state. `inspect --request` → ready-for-preparation, membership eligible, source `souls/oats-kernel-expert@caa341f3`. `prepare` resolved and materialized `oats-package@caa341f3`, `oats.okf@v2.1.1`, `oats.aweb@v1.10.3`, `oats.core`, `oats.setup`, `oats.knowledge-theory` + soul; artifact-set approvals worked. Terminal: `needs-configuration` + `provider-not-qualified` (aweb 1.10.3 has no binding interface) — expected. Seams (assigned to L, one PR, priority):
+1. `inspect --request` requires `workTarget`; `prepare --request` refuses it (`buildFreshPreparationRequest` exists but the CLI never uses it).
+2. `prepare` on the absent deployment inspect blessed → raw `ENOENT` + host path through the JSON envelope.
+3. `prepare` writes lock v3; `oats trust <cap> --dir` rejects it (`unsupported lockfileVersion 3`) → dead end from `--help`.
+4. The working `trust --deployment --artifact-set <sha256>` route is absent from `--help`.
+5. Problems carry `origins: []` and no slot/capability, so a valid and a bogus `stores.oats` binding produce byte-identical output. **Root cause (L's trace):** both OKF `normalize` calls refused because the operator request had no OKF runtime settings (`bindings-file`, `state-dir` — absolute host paths, no defaults); the message never said so. Fix = attribute problems by slot/capability and name the missing item; the identical pair is correct output for that input and stays identical. Guidance for the required settings → P (oats-workspace-setup).
+
 ## S3 — Messaging (aweb) on the new infrastructure
+- ✅ **aweb PR3 merged → v1.11.0 (93f8ab96)**: `binding {normalize,bind,check}` on the existing wire; `check` = HOME-route operational custody only (explicit private team, `delivery: session`, kernel ≥0.24.2 via caller-owned `OATS_CLI_BIN`, retained `launchSelection` must be input-capable Claude/Codex; strict-Pi print → `needs-configuration`, never downgraded). Native adapter over existing `aw` commands with physical identity-dir custody and redacted tokens. Standalone 30/0; coupling 14/0 vs kernel b92f0d07. PR33 (launchSelection projection, OATS_CLI_BIN in codec env) merged b92f0d07.
 - Facts: released aweb 1.10.3 has no binding interface; broker refuses. aw 1.36.1 broker calls `oats session inspect/input --home H`; never restarts stopped runtime; strict-Pi print mode can't take session input.
 - 🔄 oats-aweb **PR2** codec (165b20e) + uncommitted `lib/captured-execution.mjs` (6/6).
 - ✅ Lead answered (d9d912a4): pilot primary = Pi strict print host explicit model; helper = Pi sole-OKF (Claude/Codex allowed by 2.1.1); authority = existing HOME route + L's custody fix, gated on `oats >=0.24.1`; no new grant mechanism. P delivers aweb 1.11.0 PR. 
-- 🔄 L finding c21e36ff accepted; fix assigned (L, `fix/home-route-captured-custody`): reuse `readCapturedInstanceAuthority` on the HOME-only route, refuse before transport.
+- ✅ **PR27 merged (5af848fc)**: HOME-only session route applies existing captured custody; refuses before transport on drift. Full gate 1626/1632 (2 pre-existing env failures reproduced on main). Ships in **v0.24.1** — the kernel floor the aweb adapter gates on.
 
 ## S4 — `oats.core` / `oats.setup` / onboarding
+- ✅ **D3 merged PR35 (37c5c012)**: `oats onboard` classic local bootstrap; edition `souls/oats-setup-expert` (core+setup, provider defaults `none`, no knowledge owner). Full gate 1639/0. Live: onboard → acquire `oats.framework` 1.1.1 @0aad753c → soul declares both caps at that commit → scaffold-only spawn composes exactly `oats-operate, oats-souls, oats-config, oats-packages, oats-workspace-setup` + the `oats.core` injection, no legacy kernel skills. Baseline hygiene fixed on main (a96f24df).
+- ✅ **D1 merged PR28 (70b10822)**, distribution tag `oats-framework/v1.1.0` on 9930dcfb; **D2 merged PR29 (9930dcfb)** full gate 1634/0. Verified live: `oats create` writes `requires.capabilities.oats.core` with the catalog source; `oats install oats.framework` acquires all three capabilities from the tag.
 - ✅ Decision + plan D1–D4 on main 18af53be; docs reference as accepted-not-shipped.
 - 🔄 **D1** (P, started 16:29Z; package identity confirmed: rename distribution package to `oats.framework` 1.1.0, capabilities 1.0.0, `oats.knowledge-theory` unchanged) package `oats.core` (`oats-operate`, `oats-souls`, oats.md injection) and `oats.setup` (oats-config, oats-packages, adoption guidance) under `oats-package/capabilities/`. Owner P.
 - 🔄 **D2** (L, after custody fix) soul creation writes explicit `requires.capabilities.oats.core`; kernel skill list de-ambiented (one-release coexistence); checked-in souls updated. Owner L.
-- ⬜ **D3** onboarding creates + instantiates `oats-setup-expert` (edition in `souls/`). Owner L (+M edition).
+- 🔄 **D3** (L, in progress) onboarding creates `oats-setup-expert` (edition in `souls/`); CLI verb **`oats onboard`** — `oats setup` is already the record capture-setup command and stays untouched.
 - Exit: fresh onboarding → running setup expert; created soul shows `oats.core`; kernel ships no ambient operational skill.
 
 ## S5 — Official marketplace
@@ -50,21 +61,23 @@ Legend: ✅ on main/published · 🔄 in flight (PR/branch) · 🟡 preserved, n
 - ✅ **D4 merged PR26 (786490ae)**: `docs/official-marketplace.md`, `package-catalog.json` policy pointer (inert to the reader), README/packages/capabilities links, D3 sketch in adoption guide. ⬜ entries for `oats.core`/`oats.setup` at D1 release. Desktop view → S8.
 
 ## S6 — Five expert souls in the oats repo
+- ✅ **PR30 merged (40a579dc)** + maintainer follow-up **caa341f3**: all five declare `oats.core: {source: repo:oats-package}`, oats.okf@v2.1.1; `oats.yaml` exports all five; `oats-workspace.yaml` imports all five at caa341f3 (375b9f42). Live inspection against published main resolves them.
 - Roster (decided): `oats-expert`, `oats-kernel-expert`, `oats-desktop-expert`, `market-research-expert`, `oats-assistant`.
 - 🟡 Candidate: `expert-roster` worktree (b5e233b9 + 519 uncommitted changes: five `agents/<name>/soul/` + legacy roster deletions). Reviewed earlier; NOT committed.
 - ✅ `souls/oats-expert` transitional edition on main already declares owns/reads for the five nodes.
 - 🔄 Assigned to M (17:05Z): create `souls/<name>/` editions for the other four from the candidate; each declares `oats.core` explicitly (S4 rule) + `oats.okf`/`oats.aweb` sources; export in `oats.yaml`. Legacy `agents/` roster retirement is a separate, later cutover.
 
 ## S7 — Centralised knowledge in `oats-knowledge`
+- ✅ Juan made the repo PUBLIC (2026-09-20). Bootstrap history pushed to main; **PR #1 merged (8d67eab4)**: 25 curated concepts, roadmap re-verified to the 0.24.1 baseline and 2026-09-20 decisions, validator pinned to OKF v2.1.1, strict OKF 25/0/0, ownership tests 24/24.
 - 🟡 Curated corpus: 35 concepts (five nodes) on local `curation/expert-knowledge` in `/Users/pepe-reyero/OATS-workspace/oats-knowledge`, **uncommitted**. Bootstrap + one PR-only harvest already proven on `josep-reyero/oats-knowledge` (3 commits).
 - ⛔ Target `awebai/oats-knowledge` is EMPTY and PRIVATE; **visibility undecided** (stated requirement: public). Human decision needed before publishing.
 - ⬜ Then: push bootstrap + curation as PR to awebai; bind `stores.oats` in the pilot deployment; prove fresh-reader + Git-PR learning with the new souls; retire old in-soul knowledge (`agents/*/soul/knowledge`) as a final cutover.
 
 ## S8 — Desktop parity
+- Finding (L, D2 audit): the Desktop server has **no soul-creation endpoint** today (roster reads, existing-soul edits/capability operations, instance spawn only). Soul creation with explicit `oats.core`, the marketplace view and the onboarding flow are new Desktop features, not wiring.
 - ⬜ After S4/S5: official marketplace view/search; soul creation showing `oats.core`; onboarding flow; redesign parity vs `Oats UX Redesign and Desktop Discovery (1)`.
 - ⛔ Fresh `oats-desktop-engineer` not spawned: `claude` not on PATH → choose Pi/Codex or install (human).
 
 ## Blockers needing the human
-1. `awebai/oats-knowledge` visibility (public vs private) — gates S7 publication.
-2. Push access to `awebai/oats-dev` and `awebai/oats-linear` for `josep-reyero` (or human pushes M's exact commits 0434f4ef / 8c183c37 as `oats.yaml`) — gates S2 completion.
-3. Desktop engineer runtime (Claude absent) — gates S8.
+- ~~oats-knowledge visibility~~ → PUBLIC (Juan). ~~oats-dev/oats-linear access~~ → granted, indexes merged. ~~Desktop runtime~~ → Juan's machine hosts the Desktop lane (has `claude`).
+- None open at 23:10Z. Juan's side (Antares) takes: (a) fresh-deployment gate P1.5, (c) fresh-reader proof, (b) Desktop host after D3.

package/docs/design/2026-09-20-workspace-onboarding-public.md

@@ -9,9 +9,11 @@ owned; production capability/profile readiness is not established by the fixture
 
 ```sh
 oats inspect --request /absolute/inspection.json --json
+# Optional explicit request export (new private file; never overwrite):
+oats inspect --request /absolute/inspection.json --emit-prepare-request /absolute/preparation.json --json
 ```
 
-This mode accepts only one request file and `--json`. Explicit captured selectors
+This mode accepts one request file, optional `--emit-prepare-request`, and `--json`. Explicit captured selectors
 or current-context flags conflict before file reads; inherited captured environment
 is not new-work input. Other existing inspect modes are unchanged. The shared
 bounded strict JSON request reader feeds the existing inspection validator intact:
@@ -66,21 +68,47 @@ have not been classified by their owner and are omitted. Import summaries expose
 `payloadOmitted`. Top-level `omitted:{providerPayloads:true,adoptionValues:true}`
 states that this is a metadata view, not a lossless request or a safe-payload claim.
 It is not an issued `buildFreshPreparationRequest` witness, even in the same
-process. Keep the original authored input for an explicit preparation request.
+process. The opt-in `--emit-prepare-request` route calls that existing builder
+on the real in-process inspection before dropping the private witness. It writes
+only `.preparation` to a new mode-0600 file at an explicit normalized absolute
+path with an existing real parent; existing files/symlinks are refused, never
+overwritten. JSON output names `prepareRequestFile` and records the explicit
+request-file write in `effects`; it does not echo the request contents. The
+export can carry unclassified adoption declarations and must remain private;
+requests must contain nonsecret values or credential references, never secrets.
+A held inspection cannot emit a fresh preparation request. Core callers can
+explicitly request this data via `{includePrepareRequest:true}`; the default
+metadata projection and its omissions are unchanged.
+
+The file is reusable new-work input, NOT a stored resolution, approval, admission,
+or serialized ready-inspection permission. Preparation performs fresh validation
+and observations, including re-resolving any mutable source selectors. Provider
+configuration still requires explicit operator choices; conversion invents none.
 
 Existing managed deployment state is preserved and reported, not repaired or
 migrated. An absent selected path requires explicit operator provisioning and
-reinspection. The serialized inspection does not lock the filesystem or authorize
+reinspection. Prepare refuses it with typed `needs-configuration` and provisioning
+guidance before fetching or writing managed state, not a raw ENOENT. Inspection's
+`ready` means the path is eligible for fresh setup, not already provisioned.
+The serialized inspection does not lock the filesystem or authorize
 later mutation; preparation retains its own existing validation/custody rules.
 The inspected work target does not become source identity or an implied placement
 choice. Supported captured directory scaffolds own their separate H/work.
 
 ## Existing preparation and retained execution
 
-`oats prepare --request` already accepts deployment/source/origin, workspace/member
-OR standalone context, operator policy/bindings, mode/local-input authorization,
-launch and helperLaunches. Do not pass the inspection result or workTarget/catalog
-wrapper. Exact executable approval is separate. A required provider whose binding
+`oats prepare --request` accepts deployment/source/origin, optional `workTarget`,
+workspace/member OR standalone context, operator policy/bindings,
+mode/local-input authorization, launch and helperLaunches. The original minimal
+inspection request (without inspection-only `catalogIndexes`) is also accepted;
+use the converter rather than stripping fields from a metadata/result wrapper.
+Explicit `workTarget` is validated with the same physical existing-directory
+validator as inspection and returned as work-context metadata. It takes precedence
+over any caller assumption about cwd: no cwd/config fallback selects its value.
+Omitting it preserves prior preparation behavior without inventing a placement.
+It does not change source identity, `operator.localBase`, work mode, or captured
+H/work placement. Do not pass an inspection result/catalog wrapper or private
+scratch `directory` to preparation. Exact executable approval is separate. A required provider whose binding
 code is unapproved may return `needs-configuration` with an `approval-required`
 problem and exact artifact-set/capability requests, before any record exists:
 
@@ -92,6 +120,44 @@ oats spawn <subject> --deployment <D> --resolution <R> --home <new-H> --no-launc
 oats session start --deployment <D> --resolution <R> --home <H> --request /absolute/native.json --json
 ```
 
+Each `selections[]` row carries an `artifactSet` id and an `approvalRequired[]`
+array of **capability ids**. Pair them: pass the capability to `trust` and that
+row's artifact-set id to `--artifact-set`. These are not interchangeable ids.
+`trust <capability> --dir <D>` against a v3 deployment now refuses with typed
+`needs-configuration` and exact available-set commands; it never picks or approves
+a set automatically. Classic v1/v2 trust remains the classic route.
+
+Provider preparation problems carry `slot` and `capability`, plus original
+provenance where available. A no-interface provider is identified with kernel-known
+manifest/version facts. Other supported slots still normalize, resolve through
+the same choice engine, and bind if their own choices are resolved; any required
+slot problem still prevents publication. Provider free text is not passed through.
+Different opaque inputs need not produce different public errors if both fail the
+same provider prerequisite. In particular, missing OKF host runtime settings can
+hold both syntactically valid Git locators; preparation does not test whether a
+remote repository exists. Required readiness checks remain later, with the provider.
+
+### Operator input
+
+When present, `operator` requires both `policy` (object; `{}` is valid) and
+`document` (`{ "kind": "operator", "id": "setup-attempt" }`). Its ONLY optional
+fields are `localBase`, `allowLocalPaths`, `sourceContext`, and `bindings`:
+
+- `policy`: explicit provider/additive selections with their selected sources and
+  settings, using the existing policy grammar. It cannot erase soul requirements.
+- `localBase`: explicit absolute base for relative local policy sources. Work
+  context/cwd is not a substitute.
+- `allowLocalPaths`: explicit boolean authorization for those local policy sources.
+  Top-level local acquisition authorization remains a separate input.
+- `sourceContext`: existing qualified repository anchor for `repo:` policy sources;
+  not a new repository inferred from workTarget.
+- `bindings`: provider-owned map. Kernel preserves it and its document pointers;
+  it does not interpret store names, Git destinations, credentials or private teams.
+
+Selecting an inherited store does not replace required provider runtime settings.
+Use the selected provider's instructions for those settings; kernel must not guess
+host-owned durable paths or copy native authentication.
+
 Repreparation after explicit approval is ordinary continuation in the selected,
 now-managed deployment; do not delete its state to make fresh preflight pass.
 Required hooks still run under their admitted custody with `--no-launch`; a parsed

package/docs/first-team.md

@@ -42,6 +42,48 @@ For several repositories initialize their common workspace, then select the
 repository owning the soul with `--dir /path/to/workspace/project` for
 create/spawn/retire. A team roster does not select a work repository for spawn.
 
+## Onboarding with the setup expert
+
+For a kernel build that includes `oats onboard` (check `oats onboard --help`),
+start in an explicit empty deployment:
+
+```bash
+oats onboard --dir /absolute/new-deployment --json
+```
+
+This command is **not present in the published 0.24.0/0.24.1 kernels**. It is a
+classic local bootstrap, not captured preparation or workspace enrollment. It
+acquires `oats.framework` from the official catalog, exact-locks its artifacts,
+selects only `oats.core` and `oats.setup` for the new local `oats-setup-expert`,
+and prints the exact next spawn command. Review and run the returned
+`result.next.command` when ready; it addresses this same kernel and deployment.
+Onboarding itself never launches a model, changes native authentication or
+installs capture hooks/services. **`oats setup` remains the separate record
+capture-setup command**, not an alias for onboarding.
+
+The expert receives `oats-operate`, `oats-souls`, `oats-config`, `oats-packages`
+and `oats-workspace-setup`, without duplicate legacy kernel skill copies. It has
+no hard knowledge/messaging dependency, so it can help select and configure those
+providers afterward. Catalog identity grants no executable trust: the bootstrap
+uses resource-only core/setup capabilities and refuses unexpected executable
+surfaces instead of auto-approving them.
+
+An existing roster is refused unless `--force-existing` is explicit. That flag
+permits adding the new soul, not overwriting an existing setup expert or disabling
+providers for other souls. Failures report partial acquisition/creation rather
+than claiming atomic captured preparation. Preserve that evidence before retrying.
+
+Optional `--workspace git:host/org/repository[@revision]` reads the selected
+repository through ordinary discovery: use its pinned `oats-setup-expert` import
+when present, otherwise its own advertised `souls/oats-setup-expert` edition at
+the observed revision. Missing or incompatible explicit sources refuse; they do
+not fall back to the packaged default. The copied edition's package must match
+the official acquisition; workspace policy, teams and provider adoption values
+are not silently adopted. Without this option, only the packaged definition and
+instruction text are used—no knowledge corpus is bundled.
+
+The manual path below retains its stated older integration/version scope.
+
 ## Configure explicit knowledge and optional messaging
 
 Edit the existing entries in `oats-config.yaml`; do not append a second

package/docs/layers.md

@@ -80,7 +80,7 @@ Messaging is conversation, not automatically task state. Accepted knowledge may
 
 The current slot name is **`messaging`**. The capability owns native identity, addressing, team membership, transport, wake delivery and qualification. A team alias in a workspace is a declaration, not proof that an actor is enrolled or a privacy property is enforced.
 
-The released aweb1.10.3 integration supports its legacy setup/lifecycle path but lacks the captured provider-binding interface required for a new portable profile. That capability needs adaptation and real qualification; a codec that always refuses readiness is not completed messaging support.
+aweb 1.10.3 supports its legacy setup/lifecycle path but lacks the captured provider-binding interface. **aweb 1.11.0** (OATS >=0.24.2) adds it: `check` qualifies HOME-route operational custody for an input-capable Claude/Codex primary with an explicit private team and `delivery: session`; a strict-Pi print primary reports `needs-configuration` rather than dropping the requirement. Qualification is not account delegation, broker delivery or model consumption.
 
 The earlier proposed `reach` ladder is **not an enforced universal field**. In particular, aweb's `team_and_contacts` includes verified same-team senders; the compatibility spellings `contacts-only` and `contacts_only` do not establish owner-only admission. A config command succeeding proves neither inbound/outbound restrictions nor knowledge visibility. See the [identity/membership amendment](design/2026-09-08-expert-assisted-deployment-proposal.md#membership-reach-and-visibility-are-separate) and [messaging boundary](design/2026-09-16-messaging-capability-contract.md).
 

package/docs/official-marketplace.md

@@ -58,17 +58,22 @@ or workspace membership alone does not make a package official.
 Contact and license evidence may live in the package/repository documentation;
 this policy does not invent new catalog or manifest fields.
 
-## Planned first set
+## Listed first set
 
-- Already listed: `oats.okf`, `oats.aweb`, `oats.authoring`, `oats.jira`,
-  `oats.linear`, `oats.dev` and `oats.knowledge-theory`.
-- **Planned, not yet listed:** `oats.core` for OATS operation/soul guidance, and
-  `oats.setup` for OATS Soul Setup, configuration and package guidance. Add their
-  catalog entries only after their actual D1 package releases exist and pass
-  review. They are not available merely because this document names them.
+- Listed capabilities: `oats.okf`, `oats.aweb`, `oats.authoring`, `oats.jira`,
+  `oats.linear`, `oats.dev`, `oats.knowledge-theory`, `oats.core` and `oats.setup`.
+- **`oats.framework` 1.1.1** is listed at tag `oats-framework/v1.1.1` in
+  `awebai/oats`, payload root `oats-package`. The `oats.core`, `oats.setup` and
+  `oats.knowledge-theory` aliases select that distribution; package identity is
+  distinct from capability identity. Core supplies operation/soul guidance;
+  setup supplies OATS Soul Setup, configuration and package guidance.
 
-The [workspace adoption guide](workspace-adoption.md) describes the separate
-planned setup-expert flow. No package is silently added to an existing soul.
+These entries are in the current repository catalog. An older installed CLI keeps
+its bundled catalog; publication here does not update that installation or rewrite
+old source references, locks or tags. Follow that CLI's supported acquisition path.
+The [workspace adoption guide](workspace-adoption.md) distinguishes the published
+capabilities and five expert imports from the still-pending D3 setup-expert flow.
+No package is silently added to an existing soul.
 
 ## Updates, deprecation and removal
 

package/docs/packages.md

@@ -402,7 +402,7 @@ sources; installing a kernel does not advance existing package locks:
 {
   "packages": {
     "oats.okf": { "url": "https://github.com/awebai/oats-okf.git", "ref": "v2.0.0", "path": "oats-package" },
-    "oats.knowledge-theory": { "url": "https://github.com/awebai/oats.git", "ref": "v0.23.0", "path": "oats-package" },
+    "oats.framework": { "url": "https://github.com/awebai/oats.git", "ref": "oats-framework/v1.1.1", "path": "oats-package" },
     "oats.dev": { "url": "https://github.com/awebai/oats-dev.git", "ref": "v1.0.0", "path": "oats-package" }
   },
   "capabilities": { "oats.review": "oats.dev" }
@@ -427,13 +427,17 @@ npm drops the source worker soul's `CLAUDE.md -> AGENTS.md`. It must not be
 advertised as a complete local package or repaired after acquisition to evade
 integrity checks. Git transport preserves the canonical source alias.
 
-The optional `oats.knowledge-theory` package is a separate Git payload in this
+The `oats.framework` distribution package is a separate Git payload in this
 repository's `oats-package/`, excluded from the kernel npm tarball. The catalog
-entry selects published framework v0.23.0, which contains package 1.0.0.
-The source reference patch 1.0.1 is separately available through an explicit
-v0.23.1 Git source after that framework tag is published. It supplies an authoring skill and
-`knowledge-theory-expert`, not a default knowledge-layer binding, runtime judge
-or OKF dependency. Acquiring it does not activate it.
+entry selects the published `oats-framework/v1.1.1` tag, which exports three
+capabilities: `oats.core` (day-to-day operation: `oats-operate`, `oats-souls`
+and the "you run on OATS" briefing — declared explicitly on every soul by
+default at creation and removable), `oats.setup` (OATS Soul Setup: `oats-config`,
+`oats-packages`, `oats-workspace-setup`) and the optional `oats.knowledge-theory`
+(authoring skill and `knowledge-theory-expert`). Acquire it with
+`oats install oats.framework`; the capability ids also resolve through the
+catalog aliases. Acquiring it does not activate anything, bind a knowledge
+layer or add a runtime judge.
 
 Updating OKF v1 to v2 is a breaking capability change. Preserve existing
 knowledge and source state/cursors, explicitly bind/provision external owners,