yaaw-se 0.3.11 → 0.3.13

package/dist/payload/yaaw-core/system/templates/project-state.json

@@ -1,13 +0,0 @@
-{
-  "schema": "yaaw.project-state/v2",
-  "phase": "product",
-  "product": {"artifact": ".yaaw-core/project/product.md", "status": "missing", "revision": 0},
-  "planning": {"artifact": ".yaaw-core/project/engineering.md", "status": "missing", "revision": 0, "current_frontier": null, "readiness": "pending", "active_spec": null, "scope_status": "UNKNOWN"},
-  "active_ticket": null,
-  "tickets": {},
-  "transition_sequence": 0,
-  "last_transition": null,
-  "blocker": null,
-  "last_observed_commit": null,
-  "last_workflow": null
-}

package/dist/payload/yaaw-core/system/tools/orchestration-engine.mjs

@@ -1,210 +0,0 @@
-const EXECUTABLE = new Set(["READY","IN_PROGRESS","REVIEW_REQUIRED","REPAIR_REQUIRED","PASS"]);
-export const normalizeStatus=v=>String(v??"").trim().toLowerCase();
-const num=(a,b)=>Number(a)===Number(b);
-const specId=v=>String(v??"").match(/SPEC-[0-9]+/)?.[0]??null;
-const legal=(t,a,b)=>(t?.legal??[]).some(x=>x.from===a&&x.to===b);
-const currentRepo=(r,repo)=>Boolean(r?.value?.repository?.worktree_digest&&repo?.status==="READY"&&r.value.repository.worktree_digest===repo.worktree_digest);
-const latest=(rows,pred)=>(rows??[]).filter(pred).sort((a,b)=>String(a.path).localeCompare(String(b.path))).at(-1)??null;
-const evidenceRefs=r=>new Set((r?.value?.evidence??[]).map(String));
-
-export function ticketSourceStatus(ticket,state,activeSpec){
-  if(!ticket||!activeSpec)return "SPEC_SOURCE_STALE";
-  if(!num(ticket.product_revision,state?.product?.revision))return "PRODUCT_SOURCE_STALE";
-  if(!num(ticket.engineering_revision,state?.planning?.revision))return "ENGINEERING_SOURCE_STALE";
-  if(String(ticket.spec)!==String(activeSpec.id))return "SPEC_SOURCE_STALE";
-  if(!num(ticket.spec_revision,activeSpec.revision))return "TICKET_SOURCE_STALE";
-  return "CURRENT";
-}
-export function currentAcceptedSpecs(state,a){
-  return Object.entries(a?.specs??{}).filter(([,x])=>normalizeStatus(x?.meta?.status)==="accepted")
-    .filter(([,x])=>num(x.meta.product_revision,state?.product?.revision))
-    .filter(([,x])=>num(x.meta.engineering_revision,state?.planning?.revision))
-    .filter(([,x])=>String(x.meta.frontier_id??"")===String(state?.planning?.current_frontier??""))
-    .sort(([x],[y])=>x.localeCompare(y));
-}
-function activeSpec(state,a){const id=specId(state?.planning?.active_spec);const x=id&&a?.specs?.[id];return x?{id,...x.meta,path:x.path}:null;}
-function ev(rows,id,tr,sr,kind){return latest(rows,x=>x?.value?.ticket===id&&x.value.kind===kind&&num(x.value.ticket_revision,tr)&&num(x.value.spec_revision,sr));}
-function start(rows,id,tr,sr){const x=ev(rows,id,tr,sr,"implementation_start");return x?.value?.schema==="yaaw.evidence/v3"&&x.value.result==="STARTED"?x:null;}
-function verify(rows,id,tr,sr){return ev(rows,id,tr,sr,"implementation_verification");}
-function review(rows,id,tr,sr){return (rows??[]).filter(x=>x?.value?.ticket===id&&num(x.value.ticket_revision,tr)&&num(x.value.spec_revision,sr)).sort((a,b)=>Number(a.value.round)-Number(b.value.round)).at(-1)??null;}
-function transition(id,subject,from,to,reason,evidence=[]){return{id,kind:"STATE",subject,from,to,reason,workflow:"orchestration.reconcile-state",evidence};}
-function currentTicketIds(state,a){const s=activeSpec(state,a);return s?Object.keys(state?.tickets??{}).filter(id=>ticketSourceStatus(a?.tickets?.[id]?.meta,state,s)==="CURRENT").sort():[];}
-
-export function selectReconciliation({state,artifacts:a,evidence=[],reviews=[],repository,transitions,reconciliationPolicy,routingPolicy}){
-  const order=["PROJECT_STATE_SCHEMA_MIGRATION_REQUIRED","PRODUCT_LEDGER_SYNC","PLANNING_LEDGER_SYNC","ACTIVE_SPEC_UNADOPTED","TICKET_UNREGISTERED","TICKET_ADMISSION","CONTRACT_SOURCE_STALE","IMPLEMENTATION_STARTED","IMPLEMENTATION_VERIFIED","REVIEW_RESULT_UNAPPLIED","ACCEPTANCE_STALE","PROJECT_COMPLETION_SYNC"];
-  const declared=(reconciliationPolicy?.priority??[]).map(x=>typeof x==="string"?x:x.id);
-  if(declared.length&&JSON.stringify(declared)!==JSON.stringify(order))return{id:"RECONCILIATION_POLICY_DRIFT",kind:"BLOCKED",reason:"reconciliation priority differs from engine contract"};
-  if(!state)return{id:"PROJECT_STATE_MISSING",kind:"BLOCKED",reason:"project state missing"};
-  if(state.schema!=="yaaw.project-state/v2")return{id:"PROJECT_STATE_SCHEMA_MIGRATION_REQUIRED",kind:"BLOCKED",reason:"project schema requires installer migration"};
-
-  const p=a?.product?.meta;
-  if(p){
-    if(Number(state.product.revision)>Number(p.revision))return{id:"PRODUCT_LEDGER_AHEAD",kind:"BLOCKED",reason:"state product revision is ahead of durable product"};
-    if(Number(p.revision)>Number(state.product.revision)||normalizeStatus(p.status)!==normalizeStatus(state.product.status))
-      return{id:"PRODUCT_LEDGER_SYNC",kind:"STATE",subject:"product",from:String(state.product.revision),to:String(p.revision),reason:"durable product metadata is ahead",workflow:"orchestration.reconcile-state",evidence:[a.product.path],patch:{revision:Number(p.revision),status:p.status}};
-  }
-  const e=a?.engineering?.meta;
-  if(e){
-    if(Number(state.planning.revision)>Number(e.revision))return{id:"PLANNING_LEDGER_AHEAD",kind:"BLOCKED",reason:"state planning revision is ahead of durable engineering"};
-    const scope=e.scope_status??"UNKNOWN";
-    if(Number(e.revision)>Number(state.planning.revision)||normalizeStatus(e.status)!==normalizeStatus(state.planning.status)||normalizeStatus(e.readiness)!==normalizeStatus(state.planning.readiness)||String(e.current_frontier??"")!==String(state.planning.current_frontier??"")||scope!==(state.planning.scope_status??"UNKNOWN"))
-      return{id:"PLANNING_LEDGER_SYNC",kind:"STATE",subject:"planning",from:String(state.planning.revision),to:String(e.revision),reason:"durable engineering metadata is ahead",workflow:"orchestration.reconcile-state",evidence:[a.engineering.path],patch:{revision:Number(e.revision),status:e.status,readiness:e.readiness,current_frontier:e.current_frontier??null,scope_status:scope}};
-  }
-
-  const specs=currentAcceptedSpecs(state,a);
-  if(specs.length>1)return{id:"MULTIPLE_CURRENT_ACCEPTED_SPECS",kind:"BLOCKED",reason:"multiple current accepted specs"};
-  if(specs.length===1&&specId(state.planning.active_spec)!==specs[0][0]){
-    const [id,x]=specs[0];return{id:"ACTIVE_SPEC_UNADOPTED",kind:"STATE",subject:id,from:state.planning.active_spec??null,to:x.path,reason:"current accepted spec not adopted",workflow:"orchestration.reconcile-state",evidence:[x.path],patch:{active_spec:x.path}};
-  }
-
-  const s=activeSpec(state,a);
-  if(s){
-    for(const [id,x] of Object.entries(a?.tickets??{}).sort(([x],[y])=>x.localeCompare(y))){
-      if(Object.hasOwn(state.tickets??{},id))continue;
-      if(!["DRAFT","READY"].includes(String(x?.meta?.status)))continue;
-      if(ticketSourceStatus(x.meta,state,s)!=="CURRENT")continue;
-      return{id:"TICKET_UNREGISTERED",kind:"STATE",subject:id,from:null,to:x.meta.status,reason:"current ticket artifact not registered",workflow:"orchestration.reconcile-state",evidence:[x.path],patch:{ticket:id,status:x.meta.status}};
-    }
-    for(const id of Object.keys(state.tickets??{}).sort()){
-      const st=state.tickets[id],m=a?.tickets?.[id]?.meta;
-      if(st!=="DRAFT"||String(m?.status??"")!=="READY")continue;
-      if(ticketSourceStatus(m,state,s)!=="CURRENT")continue;
-      if(normalizeStatus(state?.planning?.status)!=="ready"||state?.planning?.readiness!=="PASS")continue;
-      if(!deps(id,a,state)||repository?.status!=="READY")continue;
-      const contract=(transitions?.legal??[]).find(x=>x.from==="DRAFT"&&x.to==="READY");
-      if(contract?.owner!=="planner"||contract?.workflow!=="planning.create-tickets")
-        return{id:"ILLEGAL_TICKET_ADMISSION_CONTRACT",kind:"BLOCKED",reason:"DRAFT -> READY admission must be owned by Planner planning.create-tickets"};
-      return transition("TICKET_ADMISSION",id,"DRAFT","READY","PLANNER_ADMISSION_CURRENT",[a.tickets[id].path,s.path]);
-    }
-    for(const id of Object.keys(state.tickets??{}).sort()){
-      const st=state.tickets[id];if(!EXECUTABLE.has(st))continue;
-      const cause=ticketSourceStatus(a?.tickets?.[id]?.meta,state,s);
-      if(cause!=="CURRENT"){
-        const target=routingPolicy?.invalidation_routes?.[cause]?.state;
-        if(target!=="REPLAN_REQUIRED"||!legal(transitions,st,target))return{id:"ILLEGAL_INVALIDATION_TRANSITION",kind:"BLOCKED",reason:st+" cannot transition for "+cause};
-        return transition("CONTRACT_SOURCE_STALE",id,st,target,cause,[a?.tickets?.[id]?.path,s.path].filter(Boolean));
-      }
-    }
-    for(const id of Object.keys(state.tickets??{}).sort()){
-      const st=state.tickets[id],m=a?.tickets?.[id]?.meta;if(!m)continue;
-      const tr=Number(m.revision),sr=Number(s.revision);
-      if(st==="READY"){
-        const x=start(evidence,id,tr,sr);
-        if(x)return transition("IMPLEMENTATION_STARTED",id,"READY","IN_PROGRESS","IMPLEMENTATION_STARTED",[x.path]);
-      }
-      if(st==="IN_PROGRESS"){
-        const x=verify(evidence,id,tr,sr);
-        if(x?.value?.schema==="yaaw.evidence/v3"&&x.value.result==="PASS"&&currentRepo(x,repository))
-          return transition("IMPLEMENTATION_VERIFIED",id,"IN_PROGRESS","REVIEW_REQUIRED","IMPLEMENTATION_VERIFIED",[x.path]);
-      }
-      if(st==="REPAIR_REQUIRED"){
-        const v=verify(evidence,id,tr,sr),r=review(reviews,id,tr,sr),used=evidenceRefs(r);
-        if(v?.value?.schema==="yaaw.evidence/v3"&&v.value.result==="PASS"&&currentRepo(v,repository)&&!used.has(String(v.value.id)))
-          return transition("IMPLEMENTATION_VERIFIED",id,"REPAIR_REQUIRED","REVIEW_REQUIRED","REPAIR_VERIFIED",[v.path,r?.path].filter(Boolean));
-      }
-      if(st==="REVIEW_REQUIRED"){
-        const v=verify(evidence,id,tr,sr),r=review(reviews,id,tr,sr),to={PASS:"PASS",REPAIR:"REPAIR_REQUIRED",REPLAN:"REPLAN_REQUIRED",BLOCKED:"BLOCKED"}[r?.value?.result];
-        if(r&&to&&currentRepo(r,repository)){
-          const verificationCurrent=Boolean(v?.value?.schema==="yaaw.evidence/v3"&&v.value.result==="PASS"&&currentRepo(v,repository));
-          if(!verificationCurrent)return null;
-          if(!evidenceRefs(r).has(String(v.value.id)))return null;
-          if(!legal(transitions,"REVIEW_REQUIRED",to))
-            return{id:"ILLEGAL_REVIEW_TRANSITION",kind:"BLOCKED",reason:"review result is not a legal lifecycle transition"};
-          return transition("REVIEW_RESULT_UNAPPLIED",id,"REVIEW_REQUIRED",to,"REVIEW_"+r.value.result,[r.path,v.path]);
-        }
-      }
-      if(st==="PASS"){
-        const v=verify(evidence,id,tr,sr),r=review(reviews,id,tr,sr);let reason=null;
-        if(!r)reason="REVIEW_MISSING";
-        else if(!r.value?.repository?.worktree_digest)reason="LEGACY_IDENTITY_UNVERIFIABLE";
-        else if(!currentRepo(r,repository))reason="REVIEW_REPOSITORY_STALE";
-        else if(!v||v.value?.schema!=="yaaw.evidence/v3"||v.value.result!=="PASS")reason="VERIFICATION_MISSING";
-        else if(!currentRepo(v,repository))reason="VERIFICATION_REPOSITORY_STALE";
-        else if(!evidenceRefs(r).has(String(v.value.id)))reason="VERIFICATION_MISSING";
-        if(reason){
-          const target=routingPolicy?.invalidation_routes?.[reason]?.state;
-          if(target!=="REVIEW_REQUIRED"||!legal(transitions,"PASS",target))return{id:"ILLEGAL_ACCEPTANCE_INVALIDATION",kind:"BLOCKED",reason};
-          return transition("ACCEPTANCE_STALE",id,"PASS",target,reason,[r?.path,v?.path].filter(Boolean));
-        }
-      }
-    }
-  }
-  const ids=currentTicketIds(state,a),vals=ids.map(id=>state.tickets[id]);
-  if(ids.length&&vals.every(x=>x==="PASS"||x==="CANCELLED")&&state.planning.scope_status==="COMPLETE"&&state.phase!=="complete")
-    return{id:"PROJECT_COMPLETION_SYNC",kind:"STATE",subject:"project",from:state.phase,to:"complete",reason:"all current admitted tickets terminal and scope COMPLETE",workflow:"orchestration.reconcile-state",evidence:ids};
-  return null;
-}
-function deps(id,a,state){return (a?.tickets?.[id]?.meta?.dependencies??[]).every(d=>state.tickets?.[d]==="PASS");}
-function baseRoute(state,a,evidence,reviews,repository,p){
-  if(state?.blocker)return{kind:"BLOCKED",terminal:"BLOCKED",reason:state.blocker.kind??"PROJECT_BLOCKED"};
-  if(normalizeStatus(state?.product?.status)!=="ready")return{kind:"DISPATCH_READY",workflow:p.product_unready_workflow};
-  const tickets=state?.tickets??{},replan=Object.keys(tickets).sort().find(id=>tickets[id]==="REPLAN_REQUIRED");if(replan)return{kind:"DISPATCH_READY",workflow:"planning.replan",ticket:replan};
-  if(normalizeStatus(state?.planning?.status)!=="ready"||state.planning.readiness!=="PASS")return{kind:"DISPATCH_READY",workflow:p.planning_unready_workflow};
-  const s=activeSpec(state,a);if(!s||normalizeStatus(s.status)!=="accepted")return{kind:"DISPATCH_READY",workflow:p.missing_spec_workflow};
-  const ids=currentTicketIds(state,a);if(!ids.length)return{kind:"DISPATCH_READY",workflow:p.missing_tickets_workflow};
-  const repair=ids.find(x=>tickets[x]==="REPAIR_REQUIRED");if(repair)return{kind:"DISPATCH_READY",workflow:"implementation.repair-ticket",ticket:repair};
-  const reviewRequired=ids.find(x=>tickets[x]==="REVIEW_REQUIRED");
-  if(reviewRequired){
-    const m=a.tickets[reviewRequired].meta,tr=Number(m.revision),sr=Number(s.revision),v=verify(evidence,reviewRequired,tr,sr);
-    const verificationCurrent=Boolean(v?.value?.schema==="yaaw.evidence/v3"&&v.value.result==="PASS"&&currentRepo(v,repository));
-    if(!verificationCurrent)return{kind:"DISPATCH_READY",workflow:"implementation.verify-ticket",ticket:reviewRequired,reason:"REVIEW_VERIFICATION_RECOVERY_REQUIRED"};
-    const r=review(reviews,reviewRequired,tr,sr),reviewCurrent=Boolean(r&&currentRepo(r,repository)&&evidenceRefs(r).has(String(v.value.id)));
-    if(!reviewCurrent)return{kind:"DISPATCH_READY",workflow:"review.review-ticket",ticket:reviewRequired,reason:"REVIEW_REFRESH_REQUIRED"};
-    return{kind:"DISPATCH_READY",workflow:"review.review-ticket",ticket:reviewRequired,reason:"REVIEW_RESULT_REFRESH_REQUIRED"};
-  }
-  const ip=ids.find(x=>tickets[x]==="IN_PROGRESS");if(ip){const m=a.tickets[ip].meta;return start(evidence,ip,Number(m.revision),Number(s.revision))?{kind:"DISPATCH_READY",workflow:"implementation.verify-ticket",ticket:ip}:{kind:"ROOT_ACTION",workflow:"orchestration.recover-interruption",ticket:ip,reason:"IMPLEMENTATION_START_EVIDENCE_MISSING"};}
-  const ready=ids.find(x=>tickets[x]==="READY"&&deps(x,a,state));if(ready)return{kind:"DISPATCH_READY",workflow:"implementation.implement-ticket",ticket:ready};
-  const draft=ids.find(x=>tickets[x]==="DRAFT"&&deps(x,a,state));if(draft)return{kind:"DISPATCH_READY",workflow:p.draft_admission_workflow??"planning.create-tickets",ticket:draft,reason:"TICKET_ADMISSION_REQUIRED"};
-  const vals=ids.map(x=>tickets[x]);if(vals.some(x=>x==="BLOCKED"))return{kind:"BLOCKED",terminal:"BLOCKED",reason:"TICKET_BLOCKED"};
-  if(vals.length&&vals.every(x=>x==="PASS"||x==="CANCELLED"))return state.planning.scope_status==="COMPLETE"?{kind:"TERMINAL",terminal:p.complete_terminal}:{kind:"DISPATCH_READY",workflow:p.next_frontier_workflow};
-  if(vals.some(x=>x==="DRAFT"))return{kind:"DISPATCH_READY",workflow:p.next_frontier_workflow,reason:"DRAFT_DEPENDENCIES_UNSATISFIED"};
-  const unsupported=vals.find(x=>!["READY","IN_PROGRESS","REVIEW_REQUIRED","REPAIR_REQUIRED","REPLAN_REQUIRED","BLOCKED","PASS","CANCELLED","DRAFT"].includes(x));
-  if(unsupported)return{kind:"BLOCKED",terminal:"BLOCKED",reason:"UNSUPPORTED_TICKET_STATE:"+unsupported};
-  return{kind:"DISPATCH_READY",workflow:p.next_frontier_workflow,reason:"PLANNING_ROUTE_REQUIRED"};
-}
-function legalNow(w,state,a){
-  const s=activeSpec(state,a),t=state?.tickets??{},productReady=normalizeStatus(state?.product?.status)==="ready";
-  if(w==="prd.route")return true;
-  if(["prd.revise","prd.refine"].includes(w))return Boolean(a?.product?.meta);
-  if(["planning.route","planning.readiness-review"].includes(w))return productReady;
-  if(w==="planning.create-spec")return productReady&&normalizeStatus(state.planning.status)==="ready"&&state.planning.readiness==="PASS"&&!s;
-  if(w==="planning.create-tickets"){const ids=currentTicketIds(state,a);return Boolean(s)&&(ids.length===0||ids.some(id=>t[id]==="DRAFT"&&deps(id,a,state)));}
-  if(w==="implementation.implement-ticket")return Object.values(t).includes("READY");
-  if(w==="implementation.repair-ticket")return Object.values(t).includes("REPAIR_REQUIRED");
-  if(w==="review.review-ticket")return Object.values(t).includes("REVIEW_REQUIRED");
-  return false;
-}
-export function intentComplete(i,state,a){
-  if(!i)return false;const target=String(i.target_artifact??"").match(/TASK-[0-9]+/)?.[0]??null,o=i.desired_outcome,advanced=Number(state?.last_transition?.sequence??0)>Number(i.created_from_transition_sequence??0);
-  if(o==="CREATE_SPEC")return currentAcceptedSpecs(state,a).length===1;
-  if(o==="CREATE_TICKETS"){const ids=currentTicketIds(state,a);return ids.length>0&&!ids.some(id=>state.tickets?.[id]==="DRAFT"&&deps(id,a,state));}
-  if(o==="IMPLEMENT"||o==="REPAIR")return target?state.tickets?.[target]==="REVIEW_REQUIRED":advanced&&state.last_transition?.to==="REVIEW_REQUIRED";
-  if(o==="REVIEW")return target?Boolean(state.tickets?.[target]&&state.tickets[target]!=="REVIEW_REQUIRED"):advanced&&state.last_transition?.workflow==="review.record-review";
-  if(o==="CONTINUE_PRODUCT")return normalizeStatus(state.product?.status)==="ready";
-  if(o==="REVISE_PRODUCT"||o==="REFINE_PRODUCT")return advanced&&state.last_transition?.subject==="product";
-  if(o==="CONTINUE_PLANNING")return normalizeStatus(state.planning?.status)==="ready"&&state.planning?.readiness==="PASS";
-  if(o==="PLANNING_REVIEW")return ["PASS","MISSING_DECISIONS","PRODUCT_GAP","REPLAN","BLOCKED"].includes(state.planning?.readiness);
-  return false;
-}
-export function selectRoute({state,artifacts:a,evidence=[],reviews=[],repository,intent,routingPolicy}){
-  const normal=baseRoute(state,a,evidence,reviews,repository,routingPolicy);if(!intent||intent.desired_outcome==="CONTINUE")return normal;
-  if(intentComplete(intent,state,a))return{kind:"INTENT_COMPLETE",reason:intent.completion_kind};
-  if(intent.requested_workflow&&legalNow(intent.requested_workflow,state,a)){const map={"implementation.implement-ticket":"READY","implementation.repair-ticket":"REPAIR_REQUIRED","review.review-ticket":"REVIEW_REQUIRED"},st=map[intent.requested_workflow];let ticket=st&&Object.keys(state.tickets??{}).sort().find(id=>state.tickets[id]===st);if(intent.requested_workflow==="planning.create-tickets")ticket=currentTicketIds(state,a).find(id=>state.tickets?.[id]==="DRAFT"&&deps(id,a,state))??null;return{kind:"DISPATCH_READY",workflow:intent.requested_workflow,...(ticket?{ticket}:{})};}
-  if(["REVIEW","REPAIR"].includes(intent.desired_outcome))return{kind:"BLOCKED",terminal:"BLOCKED",reason:intent.desired_outcome+"_PRECONDITION_UNSATISFIED"};
-  return normal;
-}
-export function applyReconciliation(state,r,repo){
-  if(!r||r.kind!=="STATE")throw new Error("reconciliation is not applicable");const n=structuredClone(state),seq=Number(n.transition_sequence??0)+1;
-  if(r.id==="PRODUCT_LEDGER_SYNC")Object.assign(n.product,r.patch);
-  else if(r.id==="PLANNING_LEDGER_SYNC")Object.assign(n.planning,r.patch);
-  else if(r.id==="ACTIVE_SPEC_UNADOPTED")n.planning.active_spec=r.patch.active_spec;
-  else if(r.id==="TICKET_UNREGISTERED"){n.tickets[r.patch.ticket]=r.patch.status;if(!n.active_ticket&&r.patch.status==="READY")n.active_ticket=r.patch.ticket;}
-  else if(r.id==="PROJECT_COMPLETION_SYNC"){n.phase="complete";n.active_ticket=null;}
-  else if(r.subject?.startsWith?.("TASK-")){n.tickets[r.subject]=r.to;if(["IN_PROGRESS","REVIEW_REQUIRED","REPAIR_REQUIRED","REPLAN_REQUIRED"].includes(r.to))n.active_ticket=r.subject;if(["PASS","CANCELLED"].includes(r.to)&&n.active_ticket===r.subject)n.active_ticket=null;}
-  n.transition_sequence=seq;n.last_transition={sequence:seq,subject:r.subject,from:r.from??null,to:r.to,workflow:r.workflow??"orchestration.reconcile-state",reason:r.reason,evidence:r.evidence??[],observed_commit:repo?.head_commit??null};n.last_observed_commit=repo?.head_commit??null;n.last_workflow=r.workflow??"orchestration.reconcile-state";return n;
-}
-export function planNext(input){
-  if(input?.framework?.integrity_status!=="HEALTHY"){const s=input?.framework?.integrity_status??"UNKNOWN";return{kind:"FRAMEWORK_STOP",reason:s==="CONTRACT_INCONSISTENT"?"FRAMEWORK_CONTRACT_INCONSISTENCY":["UNKNOWN","MANIFEST_INVALID"].includes(s)?"FRAMEWORK_INTEGRITY_UNKNOWN":"FRAMEWORK_INTEGRITY_VIOLATION"};}
-  const r=selectReconciliation(input);if(r?.kind==="BLOCKED")return{kind:"BLOCKED",terminal:"BLOCKED",reason:r.id,reconciliation:r};if(r)return{kind:"RECONCILE_REQUIRED",workflow:"orchestration.reconcile-state",reconciliation:r};return selectRoute(input);
-}
-export const handoffBasis=({selected,state,intent})=>({workflow:selected.workflow,ticket:selected.ticket??null,desired_intent:intent?.desired_outcome??null,transition_sequence:Number(state?.transition_sequence??0)});

package/dist/payload/yaaw-core/system/tools/orchestration-runtime.mjs

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-import {spawnSync} from "node:child_process";
-import {mkdir,readFile,readdir,rm,writeFile} from "node:fs/promises";
-import {basename,join,relative,resolve} from "node:path";
-import {applyReconciliation,handoffBasis,planNext} from "./orchestration-engine.mjs";
-import {parseFrontmatter} from "./frontmatter.mjs";
-
-const argv=process.argv.slice(2);let workspaceArg=".",mode="prepare",invokeSkill=null;
-for(let i=0;i<argv.length;i++){if(argv[i]==="--workspace"&&argv[i+1])workspaceArg=argv[++i];else if(argv[i]==="--inspect-only")mode="inspect";else if(argv[i]==="--check-handoff")mode="check";else if(argv[i]==="--reconcile-one")mode="reconcile";else if(argv[i]==="--invoke-skill"&&argv[i+1])invokeSkill=argv[++i];else{process.stderr.write("usage: orchestration-runtime.mjs [--workspace <path>] [--invoke-skill <id>] [--inspect-only|--check-handoff|--reconcile-one]\n");process.exit(2);}}
-const workspace=resolve(workspaceArg),systemRoot=join(workspace,".yaaw-core","system"),projectRoot=join(workspace,".yaaw-core","project"),runtimeRoot=join(workspace,".yaaw-core","runtime");
-const observedPath=join(runtimeRoot,"observed-state.json"),handoffPath=join(runtimeRoot,"handoff.json"),intentPath=join(runtimeRoot,"intent.json"),statePath=join(projectRoot,"state.json");
-const json=async p=>JSON.parse(await readFile(p,"utf8"));const maybe=async p=>{try{return await json(p)}catch{return null}};const uniq=a=>[...new Set(a.filter(Boolean))];
-async function fm(path){try{return parseFrontmatter(await readFile(path,"utf8"))}catch{return null}}
-async function list(dir,re){try{return(await readdir(dir,{withFileTypes:true})).filter(x=>x.isFile()&&re.test(x.name)).map(x=>join(dir,x.name)).sort()}catch{return[]}}
-function run(tool,args){const r=spawnSync(process.execPath,[tool,...args],{cwd:workspace,encoding:"utf8",windowsHide:true,maxBuffer:64*1024*1024});try{return JSON.parse(r.stdout||"{}")}catch{throw new Error((r.stderr||"").trim()||"invalid JSON from "+basename(tool))}}
-function framework(raw,status=raw?.status??"UNKNOWN"){return{yaaw_version:String(raw?.package_version??"unknown"),system_schema:Number(raw?.system_schema??1),installation_schema:Number(raw?.installation_schema??1),project_schema:Number(raw?.project_schema??1),manifest_digest:String(raw?.manifest_digest??"sha256:unknown"),integrity_status:status,modified:Array.isArray(raw?.modified)?raw.modified:[],missing:Array.isArray(raw?.missing)?raw.missing:[],local_overrides:Array.isArray(raw?.local_overrides)?raw.local_overrides:[],repair_required:status!=="HEALTHY"}}
-function repo(raw){return{schema:"yaaw.repository-identity/v2",algorithm:raw?.algorithm??null,status:raw?.status??"UNAVAILABLE",workspace_scope:String(raw?.workspace_scope??"."),git_root_relation:raw?.git_root_relation??"unknown",head_commit:raw?.head_commit??null,dirty:typeof raw?.dirty==="boolean"?raw.dirty:null,worktree_digest:raw?.worktree_digest??null,components:raw?.components??null,changed_paths:Array.isArray(raw?.changed_paths)?raw.changed_paths:[],error:raw?.error??null}}
-async function contracts(){const names=["workflows","execution-policy","role-io","routing-policy","handoff-policy","artifacts","skills","transitions","reconciliation-policy"];const vals=await Promise.all(names.map(n=>json(join(systemRoot,"registries",n+".json"))));const c=Object.fromEntries(names.map((n,i)=>[n.replaceAll("-","_"),vals[i]])),errors=[];for(const[w,p]of Object.entries(c.handoff_policy.workflows??{})){const reg=c.workflows[w],ex=c.execution_policy.workflows?.[w],io=c.role_io.roles?.[reg?.role];if(!reg)errors.push("unknown workflow "+w);if(!ex)errors.push("no execution policy "+w);if(!io)errors.push("unknown role "+reg?.role);if(io){const br=(p.reads??[]).filter(x=>!io.reads.includes(x)),bw=(p.writes??[]).filter(x=>!io.writes.includes(x));if(br.length)errors.push(w+" bad reads "+br);if(bw.length)errors.push(w+" bad writes "+bw)}}return{...c,errors}}
-const rel=p=>relative(workspace,p).replaceAll("\\","/"),specId=v=>String(v??"").match(/SPEC-[0-9]+/)?.[0]??null;
-async function inspect(state){const pp=join(projectRoot,"product.md"),ep=join(projectRoot,"engineering.md"),specs={},tickets={},reviews=[],evidence=[];for(const p of await list(join(projectRoot,"specs"),/^SPEC-[0-9]+\.md$/)){const m=await fm(p);if(m?.id)specs[m.id]={path:rel(p),meta:m}}for(const p of await list(join(projectRoot,"tickets"),/^TASK-[0-9]+\.md$/)){const m=await fm(p);if(m?.id)tickets[m.id]={path:rel(p),meta:m}}for(const p of await list(join(projectRoot,"reviews"),/^TASK-[0-9]+-R[0-9]+\.md$/)){const v=await fm(p);if(v)reviews.push({path:rel(p),value:v})}for(const p of await list(join(projectRoot,"evidence"),/\.json$/)){try{evidence.push({path:rel(p),value:await json(p)})}catch{}}return{product:{path:rel(pp),meta:await fm(pp)},engineering:{path:rel(ep),meta:await fm(ep)},specs,tickets,reviews,evidence,research:(await list(join(projectRoot,"research"),/^RSH-.*\.md$/)).map(rel),rules:(await list(join(projectRoot,"rules"),/\.md$/)).map(rel),activeSpecId:specId(state?.planning?.active_spec)}}
-function summary(a){return{product:a.product.meta?a.product:null,engineering:a.engineering.meta?a.engineering:null,specs:a.specs,tickets:a.tickets,reviews:a.reviews.map(x=>x.path),evidence:a.evidence.map(x=>x.path)}}
-function requirement(r,repository){return r==="NONE"||r==="INSPECT"&&["READY","UNVERSIONED"].includes(repository.status)||r==="IDENTITY"&&repository.status==="READY"}
-function refs(policy,a,ticket,state){const out=[];for(const x of policy.reads??[]){if(x==="product"&&a.product.meta)out.push(a.product.path);else if(x==="engineering"&&a.engineering.meta)out.push(a.engineering.path);else if(x==="spec"){const id=specId(state?.planning?.active_spec);if(id&&a.specs[id])out.push(a.specs[id].path)}else if(x==="ticket"&&ticket&&a.tickets[ticket])out.push(a.tickets[ticket].path);else if(x==="evidence")out.push(...a.evidence.map(v=>v.path));else if(x==="review")out.push(...a.reviews.map(v=>v.path));else if(x==="engineering_research")out.push(...a.research);else if(x==="project_rule")out.push(...a.rules);else if(x==="state")out.push(".yaaw-core/project/state.json")}return uniq(out)}
-function revisions(state,a,ticket){const id=specId(state?.planning?.active_spec);return{product:Number(state?.product?.revision??0),engineering:Number(state?.planning?.revision??0),spec:Number(id?a.specs?.[id]?.meta?.revision??0:0),ticket:Number(ticket?a.tickets?.[ticket]?.meta?.revision??0:0)}}
-async function expertise(policy,role,a,ticket){const reg=await json(join(systemRoot,"registries","expertise.json")),ids=[...(policy.required_expertise??[])];if(policy.ticket_expertise&&ticket&&Array.isArray(a.tickets?.[ticket]?.meta?.expertise))ids.push(...a.tickets[ticket].meta.expertise);return uniq(ids).filter(id=>reg[id]&&(reg[id].usable_by??[]).includes(role)).sort()}
-function active(policy,a,ticket,state){if(policy.active_artifact==="product")return a.product.meta?a.product.path:null;if(policy.active_artifact==="engineering")return a.engineering.meta?a.engineering.path:null;if(policy.active_artifact==="spec"){const id=specId(state?.planning?.active_spec);return id?a.specs[id]?.path??null:null}if(policy.active_artifact==="ticket")return ticket?a.tickets[ticket]?.path??null:null;return null}
-async function handoff(sel,c,state,a,fw,repository,intent){const reg=c.workflows[sel.workflow],p=c.handoff_policy.workflows[sel.workflow],ex=c.execution_policy.workflows[sel.workflow];if(!reg||!p||!ex)throw new Error("missing deterministic handoff contract for "+sel.workflow);const role=reg.role;return{schema:"yaaw.handoff/v3",framework:{yaaw_version:fw.yaaw_version,system_schema:fw.system_schema,installation_schema:fw.installation_schema,project_schema:fw.project_schema,manifest_digest:fw.manifest_digest,integrity_status:"HEALTHY"},role,workflow:sel.workflow,desired_intent:intent?.desired_outcome??p.desired_intent??null,active_artifact:active(p,a,sel.ticket,state),references:refs(p,a,sel.ticket,state),reads:uniq(p.reads??[]),writes:uniq(p.writes??[]),forbidden_writes:uniq(c.role_io.roles[role].forbidden_writes??[]),revisions:revisions(state,a,sel.ticket),expertise:await expertise(p,role,a,sel.ticket),host_expertise:[],expected_output:p.expected_output,result_vocabulary:uniq(p.result_vocabulary??[]),repository_requirement:ex.repository_requirement,repository,transition_sequence:Number(state.transition_sequence??0)}}
-async function seed(skill,c,state){const s=c.skills[skill];if(!s)throw new Error("unknown public skill "+skill);const v={schema:"yaaw.intent/v2",source_skill:skill,desired_outcome:s.desired_outcome,requested_workflow:s.requested_workflow??s.workflow_id,target_artifact:null,completion_kind:s.completion_kind,created_from_transition_sequence:Number(state?.transition_sequence??0)};await mkdir(runtimeRoot,{recursive:true});await writeFile(intentPath,JSON.stringify(v,null,2)+"\n");return v}
-const clear=async p=>rm(p,{force:true}),same=(a,b)=>JSON.stringify(a)===JSON.stringify(b);
-async function main(){
- let raw;try{raw=run(join(systemRoot,"tools","framework-integrity.mjs"),["--workspace",workspace])}catch(e){raw={status:"UNKNOWN",error:String(e)}}let fw=framework(raw),c;try{c=await contracts()}catch(e){return{schema:"yaaw.orchestration-runtime/v2",status:"FRAMEWORK_STOP",reason:"FRAMEWORK_CONTRACT_INCONSISTENCY",error:String(e)}}if(c.errors.length)fw=framework(raw,"CONTRACT_INCONSISTENT");
- let rr;try{rr=run(join(systemRoot,"tools","repository-identity.mjs"),["--workspace",workspace])}catch(e){rr={status:"UNAVAILABLE",workspace_scope:".",git_root_relation:"unknown",error:String(e)}}const repository=repo(rr);let state=await maybe(statePath);if(invokeSkill)await seed(invokeSkill,c,state);const intent=await maybe(intentPath),a=await inspect(state);
- const p=planNext({framework:fw,repository,state,artifacts:a,evidence:a.evidence,reviews:a.reviews,intent,transitions:c.transitions,routingPolicy:c.routing_policy,reconciliationPolicy:c.reconciliation_policy});
- const observed={schema:"yaaw.observed-state/v3",framework:fw,repository,transition_sequence:Number(state?.transition_sequence??0),claims:state??{},artifacts:summary(a),inconsistencies:c.errors.map(x=>"FRAMEWORK_CONTRACT_INCONSISTENCY:"+x),candidate_actions:[],reconciliation:p.reconciliation??null};
- const persist=async()=>{await mkdir(runtimeRoot,{recursive:true});await writeFile(observedPath,JSON.stringify(observed,null,2)+"\n")};
- if(p.kind==="FRAMEWORK_STOP"){observed.candidate_actions=["INSTALLER_REPAIR"];if(mode!=="check"){await persist();await clear(handoffPath)}return{schema:"yaaw.orchestration-runtime/v2",status:"FRAMEWORK_STOP",reason:p.reason,observed}}
- if(p.kind==="RECONCILE_REQUIRED"){observed.candidate_actions=["orchestration.reconcile-state"];if(mode==="reconcile"){state=applyReconciliation(state,p.reconciliation,repository);await writeFile(statePath,JSON.stringify(state,null,2)+"\n");observed.transition_sequence=state.transition_sequence;observed.claims=state;await persist();await clear(handoffPath);return{schema:"yaaw.orchestration-runtime/v2",status:"RECONCILED",reconciliation:p.reconciliation,state}}if(mode!=="check"){await persist();await clear(handoffPath)}return{schema:"yaaw.orchestration-runtime/v2",status:"RECONCILE_REQUIRED",workflow:"orchestration.reconcile-state",reconciliation:p.reconciliation,observed}}
- if(p.kind==="INTENT_COMPLETE"){observed.candidate_actions=["INTENT_COMPLETE"];if(mode!=="check"){await persist();await clear(handoffPath);await clear(intentPath)}return{schema:"yaaw.orchestration-runtime/v2",status:"INTENT_COMPLETE",completion_kind:intent?.completion_kind??null,observed}}
- if(mode==="inspect"){observed.candidate_actions=[p.workflow??p.terminal??p.reason??p.kind];await persist();return{schema:"yaaw.orchestration-runtime/v2",status:"INSPECTED",observed}}
- if(["ROOT_ACTION","TERMINAL","BLOCKED"].includes(p.kind)){observed.candidate_actions=[p.workflow??p.terminal??p.reason??p.kind];if(mode!=="check"){await persist();await clear(handoffPath)}return{schema:"yaaw.orchestration-runtime/v2",status:p.kind,workflow:p.workflow??null,terminal:p.terminal??null,reason:p.reason??null,observed}}
- const ex=c.execution_policy.workflows[p.workflow];if(!requirement(ex.repository_requirement,repository)){if(mode!=="check"){await persist();await clear(handoffPath)}return{schema:"yaaw.orchestration-runtime/v2",status:"BLOCKED",terminal:"BLOCKED",reason:ex.repository_requirement==="IDENTITY"?"REPOSITORY_IDENTITY_UNAVAILABLE":"REPOSITORY_INSPECTION_UNAVAILABLE",workflow:p.workflow,observed}}
- const h=await handoff(p,c,state,a,fw,repository,intent);observed.candidate_actions=[p.workflow];
- if(mode==="check"){const old=await maybe(handoffPath);return old&&same(old,h)?{schema:"yaaw.orchestration-runtime/v2",status:"HANDOFF_FRESH",...handoffBasis({selected:p,state,intent})}:{schema:"yaaw.orchestration-runtime/v2",status:"HANDOFF_STALE",workflow:p.workflow,reason:"HANDOFF_BASIS_CHANGED"}}
- await persist();await writeFile(handoffPath,JSON.stringify(h,null,2)+"\n");return{schema:"yaaw.orchestration-runtime/v2",status:"DISPATCH_READY",workflow:h.workflow,role:h.role,handoff:h}
-}
-try{const r=await main();process.stdout.write(JSON.stringify(r,null,2)+"\n");process.exitCode=["DISPATCH_READY","INSPECTED","HANDOFF_FRESH","ROOT_ACTION","TERMINAL","RECONCILED","INTENT_COMPLETE"].includes(r.status)?0:2}catch(e){process.stdout.write(JSON.stringify({schema:"yaaw.orchestration-runtime/v2",status:"FRAMEWORK_STOP",reason:"FRAMEWORK_CONTRACT_INCONSISTENCY",error:String(e?.message??e)},null,2)+"\n");process.exitCode=2}

package/dist/payload/yaaw-core/system/tools/repository-identity.mjs

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-import { createHash } from "node:crypto";
-import { lstatSync, readFileSync, readlinkSync } from "node:fs";
-import { resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-
-const ALGORITHM = "yaaw-worktree-v2";
-const CONTROL_OUTPUT_EXCLUDES = [
-  ".yaaw-core/runtime/**",
-  ".yaaw-core/project/state.json",
-  ".yaaw-core/project/evidence/**",
-  ".yaaw-core/project/reviews/**"
-];
-const EXCLUDE_PATHSPECS = CONTROL_OUTPUT_EXCLUDES.map(path => `:(exclude)${path}`);
-const hash = value => createHash("sha256").update(value).digest("hex");
-function stable(value) {
-  if (Array.isArray(value)) return value.map(stable);
-  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map(k => [k, stable(value[k])]));
-  return value;
-}
-const canonicalJson = value => JSON.stringify(stable(value));
-function fail(status, message) {
-  process.stdout.write(JSON.stringify({
-    schema:"yaaw.repository-identity/v2", algorithm:null, status, workspace_scope:".",
-    git_root_relation:status==="UNVERSIONED"?"none":"unknown", head_commit:null, dirty:null,
-    worktree_digest:null, components:null, changed_paths:[], error:message
-  })+"\n");
-  process.exitCode=2;
-}
-function git(workspace,args) {
-  const r=spawnSync("git",["-C",workspace,...args],{encoding:null,windowsHide:true,maxBuffer:64*1024*1024});
-  if(r.error) throw r.error;
-  if(r.status!==0) throw new Error((r.stderr??Buffer.alloc(0)).toString("utf8").trim()||`git ${args.join(" ")} exited ${r.status}`);
-  return r.stdout??Buffer.alloc(0);
-}
-const nulPaths=buf=>buf.toString("utf8").split("\0").filter(Boolean).map(p=>p.replaceAll("\\","/")).sort();
-function untrackedRecord(workspace,path) {
-  const absolute=resolve(workspace,path);
-  const stat=lstatSync(absolute);
-  if(stat.isSymbolicLink()) return {path,kind:"symlink",sha256:hash(Buffer.from(readlinkSync(absolute),"utf8"))};
-  if(stat.isFile()) return {path,kind:"file",sha256:hash(readFileSync(absolute))};
-  throw new Error(`unsupported untracked filesystem object: ${path}`);
-}
-
-const args=process.argv.slice(2);
-let workspaceArg=".";
-for(let i=0;i<args.length;i+=1){
-  if(args[i]==="--workspace" && args[i+1]) {workspaceArg=args[i+1]; i+=1;}
-  else {process.stderr.write("usage: repository-identity.mjs [--workspace <path>]\n"); process.exit(2);}
-}
-const workspace=resolve(workspaceArg);
-let workspacePrefix;
-try {
-  const inside=git(workspace,["rev-parse","--is-inside-work-tree"]).toString("utf8").trim();
-  if(inside!=="true") throw new Error("workspace is not inside a Git work tree");
-  workspacePrefix=git(workspace,["rev-parse","--show-prefix"]).toString("utf8").trim().replaceAll("\\","/");
-}
-catch(error){ fail("UNVERSIONED",error instanceof Error?error.message:String(error)); }
-
-if(workspacePrefix !== undefined){
-  try {
-      const head=git(workspace,["rev-parse","HEAD"]).toString("utf8").trim();
-      const scoped=[".",...EXCLUDE_PATHSPECS];
-      const status=git(workspace,["status","--porcelain=v1","-z","--untracked-files=all","--",...scoped]);
-      const unstaged=git(workspace,["diff","--binary","--no-ext-diff","--no-textconv","HEAD","--",...scoped]);
-      const staged=git(workspace,["diff","--cached","--binary","--no-ext-diff","--no-textconv","HEAD","--",...scoped]);
-      const untracked=nulPaths(git(workspace,["ls-files","--others","--exclude-standard","-z","--",...scoped])).map(p=>untrackedRecord(workspace,p));
-      const tracked=new Set([
-        ...nulPaths(git(workspace,["diff","--name-only","-z","HEAD","--",...scoped])),
-        ...nulPaths(git(workspace,["diff","--cached","--name-only","-z","HEAD","--",...scoped]))
-      ]);
-      const components={
-        status_sha256:hash(status),
-        unstaged_diff_sha256:hash(unstaged),
-        staged_diff_sha256:hash(staged),
-        untracked_manifest_sha256:hash(Buffer.from(canonicalJson(untracked),"utf8"))
-      };
-      const payload={algorithm:ALGORITHM,workspace_scope:".",head_commit:head,excluded:CONTROL_OUTPUT_EXCLUDES,...components,untracked};
-      const changed_paths=[
-        ...[...tracked].sort().map(path=>({path,kind:"tracked"})),
-        ...untracked.map(x=>({path:x.path,kind:"untracked",sha256:x.sha256}))
-      ].sort((a,b)=>a.path.localeCompare(b.path));
-      process.stdout.write(JSON.stringify({
-        schema:"yaaw.repository-identity/v2",algorithm:ALGORITHM,status:"READY",workspace_scope:".",
-        git_root_relation:workspacePrefix?"ancestor":"same",head_commit:head,dirty:status.length>0,
-        worktree_digest:"sha256:"+hash(Buffer.from(canonicalJson(payload),"utf8")),
-        components,changed_paths,error:null
-      })+"\n");
-  } catch(error) {
-    if(process.exitCode!==2) fail("IDENTITY_FAILED",error instanceof Error?error.message:String(error));
-  }
-}

package/dist/payload/yaaw-core/system/workflows/implementation/implement-ticket.md

@@ -1,18 +0,0 @@
-# Implement ticket
-
-## Purpose
-Implement one admitted bounded ticket while making interruption recoverable from durable facts.
-
-## Preconditions
-Reconciled state says the ticket is `READY`; source revisions are current; dependencies pass; repository identity is `READY`.
-
-## Procedure
-1. Read the exact handoff, state, ticket, source contracts, `.yaaw-core/system/rules/changeability.md`, applicable expertise, and minimal code.
-2. Before editing any application file, write immutable v3 `implementation_start` evidence with result `STARTED`, current ticket/spec revisions, workflow ID, and the exact pre-edit repository identity.
-3. Only after that durable start fact exists, implement strictly inside allowed scope.
-4. If a material contract gap appears, stop with `REPLAN_REQUIRED` or `BLOCKED`; do not invent it.
-5. Execute `implementation.verify-ticket`.
-6. Persist verification evidence. Do not mutate lifecycle state directly.
-
-## Output
-Bounded implementation plus durable start/verification evidence or a typed stop. Orchestrator adopts `READY -> IN_PROGRESS` from start evidence and `IN_PROGRESS -> REVIEW_REQUIRED` only from current PASS verification.

package/dist/payload/yaaw-core/system/workflows/implementation/repair-ticket.md

@@ -1,17 +0,0 @@
-# Repair ticket
-
-## Purpose
-Correct implementation defects while keeping the accepted ticket/spec contract unchanged.
-
-## Preconditions
-Reconciled state is `REPAIR_REQUIRED` and the latest review result is `REPAIR` against the current contract.
-
-## Procedure
-1. Load state, the unchanged ticket contract, `.yaaw-core/system/rules/changeability.md`, latest review findings, prior evidence, and relevant code.
-2. Repair only the bounded findings; do not broaden scope.
-3. If repair requires product/architecture contract changes, return `REPLAN_REQUIRED`.
-4. Rerun `implementation.verify-ticket` and write a new v3 verification record distinct from evidence referenced by the REPAIR review.
-5. Never edit state. Orchestrator moves `REPAIR_REQUIRED -> REVIEW_REQUIRED` only after fresh PASS verification.
-
-## Output
-Repaired reviewable implementation with fresh verification evidence, or a typed replan/blocker result.

package/dist/payload/yaaw-core/system/workflows/implementation/select-ticket.md

@@ -1,17 +0,0 @@
-# Select ticket
-
-## Purpose
-Choose exactly one safe implementation unit.
-
-## Inputs
-Ticket states, dependencies, current source revisions, repository status/identity, and optional specifically requested ticket.
-
-## Procedure
-1. Require repository status `READY`; otherwise return `PRECONDITION_UNSATISFIED:REPOSITORY_IDENTITY_UNAVAILABLE` to Orchestrator.
-2. If state/repository disagree, return control to orchestration recovery first.
-3. Reject `DRAFT`, `BLOCKED`, `REPLAN_REQUIRED`, `REPAIR_REQUIRED`, `REVIEW_REQUIRED`, `PASS`, or stale-source tickets for normal implementation.
-4. Choose the specifically requested eligible ticket, otherwise the next dependency-satisfied `READY` ticket.
-5. Revalidate source spec/product/engineering revisions immediately before admission.
-
-## Output
-One admitted `READY` ticket, or `PRECONDITION_UNSATISFIED:NO_READY_TICKET` / another exact blocker result for Orchestrator.

package/dist/payload/yaaw-core/system/workflows/implementation/verify-ticket.md

@@ -1,19 +0,0 @@
-# Verify ticket
-
-## Purpose
-Produce reproducible implementation evidence without self-accepting the ticket.
-
-## Inputs
-Exact handoff, reconciled state, ticket requirements/tests, changed surface, project rules/tooling, and current repository identity.
-
-## Procedure
-1. Run every ticket-required test/check and justified targeted regressions.
-2. Verify materially relevant changeability properties as concrete behavior.
-3. After verification commands finish, capture the canonical repository identity.
-4. Write a new immutable `.yaaw-core/project/evidence/EVIDENCE-TASK-NNN-VK.json` using `yaaw.evidence/v3`.
-5. Set `kind: implementation_verification` and exactly one result: `PASS`, `FAIL`, or `BLOCKED`.
-6. Preserve failed records; fixes produce a later evidence record.
-7. If verification proves implementation materially incomplete, return `IMPLEMENTATION_INCOMPLETE` to Orchestrator rather than silently reimplementing in this verification workflow.
-
-## Output
-One explicit verification result. Only a current PASS record can authorize review admission; evidence-file existence alone never does.

package/dist/payload/yaaw-core/system/workflows/orchestration/determine-next-action.md

@@ -1,24 +0,0 @@
-# Determine next action
-
-## Purpose
-Expose the deterministic route/handoff preparation contract without duplicating routing logic in the Orchestrator model.
-
-## Procedure
-Normal orchestration satisfies this workflow by executing:
-
-```text
-node .yaaw-core/system/tools/orchestration-runtime.mjs --workspace <WORKSPACE_ROOT>
-```
-
-The runtime reads the machine routing/execution/role-I/O/handoff policies, current durable metadata, framework basis, and canonical repository identity; it then returns exactly one typed result and, only for a dispatchable non-Orchestrator semantic workflow, persists one `yaaw.handoff/v2`.
-
-- `DISPATCH_READY`: consume the persisted handoff; do not rebuild it.
-- `RECONCILE_REQUIRED`: execute only `orchestration.reconcile-state` before preparing again.
-- `ROOT_ACTION`: execute only the selected Orchestrator recovery workflow. This result is valid only for a proven interruption boundary; ordinary `DRAFT` admission routes to Planner.
-- `TERMINAL`/`BLOCKED`/`FRAMEWORK_STOP`: write no executable handoff.
-
-## Boundary
-Do not perform target-role semantic work here. Do not hand-serialize a handoff or select expertise outside the deterministic handoff policy.
-
-## Framework write guard
-The runtime verifies selected reads/writes against `role-io.json`; an unauthorized artifact class or missing machine contract is `FRAMEWORK_CONTRACT_INCONSISTENCY`, never a semantic reroute.

package/dist/payload/yaaw-core/system/workflows/orchestration/dispatch.md

@@ -1,35 +0,0 @@
-# Dispatch one handoff
-
-## Purpose
-Execute exactly one already-selected canonical workflow. This file is not the orchestration loop.
-
-## Inputs
-`.yaaw-core/runtime/handoff.json` produced by the deterministic orchestration runtime.
-
-## Procedure
-1. Immediately before loading target semantics, execute:
-
-```text
-node .yaaw-core/system/tools/orchestration-runtime.mjs --workspace <WORKSPACE_ROOT> --check-handoff
-```
-
-2. Require `HANDOFF_FRESH`. `FRAMEWORK_STOP`, `RECONCILE_REQUIRED`, `ROOT_ACTION`, `TERMINAL`, `BLOCKED`, or `HANDOFF_STALE` returns control to `orchestration.route`; do not execute the stale target. This single freshness check reuses the same framework, repository-identity, artifact, routing, and handoff serialization implementation that created the handoff.
-3. Resolve the handoff's execution-context policy from `execution-policy.json` and `.yaaw-core/system/core/dispatch-execution.md`.
-4. If the target is an Orchestrator workflow or policy is `ROOT_ONLY`, execute in the current root context.
-5. Otherwise ask the active host adapter to resolve the selected authority's required effective execution profile. This is host execution metadata; do not write provider model/reasoning identifiers into the canonical handoff.
-6. Prefer the adapter's exact named authority worker when available. If named selection is unavailable before child creation, the adapter may choose a generic isolated mechanism only after proving profile equivalence or authoritatively correcting every mismatched profile dimension.
-7. If an isolated mechanism exists but cannot guarantee the required profile, return `BLOCKED:HOST_EXECUTION_PROFILE_UNAVAILABLE`. If strict isolation is required and no isolated mechanism exists at all, return `BLOCKED:HOST_ISOLATION_UNAVAILABLE`.
-8. In an adapter `auto` mode, inline fallback is legal only when the adapter proves the inline/root execution profile equivalent to the required authority profile. A deliberately selected adapter `inline` mode is an explicit opt-out from per-role model isolation.
-9. If a child was already created and then failed, do **not** switch mechanisms or retry blindly; return to deterministic reality preparation first.
-10. For Implementer or Reviewer, consult `.yaaw-core/runtime/dispatch-failures.json` only after inspection. If the unchanged handoff basis has reached the host-configured execution-failure threshold, request the configured host capability-fallback profile for this attempt. Resolve and preserve that fallback profile using the same fidelity rules. If the fallback itself already failed with no progress on this basis, return `BLOCKED:AUTHORITY_EXECUTION_FAILED`.
-11. A pre-execution `HOST_EXECUTION_PROFILE_UNAVAILABLE` or `HOST_ISOLATION_UNAVAILABLE` stop does not increment the execution-failure ledger because no authority child executed.
-12. The executing context loads only the target role contract, selected workflow contract, exact handoff reads, selected expertise, and minimal relevant repository context.
-13. Execute the target workflow once. A worker may not route or spawn another YAAW authority role.
-14. Require the expected durable output/state/evidence or an explicit legal typed stop/prerequisite result.
-15. Treat any child response only as an execution signal; do not accept it as project truth without re-inspection.
-16. Mark/remove the consumed runtime handoff and return control to `orchestration.route`.
-
-Never recursively dispatch `orchestration.dispatch` as its own target. A target role never dispatches a peer.
-
-## Package boundary
-Dispatch rejects any handoff whose writes include installer-managed artifacts or `.yaaw-core/system/**`. An admitted application-file write never authorizes package framework mutation.

package/dist/payload/yaaw-core/system/workflows/orchestration/inspect-state.md

@@ -1,19 +0,0 @@
-# Inspect state
-
-## Purpose
-Create a non-mutating observed-reality snapshot using the same deterministic runtime implementation used by normal orchestration.
-
-## Procedure
-1. Resolve `WORKSPACE_ROOT` using `.yaaw-core/system/core/execution-context.md`.
-2. Execute:
-
-```text
-node .yaaw-core/system/tools/orchestration-runtime.mjs --workspace <WORKSPACE_ROOT> --inspect-only
-```
-
-3. Consume `.yaaw-core/runtime/observed-state.json` and the typed `INSPECTED`/framework-stop result.
-4. The runtime compares current product/engineering/spec/ticket revisions and, for accepted work, current review/verification presence and repository identity so stale acceptance becomes a reconciliation input rather than a direct terminal route.
-5. Do not independently invoke Git, calculate `worktree_digest`, discover artifact locations, or serialize a second observation.
-
-## Output
-Observed-state snapshot only; no semantic/ticket-state mutation and no executable handoff construction in `--inspect-only` mode.

package/dist/payload/yaaw-core/system/workflows/orchestration/reconcile-state.md

@@ -1,19 +0,0 @@
-# Reconcile state
-
-## Purpose
-Apply exactly one highest-priority evidence-backed state adoption or legal lifecycle transition.
-
-## Inputs
-Current observed-state snapshot and its `reconciliation` object from the production orchestration engine.
-
-## Procedure
-1. Require framework integrity `HEALTHY`.
-2. Run `node .yaaw-core/system/tools/orchestration-runtime.mjs --workspace <WORKSPACE_ROOT> --reconcile-one`.
-3. Apply only the one reconciliation returned by the engine; do not batch multiple discovered facts.
-4. Increment `transition_sequence` exactly once and persist provenance.
-5. Return immediately to `orchestration.route` so reality is observed again.
-
-Examples include ledger sync, accepted-spec adoption, ticket registration, implementation-start adoption, PASS-verification adoption, review-result adoption, acceptance invalidation, and project completion sync.
-
-## Output
-One reconciled mutation or a typed blocker. No semantic product/engineering/implementation/acceptance judgment is invented here.

package/dist/payload/yaaw-core/system/workflows/orchestration/recover-interruption.md

@@ -1,32 +0,0 @@
-# Recover interruption
-
-## Purpose
-Resume safely after an actual context/session failure without duplicating already-completed work.
-
-This workflow is interruption-specific. It is not the generic fallback for an unresolved lifecycle state, a `DRAFT` ticket, missing planning admission, or a shortcut precondition failure.
-
-## Inputs
-Reconciled state, durable artifacts, implementation-start/verification evidence, reviews, and repository identity.
-
-## Selection guard
-Select `orchestration.recover-interruption` only when durable evidence indicates an interrupted execution boundary that cannot yet be classified by the ordinary semantic routes. The normal example is `IN_PROGRESS` with missing implementation-start provenance after a worker/session loss.
-
-Do not select recovery merely because no Implementer handoff is currently available.
-
-## Procedure
-1. Discard stale runtime caches/handoffs.
-2. Identify the last trustworthy durable boundary.
-3. For `IN_PROGRESS`: current PASS verification is reconciled to review; valid start evidence without PASS verification routes to `implementation.verify-ticket`; missing start evidence requires explicit recovery/blocking proof.
-4. Never rerun full implementation merely because a worker response disappeared.
-5. A source-current review artifact is adopted before another Reviewer dispatch.
-6. Use only legal transitions with provenance; if the interruption boundary cannot be proven, return an exact typed blocker rather than repeatedly selecting recovery.
-7. If inspection proves there is no interrupted execution boundary, return immediately to `orchestration.route`. Do not remain parked in recovery.
-
-## Explicit non-cases
-- registered `DRAFT` ticket with current planning/spec sources -> Planner admission;
-- `DRAFT` whose prerequisite ticket is runnable -> continue the prerequisite;
-- all accepted work PASS/CANCELLED with scope OPEN/UNKNOWN -> Planner next frontier;
-- direct Review/Repair shortcut with unsatisfied lifecycle preconditions -> typed shortcut precondition failure.
-
-## Output
-A safe next boundary or exact interruption blocker, then control returns to `orchestration.route`.