@choiceapps/communityservices-sdk 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.5.0 - 2026-11-10
+
+- Use a configured GWT enrollment catalog for creation and member preflight. Prior household enrollments, including exited entries, no longer force the known-broken REST grouped list. Failed or incomplete reads never imply absence.
+- Add `EnrollmentReadError` to distinguish a preflight non-commit from an unavailable read after a write attempt.
+- Add `correctEntry` for explicit scalar answers/clears and in-place edits to rows created by the original entry workflow. Preserve row IDs, other values and same-key recovery; original entry retries respect verified corrections.
+- Add read-only `adoptEnrollment` and `adoptHouseholdEnrollment` operations so manually entered enrollments can use the journaled exit workflows.
+- Record integrator-reported November 10, 2026 sandbox acceptance of 0.4.1 individual and household exits. The newly added catalog, correction and adoption paths have synthetic coverage; they have not been independently exercised against a live tenant.
+
+## 0.4.1 - 2026-11-10
+
+- Pin GitHub verification and publication jobs to Ubuntu 24.04. The Ubuntu 26.04 runner selected by `ubuntu-latest` cannot install Chromium with the pinned Playwright version, which blocked public npm publication of 0.4.0. SDK behavior is unchanged.
+
+## 0.4.0 - 2026-11-10
+
+- Add `exitEnrollment` for standalone program enrollments, with durable save journaling, authoritative exit verification, conditional destination/reason details and per-person exit assessments. Linked household participants continue to use `exitHousehold`, including whole-household and selected-member exits.
+- Support a standalone exit form without a household checkbox tree only when fresh enrollment data confirms exactly one participant. Initial acceptance covered synthetic regressions. Subsequent integrator-reported sandbox acceptance is recorded under capabilities on November 10, 2026.
+
 ## 0.3.0 - 2026-11-03
 
 - Compare journaled attachment and case-note intents, and shelter stay identities, by canonical hash instead of key-order-sensitive JSON, so an identical retry no longer conflicts when a store such as Postgres `jsonb` reorders keys. Existing journals remain valid.

package/browser/enrollment-workflow.d.mts

@@ -57,6 +57,34 @@ export interface InterimWorkflowInput {
   reviewDate:string;
   assessment:EnrollmentAssessmentPlan;
 }
+/** A standalone enrollment created or adopted by createEnrollment in this store. */
+export interface ExitEnrollmentInput extends HouseholdExitDetailInput {
+  key:string;
+  enrollmentKey:string;
+  clientId:number;
+  exitDate:string;
+  destination:string;
+  reasonForLeaving:string;
+  assessment:EnrollmentAssessmentPlan;
+}
+export interface EntryRowCorrection {
+ /** Original subassessment row key from createEnrollment, never a new row key. */
+ key:string;parentField:string;answers?:Answers;clear?:string[];
+}
+export interface EntryCorrectionInput {
+ key:string;enrollmentKey:string;clientId:number;
+ answers?:Answers;
+ /** Explicit clears; an omitted field stays unchanged. Clear is distinct from No. */
+ clear?:string[];
+ subassessments?:EntryRowCorrection[];
+}
+export interface EntryCorrectionResult extends EnrollmentWorkflowResult {enrollmentKey:string;}
+export interface AdoptEnrollmentInput {key:string;clientId:number;enrollmentId:number;}
+export interface AdoptHouseholdEnrollmentInput {
+ key:string;householdId:number;headClientId:number;
+ /** Complete linked cohort, including already exited participants. IDs are explicit, not inferred. */
+ members:Array<{clientId:number;enrollmentId:number}>;
+}
 export interface EnrollmentWorkflowResult {
   key:string;
   outcome:'verified'|'already-present';
@@ -71,16 +99,18 @@ export interface EnrollmentWorkflowResult {
 }
 export interface InterimWorkflowResult extends EnrollmentWorkflowResult {reviewId:number;}
 export interface ExitWorkflowResult extends EnrollmentWorkflowResult {projectExitDate:string;exitSubgroupId:string;}
+/** An individual exit may have no linked exit subgroup. */
+export interface ExitEnrollmentResult extends EnrollmentWorkflowResult {projectExitDate:string;exitSubgroupId:string|null;}
 export interface ExitWorkflowDiscovery extends EnrollmentWorkflowDiscovery {exit:{assessment:ProviderAssessmentItem;definition:AssessmentDefinition};}
 export interface EnrollmentWorkflowStatus {
   key:string;
-  kind:'entry'|'interim'|'exit';
+  kind:'entry'|'interim'|'exit'|'correction';
   stage:'pending'|'verified';
   assessmentCode:string;
   enrollmentId?:number;
   reviewId?:number;
   projectExitDate?:string;
-  exitSubgroupId?:string;
+  exitSubgroupId?:string|null;
   recordsetIds:Record<string,number>;
   steps:{name:string;state:'attempted'|'verified'}[];
 }
@@ -89,6 +119,14 @@ export interface EnrollmentWorkflow {
   discoverExit(input:EnrollmentDiscoveryInput):Promise<ExitWorkflowDiscovery>;
   createEnrollment(input:EnrollmentWorkflowInput):Promise<EnrollmentWorkflowResult>;
   createInterim(input:InterimWorkflowInput):Promise<InterimWorkflowResult>;
+  /** Standalone participant only. Linked household participants use exitHousehold. */
+  exitEnrollment(input:ExitEnrollmentInput):Promise<ExitEnrollmentResult>;
+  /** Patch an open entry at its original timestamp, before any review or exit. */
+  correctEntry(input:EntryCorrectionInput):Promise<EntryCorrectionResult>;
+  /** Verify an existing standalone entry and journal it without an HMIS write. */
+  adoptEnrollment(input:AdoptEnrollmentInput):Promise<EnrollmentWorkflowResult>;
+  /** Verify all existing linked entries, original head and dates; no HMIS writes. */
+  adoptHouseholdEnrollment(input:AdoptHouseholdEnrollmentInput):Promise<HouseholdEnrollmentResult>;
   /** Reads the local journal only. A verified journal is not fresh server verification. */
   getStatus(input:{clientId:number;key:string}):Promise<EnrollmentWorkflowStatus|null>;
   createHouseholdEnrollment(input:HouseholdEnrollmentInput):Promise<HouseholdEnrollmentResult>;
@@ -164,9 +202,9 @@ export interface EnrollmentWorkflowOptions {
   store:UiMutationStore;
   /** Required for SVPPROFDOB answers or carry-forward. Share this workflow's durable store. */
   birthDates?:DateOfBirth;
-  /** Required, along with api.households and helpers.addHouseholdMembers, for household operations. */
+  /** Required for exits; also required with api.households and helpers.addHouseholdMembers for household operations. */
   enrollmentSession?:EnrollmentReader;
-  /** Required for exitHousehold; the workflow owns its durable write journal. */
+  /** Required for exitEnrollment and exitHousehold; the workflow owns its durable write journal. */
   exitUi?:HouseholdExitUi;
   /** Required to set the later entry date for newly attached household members. */
   memberEntryDatePort?:MemberEntryDatePort;
@@ -183,6 +221,16 @@ export class EnrollmentWorkflowError extends Error {
   readonly step?:string;
   constructor(reason:string,options?:ErrorOptions&{step?:string});
 }
+/** An unavailable list is never evidence that no enrollment exists. */
+export class EnrollmentReadError extends EnrollmentWorkflowError {
+ readonly code:'ENROLLMENT_READ_FAILED';
+ readonly clientId:number;
+ readonly source:'rest'|'gwt-rpc';
+ readonly phase:'preflight'|'reconciliation';
+ /** false only when this workflow has not attempted a server write. */
+ readonly committed:false|'unknown';
+ constructor(options:{clientId:number;source:'rest'|'gwt-rpc';writeAttempted:boolean;cause?:unknown});
+}
 /** Tenant-configured. Retain stable keys and one durable store for all cooperating writers.
  * A partial or uncertain write requires reconciliation; no automatic write replay occurs. */
 export function createEnrollmentWorkflow(options:EnrollmentWorkflowOptions):EnrollmentWorkflow;

package/browser/enrollment-workflow.mjs

@@ -1,6 +1,7 @@
 import {apiScope} from './connection.mjs';
 import {validateBirthDate} from './date-of-birth.mjs';
 import {expectedExitDetails} from './exit-details.mjs';
+import {createEntryCorrector} from './entry-correction.mjs';
 import {createHash} from 'node:crypto';
 import {readProgramCatalog,encodeAnswers,encodeNewSubassessmentRow,toItems,parseRestInstant} from '../dist/esm/index.js';
 
@@ -11,6 +12,11 @@ const canonical=v=>JSON.stringify(v,(_,x)=>object(x)?Object.fromEntries(Object.k
 const hash=v=>createHash('sha256').update(canonical(v)).digest('hex');
 const fail=message=>{throw new EnrollmentWorkflowError(message);};
 export class EnrollmentWorkflowError extends Error {constructor(reason,options){super(`Enrollment workflow: ${reason}`,options);this.name='EnrollmentWorkflowError';this.reason=reason;if(options?.step!==undefined)this.step=options.step;}}
+export class EnrollmentReadError extends EnrollmentWorkflowError {
+ constructor({clientId,source,writeAttempted,cause}){
+  super(cause instanceof EnrollmentWorkflowError?cause.reason:'enrollment list unavailable',{step:'enrollment-read',cause});this.name='EnrollmentReadError';this.code='ENROLLMENT_READ_FAILED';this.clientId=clientId;this.source=source;this.phase=writeAttempted?'reconciliation':'preflight';this.committed=writeAttempted?'unknown':false;
+ }
+}
 function date(value){
  if(typeof value!=='string'||!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.000)?(?:Z|[+-]\d{2}:\d{2})$/.test(value)||!Number.isFinite(Date.parse(value))||new Date(value.slice(0,19)+'Z').toISOString().slice(0,19)!==value.slice(0,19))fail('timezone-qualified whole-second date required');
  return new Date(value).toISOString();
@@ -78,14 +84,19 @@ function compile(definition,input,{yesNoWrites,writeLabel}={}){
  }
  return {scalar:scalar.filter(q=>q.virt_field_name!=='SVPPROFDOB'),yesNo,mandatory,dateOfBirth:birthDate?.answer_value,rows:compiledRows,ends:compiledEnds,carry,excluded};
 }
-async function enrollments(api,clientId){
+async function enrollments(api,clientId,{enrollmentSession,writeAttempted=false}={}){
+ const gwt=typeof enrollmentSession?.listEnrollments==='function';
+ try{
  const all=[],ids=new Set();let count;
  for(let page=1;page<=100;page++){
-  let result;try{result=await api.enrollments.listForClient({path:{clientId},query:{perPage:100,startPage:page,total_count:true}});}catch(e){if(page===1&&e.status===404)return [];throw e;}
+  let result;
+  if(gwt){result=await enrollmentSession.listEnrollments({clientId});if(result?.source!=='gwt-rpc'||result.tenant!==api.tenant||result.clientId!==clientId)fail('enrollment list context mismatch');}
+  else try{result=await api.enrollments.listForClient({path:{clientId},query:{perPage:100,startPage:page,total_count:true}});}catch(e){if(page===1&&e.status===404)return [];throw e;}
   if(!Number.isSafeInteger(result?.count)||result.count<0||!Array.isArray(result.values)||count!==undefined&&count!==result.count)fail('enrollment count unavailable or changed');count=result.count;
-  for(const row of result.values){if(!positive(row.enrollmentId)||row.clientId!==clientId||!positive(row.enrollmentProvider)||typeof row.type!=='string'||!row.type||!Number.isFinite(restDate(row.projectStartDate))||typeof row.isActive!=='boolean'||ids.has(row.enrollmentId))fail('invalid enrollment list');ids.add(row.enrollmentId);all.push(row);}
-  if(all.length===count)return all;if(all.length>count||!result.values.length)fail('incomplete enrollment list');
+  for(const row of result.values){if(!object(row)||!positive(row.enrollmentId)||row.clientId!==clientId||!positive(row.enrollmentProvider)||typeof row.type!=='string'||!row.type||!Number.isFinite(restDate(row.projectStartDate))||typeof row.isActive!=='boolean'||ids.has(row.enrollmentId)||(gwt||row.projectExitDate!==undefined)&&row.projectExitDate!==null&&!Number.isFinite(restDate(row.projectExitDate)))fail('invalid enrollment list');ids.add(row.enrollmentId);all.push(row);}
+  if(all.length===count)return all;if(gwt||all.length>count||!result.values.length)fail('incomplete enrollment list');
  }fail('enrollment list exceeds limit');
+ }catch(cause){throw new EnrollmentReadError({clientId,source:gwt?'gwt-rpc':'rest',writeAttempted,cause});}
 }
 
 /** Explicit orchestration for an existing client. All writers must share the durable store.
@@ -118,11 +129,17 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
  };
  const scope=clientId=>JSON.stringify([tenantScope,'enrollment-workflow',clientId]);
  const reservationScope=clientId=>JSON.stringify([tenantScope,'household-workflow-reservation',clientId]);
+ const correctEntry=createEntryCorrector({api,store,enrollmentSession,writeLabel,discover,scope,reservationScope,makeError:(reason,options)=>new EnrollmentWorkflowError(reason,options)});
  const run=async(kind,raw,internal={})=>{
-  fields(raw,kind==='entry'?['key','clientId','providerId','type','entryDate','assessment']:['key','enrollmentKey','clientId',kind==='exit'?'exitDate':'reviewDate','assessment']);
+  const standaloneExit=kind==='exit'&&internal.standaloneExit===true;
+  fields(raw,kind==='entry'?['key','clientId','providerId','type','entryDate','assessment']:['key','enrollmentKey','clientId',kind==='exit'?'exitDate':'reviewDate','assessment',...(standaloneExit?['destination','reasonForLeaving','destinationDetails','reasonForLeavingOther']:[])]);
   const input=structuredClone(raw);key(input.key);if(!positive(input.clientId))fail('client ID required');
   if(kind==='entry'){if(!positive(input.providerId)||!entryExitTypes.includes(input.type))fail('program and supported Entry/Exit type required');input.entryDate=date(input.entryDate);}else{key(input.enrollmentKey);if(kind==='addition')input.entryDate=date(input.entryDate);else if(kind==='exit')input.exitDate=date(input.exitDate);else input.reviewDate=date(input.reviewDate);}
   if(!object(input.assessment))fail('assessment plan required');
+  if(standaloneExit&&(typeof enrollmentSession?.readEnrollment!=='function'||typeof exitUi?.validateExit!=='function'||typeof exitUi?.saveExit!=='function'))fail('exit UI and authoritative enrollment session required');
+  if(standaloneExit&&['destination','reasonForLeaving'].some(field=>typeof input[field]!=='string'||!input[field].trim()))fail('destination and reason for leaving required');
+  const exitDetails=standaloneExit?expectedExitDetails(input):null;
+  if(standaloneExit&&(exitDetails.destinationDetails||exitDetails.reasonForLeavingOther)&&typeof exitUi.readExitDetails!=='function')fail('authoritative exit details reader required');
   const locked=internal.locked?async(_scope,work)=>work():store.withLock.bind(store);
   return locked(scope(input.clientId),async()=>{
    const reservations=await store.withLock(reservationScope(input.clientId),()=>store.read(reservationScope(input.clientId)));
@@ -137,6 +154,27 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    if(kind!=='entry'&&!entry)fail('verified enrollment workflow required');
    const context=kind==='entry'?input:kind==='addition'?{...entry.context,entryDate:input.entryDate}:entry.context;
    if(kind!=='entry'&&Date.parse(input.exitDate??input.reviewDate)<Date.parse(context.entryDate))fail('review precedes entry');
+   const exitTarget=standaloneExit?{clientId:input.clientId,enrollmentId:entry.enrollmentId}:null;
+   const inspectStandaloneExit=async()=>{
+    const snapshot=await enrollmentSession.readEnrollment(exitTarget);
+    if(snapshot?.source!=='gwt-rpc'||snapshot.tenant!==api.tenant||snapshot.clientId!==input.clientId||snapshot.enrollmentId!==entry.enrollmentId||snapshot.providerId!==context.providerId||snapshot.enrollmentType!==context.type||restDate(snapshot.projectStartDate)!==restDate(context.entryDate))fail('individual enrollment context mismatch');
+    if(!Array.isArray(snapshot.members)||snapshot.members.length!==1||snapshot.members[0].clientId!==input.clientId||snapshot.members[0].enrollmentId!==entry.enrollmentId)fail('linked household enrollment requires exitHousehold');
+    if(!Array.isArray(snapshot.reviews)||snapshot.reviews.some(r=>!Number.isFinite(restDate(r.reviewDate))||restDate(r.reviewDate)>restDate(input.exitDate)))fail('exit precedes an existing review');
+    if(!Array.isArray(snapshot.exits)||snapshot.exits.length!==1)fail('authoritative individual exit read required');
+    const exit=snapshot.exits[0];
+    if(exit.clientId!==input.clientId||exit.enrollmentId!==entry.enrollmentId||canonical(exit.clientIds)!==canonical([input.clientId])||canonical(exit.enrollmentIds)!==canonical([entry.enrollmentId]))fail('individual exit membership mismatch');
+    if(exit.projectExitDate===null){
+     if([exit.destination,exit.reasonForLeaving,exit.exitSubgroupId].some(v=>v!==null))fail('incomplete existing exit metadata');
+     return {found:false};
+    }
+    const label=value=>typeof value==='string'?value.replace(/\s*\(HUD\)\s*$/,'').trim():value;
+    if(restDate(exit.projectExitDate)!==restDate(input.exitDate)||label(exit.destination)!==label(input.destination)||label(exit.reasonForLeaving)!==label(input.reasonForLeaving)||exit.exitSubgroupId!==null&&(typeof exit.exitSubgroupId!=='string'||!exit.exitSubgroupId))fail('existing exit conflicts with requested exit');
+    if(record&&Object.hasOwn(record,'exitSubgroupId')&&record.exitSubgroupId!==exit.exitSubgroupId)fail('exit identity changed');
+    if(record?.steps.exit?.state==='verified'&&record.steps.exit.value.exitSubgroupId!==exit.exitSubgroupId)fail('exit identity changed');
+    if(typeof exitUi.readExitDetails==='function'&&canonical(await exitUi.readExitDetails(exitTarget))!==canonical(exitDetails))fail('stored exit details conflict with requested exit');
+    return {found:true,value:exit};
+   };
+   const exitInput=standaloneExit?{...exitTarget,clientIds:[input.clientId],exitDate:input.exitDate,destination:input.destination,reasonForLeaving:input.reasonForLeaving,...(input.destinationDetails?{destinationDetails:input.destinationDetails}:{}),...(input.reasonForLeavingOther?{reasonForLeavingOther:input.reasonForLeavingOther}:{})}:null;
    const discovered=await discover({clientId:input.clientId,providerId:context.providerId,type:context.type,entryDate:kind==='entry'?input.entryDate:(input.exitDate??input.reviewDate)},kind==='exit');
    const schemaHash=hash({providerId:discovered.provider.providerId,entry:{assessment:discovered.entry.assessment,questions:discovered.entry.definition.questions},interim:{assessment:discovered.interim.assessment,questions:discovered.interim.definition.questions}});
    if((record&&record.schemaHash!==schemaHash)||(entry&&entry.schemaHash!==schemaHash))fail('program assessment configuration changed');
@@ -180,9 +218,11 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    const readSaved=async()=>questions(await api.assessments.get({path:{clientId:input.clientId,assessmentCode:code},query:{dateEffective:new Date(Date.parse(at)+1000).toISOString()}}));
    const initial=await read();
    if(expectedHead===input.clientId&&headQuestion)checkHeadAnswer(proposedHead?.answer_value??initial.find(q=>q.virt_field_name==='HUD_RELATIONTOHOH')?.answer_value);
-   for(const field of plan.carry.filter(field=>field!=='SVPPROFDOB')){const q=initial.find(q=>q.virt_field_name===field);if(!q||(q.question_type==='sub_assessment'?!q.sub_assessment_answer_list?.length:!q.answer_value))fail('carry-forward field is empty');}
+   for(const field of plan.carry.filter(field=>field!=='SVPPROFDOB')){if(kind==='entry'&&record?.correctedScalars?.[field])continue;const q=initial.find(q=>q.virt_field_name===field);if(!q||(q.question_type==='sub_assessment'?!q.sub_assessment_answer_list?.length:!q.answer_value))fail('carry-forward field is empty');}
    // Resend mandatory answers with the standard yes/no write. A blank write must not hide a recorded value.
    const mandatory=plan.mandatory.map(m=>{
+    const corrected=kind==='entry'?record?.correctedScalars?.[m.virt_field_name]:undefined;
+    if(corrected)return {...m,expected:corrected.answer_value};
     const recorded=initial.find(q=>q.virt_field_name===m.virt_field_name)?.answer_value;
     if(m.carry){
      const question=definition.questions.find(q=>q.fieldName===m.virt_field_name),options=question.options.filter(o=>String(o.id)===String(recorded));
@@ -196,6 +236,10 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    });
    // Validate closure targets before creating enrollment/review or submitting any answers.
    const current=await readCurrent();
+   if(kind==='entry'&&record?.correctedScalars){
+    const saved=await readSaved();
+    for(const q of Object.values(record.correctedScalars)){const actual=saved.find(r=>r.virt_field_name===q.virt_field_name);if(!actual||!sameAnswer(q,actual.answer_value)||q.answer_value!==''&&restDate(actual.date_effective)!==restDate(at))fail('verified entry correction changed');}
+   }
    const currentHead=current.find(q=>q.virt_field_name==='HUD_RELATIONTOHOH');
    // A fresh entry may establish a different relationship from a prior enrollment.
    if(kind!=='entry'&&currentHead?.answer_value!==null&&currentHead?.answer_value!==undefined&&currentHead.answer_value!=='')checkHeadAnswer(currentHead.answer_value);
@@ -207,6 +251,10 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     if(restDate(end.endDate)<restDate(start[0].answer_value))fail('end date precedes record start');
     if(through[0].answer_value&&restDate(through[0].answer_value)!==restDate(end.endDate))fail('record already has a different end date');
    }
+   if(standaloneExit){
+    const observed=await inspectStandaloneExit();
+    if(!observed.found&&!record?.steps.exit)await exitUi.validateExit(exitInput);
+   }
    if(internal.preflight)return {assessmentCode:code,...(internal.pinSchema?{schemaHash}:{}),...(exitSchemaHash?{exitSchemaHash}:{})};
    const wasVerified=record?.stage==='verified';
    if(!record){record={version:1,key:input.key,kind,intentHash,schemaHash,...(exitSchemaHash?{exitSchemaHash}:{}),context:{clientId:input.clientId,providerId:context.providerId,type:context.type,entryDate:context.entryDate},assessmentCode:code,...(yesNoWrites==='standard'?{yesNoWrites}:{}),stage:'pending',steps:{},rows:{},ends:plan.ends};records.push(record);}
@@ -229,8 +277,11 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    };
    const findEnrollment=async()=>{
     const knownId=record.enrollmentId??record.steps.enrollment?.value??entry?.enrollmentId;
-    if(internal.findEnrollment)return internal.findEnrollment({knownId,context});
-    const list=await enrollments(api,input.clientId),found=list.filter(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&restDate(e.projectStartDate)===restDate(context.entryDate)&&e.isActive!==false);
+    if(internal.findEnrollment)return internal.findEnrollment({knownId,context,writeAttempted:Object.keys(record.steps).length>0});
+    if(standaloneExit){await inspectStandaloneExit();return {found:true,value:entry.enrollmentId};}
+    const list=await enrollments(api,input.clientId,{enrollmentSession,writeAttempted:Object.keys(record.steps).length>0}),matching=list.filter(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&restDate(e.projectStartDate)===restDate(context.entryDate)&&e.isActive!==false);
+    const open=matching.filter(e=>e.projectExitDate==null);if(open.length>1)fail('duplicate matching enrollments');
+    const found=knownId?matching.filter(e=>e.enrollmentId===knownId):open;
     if(found.length>1)fail('duplicate matching enrollments');
     const id=record.enrollmentId??record.steps.enrollment?.value??entry?.enrollmentId;if(id&&(!found[0]||found[0].enrollmentId!==id))fail('saved enrollment missing or changed');
     return {found:found.length===1,value:found[0]?.enrollmentId};
@@ -244,9 +295,8 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     const matches=review.snapshot.reviews.filter(r=>r.type==='Update'&&restDate(r.reviewDate)===restDate(at)&&r.clientIds.includes(input.clientId));if(matches.length!==1||record.reviewId&&record.reviewId!==matches[0].reviewId)fail('interim did not verify');record.reviewId=matches[0].reviewId;await persist();
    }
    if(kind==='exit'){
-    if(typeof internal.readExit!=='function')fail('household exit verification required');
-    const exit=await internal.readExit({clientId:input.clientId,enrollmentId:record.enrollmentId});
-    if(record.exitSubgroupId&&record.exitSubgroupId!==exit.exitSubgroupId)fail('exit identity changed');
+    const exit=standaloneExit?await step('exit',inspectStandaloneExit,()=>exitUi.saveExit(exitInput)):await internal.readExit({clientId:input.clientId,enrollmentId:record.enrollmentId});
+    if(Object.hasOwn(record,'exitSubgroupId')&&record.exitSubgroupId!==exit.exitSubgroupId)fail('exit identity changed');
     record.projectExitDate=exit.projectExitDate;record.exitSubgroupId=exit.exitSubgroupId;await persist();
    }
    for(const end of plan.ends){
@@ -270,12 +320,12 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     },()=>api.subassessments.setEndDate({clientId:input.clientId,assessmentCode:code,effectiveDate:at,parentField:end.parentField,recordsetId:end.recordsetId,endDateField:end.endDateField,endDate:end.endDate}));
    }
    if(plan.scalar.length)await step('scalars',async()=>{
-    const source=await read();return {found:plan.scalar.every(q=>{const r=source.find(r=>r.virt_field_name===q.virt_field_name);return r&&sameAnswer(q,r.answer_value)&&restDate(r.date_effective)===restDate(at);}),value:plan.scalar.map(q=>q.virt_field_name)};
+    const source=kind==='entry'&&record.correctedScalars?await readSaved():await read();return {found:plan.scalar.every(original=>{const q=kind==='entry'?record.correctedScalars?.[original.virt_field_name]??original:original,r=source.find(r=>r.virt_field_name===q.virt_field_name);return r&&sameAnswer(q,r.answer_value)&&(q.answer_value===''||restDate(r.date_effective)===restDate(at));}),value:plan.scalar.map(q=>q.virt_field_name)};
    },()=>api.assessmentsMobile.addAnswer({path:{clientId:input.clientId,assessmentCode:code},query:{dateEffective:at},body:plan.scalar}));
    // Standard writes update existing dated rows and change only the answers sent.
    if(plan.yesNo.length){const body=[...plan.yesNo,...mandatory.map(({expected,...q})=>q)],expected=[...plan.yesNo,...mandatory.map(({expected,...q})=>({...q,answer_value:expected}))];
     await step('yesno',async()=>{
-     const source=await readSaved();return {found:expected.every(q=>{const r=source.find(r=>r.virt_field_name===q.virt_field_name);return r&&sameAnswer(q,r.answer_value)&&restDate(r.date_effective)===restDate(at);}),value:plan.yesNo.map(q=>q.virt_field_name)};
+     const source=await readSaved();return {found:expected.every(original=>{const q=kind==='entry'?record.correctedScalars?.[original.virt_field_name]??original:original,r=source.find(r=>r.virt_field_name===q.virt_field_name);return r&&sameAnswer(q,r.answer_value)&&(q.answer_value===''||restDate(r.date_effective)===restDate(at));}),value:plan.yesNo.map(q=>q.virt_field_name)};
     },()=>api.assessments.create({path:{clientId:input.clientId,assessmentCode:code},query:{dateEffective:at},body}));
    }
    // Group rows into one creation request. Partial success blocks resubmission until all rows reconcile.
@@ -284,8 +334,8 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     for(const row of plan.rows){
      const parent=source.find(q=>q.virt_field_name===row.parentField);if(!Array.isArray(parent?.sub_assessment_answer_list))fail('subassessment read missing');
      const known=record.steps.rows?.value?.[row.key];
-     const expected=row.encoded.map(q=>{const overrides=records.flatMap(r=>(r.ends??[]).filter(e=>e.recordsetId===known&&r.steps['end:'+e.recordsetId]?.state==='verified'&&e.endDateField===q.virt_field_name));if(overrides.length>1)fail('multiple end-date overrides');return overrides.length?{...q,answer_value:overrides[0].endDate}:q;});
-     const candidates=parent.sub_assessment_answer_list.filter(r=>(!known||r.recordset_id===known)&&expected.every(q=>{const fields=r.sub_assessment_list?.filter(c=>c.virt_field_name===q.virt_field_name)??[];return fields.length===1&&fields[0].question_type===q.question_type&&sameAnswer(q,fields[0].answer_value);}));
+     const expected=row.encoded.map(original=>{const q=kind==='entry'?record.correctedRows?.[row.parentField]?.[known]?.[original.virt_field_name]??original:original;const overrides=records.flatMap(r=>(r.ends??[]).filter(e=>e.recordsetId===known&&r.steps['end:'+e.recordsetId]?.state==='verified'&&e.endDateField===q.virt_field_name));if(overrides.length>1)fail('multiple end-date overrides');return overrides.length?{...q,answer_value:overrides[0].endDate}:q;});
+     const candidates=parent.sub_assessment_answer_list.filter(r=>(!known||r.recordset_id===known)&&expected.every(q=>{const fields=r.sub_assessment_list?.filter(c=>c.virt_field_name===q.virt_field_name)??[];return fields.length===0&&q.answer_value===''&&record.correctedRows?.[row.parentField]?.[known]?.[q.virt_field_name]||fields.length===1&&fields[0].question_type===q.question_type&&sameAnswer(q,fields[0].answer_value);}));
      if(candidates.length>1)fail('duplicate matching subassessment rows');if(candidates.length){if(!positive(candidates[0].recordset_id)||matchedIds.has(candidates[0].recordset_id))fail('invalid or reused subassessment ID');matchedIds.add(candidates[0].recordset_id);matched[row.key]=candidates[0].recordset_id;}else missing.push(row);
     }
     return {found:missing.length===0,value:matched,missing};
@@ -313,6 +363,82 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
  const householdScope=headClientId=>JSON.stringify([tenantScope,'household-enrollment-workflow',headClientId]);
  const memberKey=(key,clientId)=>'household:'+hash({key,clientId});
  const withClients=(ids,work,index=0)=>index===ids.length?work():store.withLock(scope(ids[index]),()=>withClients(ids,work,index+1));
+ const adopt=async(household,raw)=>{
+  fields(raw,household?['key','householdId','headClientId','members']:['key','clientId','enrollmentId']);
+  const input=structuredClone(raw);key(input.key);
+  if(typeof enrollmentSession?.readEnrollment!=='function')fail('authoritative enrollment session required for adoption');
+  const targets=household?input.members:[{clientId:input.clientId,enrollmentId:input.enrollmentId}];
+  if(!Array.isArray(targets)||!targets.length)fail('explicit enrollment targets required');
+  for(const target of targets){fields(target,['clientId','enrollmentId']);if(!positive(target.clientId)||!positive(target.enrollmentId))fail('explicit enrollment targets required');}
+  targets.sort((a,b)=>a.clientId-b.clientId);const ids=targets.map(t=>t.clientId);
+  if(new Set(ids).size!==ids.length||new Set(targets.map(t=>t.enrollmentId)).size!==targets.length)fail('duplicate adoption targets');
+  if(household&&(!positive(input.householdId)||!positive(input.headClientId)||!ids.includes(input.headClientId)||typeof api.households?.get!=='function'))fail('household, original head and complete enrollment cohort required');
+  const owner=hash({adoption:true,input}),intentHash=hash(input);
+  return withClients(ids,async()=>{
+   const locked=household?work=>store.withLock(householdScope(input.headClientId),work):work=>work();
+   return locked(async()=>{
+    const groups=household?await store.read(householdScope(input.headClientId)):[];
+    if(!Array.isArray(groups)||groups.some(r=>r.stage!=='verified'&&r.key!==input.key))fail('another unfinished household workflow must be reconciled first');
+    const groupMatches=groups.filter(r=>r.key===input.key);if(groupMatches.length>1)fail('duplicate household journal keys');let group=groupMatches[0];
+    if(group&&(!group.adopted||group.intentHash!==intentHash))fail('adoption key conflicts with previous intent');
+    const journals=new Map(),prior=new Map();
+    for(const target of targets){
+     const reservations=await store.withLock(reservationScope(target.clientId),()=>store.read(reservationScope(target.clientId)));
+     if(!Array.isArray(reservations)||reservations.some(r=>r.stage!=='verified'&&r.owner!==owner))fail('unfinished household workflow must be reconciled first');
+     const records=await store.read(scope(target.clientId)),member=household?memberKey(input.key,target.clientId):input.key;
+     if(!Array.isArray(records)||records.some(r=>r.version!==1||!object(r.steps)))fail('invalid workflow journal');
+     if(records.some(r=>r.stage!=='verified'&&r.key!==member))fail('another unfinished workflow must be reconciled first');
+     if(records.some(r=>r.kind==='entry'&&r.enrollmentId===target.enrollmentId&&r.key!==member))fail('enrollment already journaled; use its existing entry key');
+     const matches=records.filter(r=>r.key===member);if(matches.length>1)fail('duplicate journal keys');
+     if(matches[0]&&(!matches[0].adopted||matches[0].intentHash!==intentHash))fail('adoption key conflicts with previous intent');
+     journals.set(target.clientId,records);prior.set(target.clientId,matches[0]);
+    }
+    const snapshots=[];
+    for(const target of targets){
+     const s=await enrollmentSession.readEnrollment(target);
+     if(s?.source!=='gwt-rpc'||s.tenant!==api.tenant||s.clientId!==target.clientId||s.enrollmentId!==target.enrollmentId||!positive(s.providerId)||!entryExitTypes.includes(s.enrollmentType)||!Number.isFinite(restDate(s.projectStartDate)))fail('adoption enrollment context mismatch');
+     if(!Array.isArray(s.members)||canonical([...s.members].sort((a,b)=>a.clientId-b.clientId))!==canonical(targets))fail(household?'adoption requires the complete linked enrollment cohort':'linked household enrollment requires adoptHouseholdEnrollment');
+     const exits=s.exits?.filter(e=>e.clientId===target.clientId&&e.enrollmentId===target.enrollmentId);
+     if(exits?.length!==1||exits[0].projectExitDate!==null&&!Number.isFinite(restDate(exits[0].projectExitDate)))fail('authoritative adoption exit date required');
+     const start=restDate(s.projectStartDate),end=exits[0].projectExitDate===null?Infinity:restDate(exits[0].projectExitDate);if(end<start)fail('adoption exit precedes entry');
+     snapshots.push({target,s,start,end});
+    }
+    const head=snapshots.find(r=>r.target.clientId===(household?input.headClientId:input.clientId));
+    if(snapshots.some(r=>r.s.providerId!==head.s.providerId||r.s.enrollmentType!==head.s.enrollmentType||r.start<head.start||r.end>head.end))fail('invalid enrollment data: adopted members require matching program and head coverage');
+    if(household){
+     const found=toItems(await api.households.get({path:{householdId:input.householdId}}));
+     if(found.length!==1||found[0].householdId!==input.householdId||found[0].isActive===false||!Array.isArray(found[0].clients))fail('active household required for adoption');
+     const members=found[0].clients,heads=members.filter(m=>m.headofhouseholdStatus&&m.isActive!==false&&!m.dateLeft);
+     if(heads.length!==1||heads[0].clientId!==input.headClientId)fail('adoption household head mismatch');
+     for(const r of snapshots){const membersForClient=members.filter(m=>m.clientId===r.target.clientId);if(membersForClient.length!==1||membersForClient[0].isActive===false||membersForClient[0].dateLeft||!Number.isFinite(restDate(membersForClient[0].dateJoined))||restDate(membersForClient[0].dateJoined)>r.start||!Array.isArray(r.s.householdClientIds)||ids.some(id=>!r.s.householdClientIds.includes(id)))fail('adoption household membership mismatch');}
+    }
+    const prepared=[];
+    for(const r of snapshots){
+     const context={clientId:r.target.clientId,providerId:r.s.providerId,type:r.s.enrollmentType,entryDate:new Date(r.start).toISOString()};
+     const discovered=await discover(context),schemaHash=hash({providerId:discovered.provider.providerId,entry:{assessment:discovered.entry.assessment,questions:discovered.entry.definition.questions},interim:{assessment:discovered.interim.assessment,questions:discovered.interim.definition.questions}});
+     const headQuestion=discovered.entry.definition.questions.find(q=>q.fieldName==='HUD_RELATIONTOHOH');
+     if(headQuestion){
+      const self=headQuestion.options.filter(o=>o.code==='RELATIONHOH_SELF'),answers=questions(await api.assessments.get({path:{clientId:r.target.clientId,assessmentCode:discovered.entry.assessment.code},query:{dateEffective:context.entryDate}}));
+      const answer=answers.find(q=>q.virt_field_name==='HUD_RELATIONTOHOH')?.answer_value;
+      if(self.length!==1||answer===null||answer===undefined||answer===''||(String(answer)===String(self[0].id))!==(r.target.clientId===head.target.clientId))fail('adoption requires the original enrollment head relationship');
+     }
+     const existing=prior.get(r.target.clientId);
+     if(existing&&(existing.enrollmentId!==r.target.enrollmentId||canonical(existing.context)!==canonical(context)||existing.schemaHash!==schemaHash))fail('adopted enrollment identity or configuration changed');
+     prepared.push(existing??{version:1,key:household?memberKey(input.key,r.target.clientId):input.key,kind:'entry',adopted:true,intentHash,schemaHash,context,enrollmentId:r.target.enrollmentId,assessmentCode:discovered.entry.assessment.code,stage:'verified',steps:{enrollment:{state:'verified',value:r.target.enrollmentId}},rows:{},ends:[]});
+    }
+    const wasVerified=household?group?.stage==='verified':prior.get(input.clientId)?.stage==='verified';
+    const results=prepared.map(r=>({key:r.key,outcome:wasVerified?'already-present':'verified',clientId:r.context.clientId,enrollmentId:r.enrollmentId,assessmentCode:r.assessmentCode,effectiveDate:r.context.entryDate,recordsetIds:structuredClone(r.rows)}));
+    if(household){
+     if(!group){group={version:1,key:input.key,kind:'entry',adopted:true,intentHash,context:{householdId:input.householdId,headClientId:input.headClientId,providerId:head.s.providerId,type:head.s.enrollmentType,entryDate:new Date(head.start).toISOString()},clientIds:ids,stage:'pending',members:{},attached:true};groups.push(group);}
+     await store.write(householdScope(input.headClientId),structuredClone(groups));
+     for(const clientId of ids)await store.withLock(reservationScope(clientId),()=>store.write(reservationScope(clientId),[{owner,stage:'pending'}]));
+    }
+    for(const r of prepared){if(!prior.get(r.context.clientId))journals.get(r.context.clientId).push(r);await store.write(scope(r.context.clientId),structuredClone(journals.get(r.context.clientId)));}
+    if(household){group.members=Object.fromEntries(results.map(r=>[r.clientId,r]));group.stage='verified';await store.write(householdScope(input.headClientId),structuredClone(groups));for(const clientId of ids)await store.withLock(reservationScope(clientId),()=>store.write(reservationScope(clientId),[{owner,stage:'verified'}]));return {key:input.key,outcome:wasVerified?'already-present':'verified',householdId:input.householdId,headClientId:input.headClientId,members:results};}
+    return results[0];
+   });
+  });
+ };
  const householdRun=async(kind,raw)=>{
   if(typeof enrollmentSession?.readEnrollment!=='function'||typeof helpers.addHouseholdMembers!=='function'||typeof api.households?.get!=='function')fail('household API and authoritative enrollment session required');
   fields(raw,kind==='addition'?['key','enrollmentKey','headClientId','entryDate','members']:kind==='entry'?['key','householdId','headClientId','providerId','type','entryDate','members']:['key','enrollmentKey','headClientId',kind==='exit'?'exitDate':'reviewDate','members',...(kind==='exit'?['destination','reasonForLeaving','destinationDetails','reasonForLeavingOther']:[])]);
@@ -344,7 +470,7 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    const base=entry??record;
    const catalog={};
    for(const group of [base,...records.filter(r=>r.kind==='addition'&&r.stage==='verified'&&r.enrollmentKey===(entry?.key??input.key))].filter(Boolean)){
-    for(const clientId of group.clientIds){if(catalog[clientId])fail('duplicate household member enrollment');catalog[clientId]={...group.members[clientId],entryDate:group.context.entryDate,entryKey:group.key};}
+    for(const clientId of group.clientIds){if(catalog[clientId])fail('duplicate household member enrollment');catalog[clientId]={...group.members[clientId],entryDate:group.members[clientId]?.effectiveDate??group.context.entryDate,entryKey:group.key};}
    }
    if(kind==='addition'){
     if(typeof memberEntryDatePort?.validateMemberEntryDate!=='function'||typeof memberEntryDatePort?.saveMemberEntryDate!=='function')fail('member entry date port required');
@@ -404,11 +530,21 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    if(!record){record={version:1,key:input.key,kind,intentHash,context,...(input.enrollmentKey?{enrollmentKey:input.enrollmentKey}:{}),clientIds:ids,stage:'pending',members:{},...(kind==='exit'?{exitSchemas:preflight}:kind==='addition'?{entrySchemas:preflight}:{})};records.push(record);}
    const persist=()=>store.write(householdScope(input.headClientId),structuredClone(records));await persist();
    for(const clientId of cohortIds)await store.withLock(reservationScope(clientId),()=>store.write(reservationScope(clientId),[{owner,stage:'pending'}]));
-   const findMember=clientId=>async({knownId})=>{
+   const writeAttempted=async()=>{
+    if(Object.keys(record.members).length>0||record.attachmentAttempted===true)return true;
+    // The head's creation can commit before its result reaches the household journal.
+    // Its per-client attempt marker remains authoritative on the next household retry.
+    for(const clientId of ids){
+     const entries=await store.read(scope(clientId));if(!Array.isArray(entries))fail('invalid workflow journal');
+     if(entries.some(r=>r.key===memberKey(input.key,clientId)&&r.steps&&Object.keys(r.steps).length>0))return true;
+    }
+    return false;
+   };
+   const findMember=clientId=>async({knownId,writeAttempted:memberWriteAttempted=false})=>{
     const expected=record.members[clientId]?.enrollmentId??catalog[clientId]?.enrollmentId??knownId;
     if(expected){if(knownId&&knownId!==expected)fail('household enrollment identity changed');await readTarget({clientId,enrollmentId:expected},{partial:kind==='entry'&&clientId===input.headClientId&&!record.attached});return {found:true,value:expected};}
     if(clientId!==input.headClientId)fail('member enrollment has not been attached');
-    const found=(await enrollments(api,clientId)).filter(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&e.isActive&&restDate(e.projectStartDate)===restDate(context.entryDate));
+    const found=(await enrollments(api,clientId,{enrollmentSession,writeAttempted:memberWriteAttempted||await writeAttempted()})).filter(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&e.isActive&&e.projectExitDate==null&&restDate(e.projectStartDate)===restDate(context.entryDate));
     if(found.length>1)fail('duplicate matching enrollments');
     if(found[0])await readTarget({clientId,enrollmentId:found[0].enrollmentId},{partial:!record.attached});
     return {found:found.length===1,value:found[0]?.enrollmentId};
@@ -432,7 +568,7 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     // Before attachment, an independently matching member enrollment is ambiguous.
     // Once any attachment was attempted, only the GWT journal can reconcile it.
     if(!record.attachmentAttempted)for(const clientId of ids.filter(id=>id!==input.headClientId)){
-     const existing=await enrollments(api,clientId);if(existing.some(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&e.isActive&&restDate(e.projectStartDate)===restDate(context.entryDate)))fail('member already has an independent matching enrollment');
+     const existing=await enrollments(api,clientId,{enrollmentSession,writeAttempted:await writeAttempted()});if(existing.some(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&e.isActive&&e.projectExitDate==null&&restDate(e.projectStartDate)===restDate(context.entryDate)))fail('member already has an independent matching enrollment');
     }
     const head=input.members.find(m=>m.clientId===input.headClientId);
     const result=await run('entry',toMember(head),{locked:true,owner,headClientId:input.headClientId,findEnrollment:findMember(head.clientId)});record.members[head.clientId]=result;await persist();
@@ -453,7 +589,7 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
      if(!record.anchor)fail('open household enrollment required to add a member');await persist();
     }
     if(!record.attachmentAttempted)for(const clientId of ids){
-     const existing=await enrollments(api,clientId);if(existing.some(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&e.isActive))fail('additional member already has an independent enrollment');
+     const existing=await enrollments(api,clientId,{enrollmentSession,writeAttempted:await writeAttempted()});if(existing.some(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&e.isActive&&e.projectExitDate==null))fail('additional member already has an independent enrollment');
     }
     record.attachmentAttempted=true;await persist();
     const attached=await helpers.addHouseholdMembers({...record.anchor,memberClientIds:ids});
@@ -553,6 +689,8 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
   }));
  };
  return {
+  correctEntry,
+  adoptEnrollment:input=>adopt(false,input),adoptHouseholdEnrollment:input=>adopt(true,input),
   addHouseholdMembers:input=>householdRun('addition',input),
   createHouseholdEnrollment:input=>householdRun('entry',input),createHouseholdInterim:input=>householdRun('interim',input),exitHousehold:input=>householdRun('exit',input),
   discoverExit:input=>discover(input,true),
@@ -565,7 +703,7 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     return {key:record.key,kind:record.kind,stage:record.stage,householdId:record.context.householdId,headClientId:input.headClientId,members:record.clientIds.map(clientId=>({clientId,key:memberKey(input.key,clientId),...structuredClone(record.members[clientId]??{})}))};
    });
   },
-  discover,createEnrollment:input=>run('entry',input),createInterim:input=>run('interim',input),
+  discover,createEnrollment:input=>run('entry',input),createInterim:input=>run('interim',input),exitEnrollment:input=>run('exit',input,{standaloneExit:true}),
   async getStatus(input){
    fields(input,['clientId','key']);if(!positive(input.clientId))fail('client ID required');key(input.key);
    return store.withLock(scope(input.clientId),async()=>{

package/browser/entry-correction.mjs

@@ -0,0 +1,164 @@
+import {createHash} from 'node:crypto';
+import {encodeAnswers,parseRestInstant,toItems} from '../dist/esm/index.js';
+
+const object=v=>v!==null&&typeof v==='object'&&!Array.isArray(v);
+const canonical=v=>JSON.stringify(v,(_,x)=>object(x)?Object.fromEntries(Object.keys(x).sort().map(k=>[k,x[k]])):x);
+const hash=v=>createHash('sha256').update(canonical(v)).digest('hex');
+const positive=v=>Number.isSafeInteger(v)&&v>0;
+const scalarTypes=new Set(['lookup','yes_no','date','int','money','textbox','textarea']);
+
+/** Internal correction writer. The workflow supplies its existing client locks and journal scopes. */
+export function createEntryCorrector({api,store,enrollmentSession,writeLabel,discover,scope,reservationScope,makeError}){
+ const fail=reason=>{throw makeError(reason);};
+ const fields=(v,allowed)=>{if(!object(v)||Object.keys(v).some(k=>!allowed.includes(k)))fail('unknown or invalid correction fields');};
+ const key=v=>{if(typeof v!=='string'||!v.trim()||v.length>200)fail('stable correction key required');};
+ const value=(type,v)=>{
+  if(v===null||v===undefined||v==='')return null;
+  if(type==='date'){const n=parseRestInstant(v);if(!Number.isFinite(n))fail('invalid stored correction date');return n;}
+  if(type==='int'||type==='money'){const n=Number(v);if(!Number.isFinite(n))fail('invalid stored correction number');return n;}
+  return String(v);
+ };
+ const encode=(questions,answers,clear,endpoint)=>{
+  if(!object(answers)||!Array.isArray(clear)||new Set(clear).size!==clear.length||clear.some(f=>typeof f!=='string'||Object.hasOwn(answers,f)))fail('invalid or conflicting correction answers and clears');
+  const index=new Map(questions.map(q=>[q.fieldName,q]));
+  for(const field of [...Object.keys(answers),...clear]){
+   const q=index.get(field);
+   if(!q||!scalarTypes.has(q.questionType)||endpoint==='mobile'&&q.questionType==='yes_no')fail('unsupported correction field type');
+   if(['SVPPROFDOB','HUD_RELATIONTOHOH'].includes(field))fail('DOB and household head corrections require their dedicated workflows');
+  }
+  const body=encodeAnswers(questions,answers,{endpoint,writeLabel});
+  if(body.length!==Object.keys(answers).length)fail('correction answer could not be encoded');
+  for(const q of body)if(q.question_type==='date'&&q.answer_value){const day=q.answer_value.slice(0,10);if(!Number.isFinite(parseRestInstant(q.answer_value))||!/^\d{4}-\d{2}-\d{2}$/.test(day)||new Date(day+'T00:00:00Z').toISOString().slice(0,10)!==day)fail('invalid correction date');}
+  for(const field of clear){const q=index.get(field);body.push({question_id:q.questionId,question_type:q.questionType,virt_field_name:field,answer_value:''});}
+  return body;
+ };
+ const expected=(questions,body,answers)=>body.map(q=>{
+  if(q.question_type!=='lookup'||q.answer_value==='')return q;
+  const encoded=encodeAnswers(questions,{[q.virt_field_name]:answers[q.virt_field_name]},{endpoint:'mobile'});
+  if(encoded.length!==1)fail('correction lookup could not be resolved');return encoded[0];
+ });
+ const readQuestions=async(clientId,assessmentCode,at)=>{
+  const rows=toItems(await api.assessments.get({path:{clientId,assessmentCode},query:{dateEffective:at}}));
+  if(rows.some(q=>!object(q)||typeof q.virt_field_name!=='string')||new Set(rows.map(q=>q.virt_field_name)).size!==rows.length)fail('ambiguous correction assessment read');
+  return rows;
+ };
+ return async raw=>{
+  fields(raw,['key','enrollmentKey','clientId','answers','clear','subassessments']);
+  const input=structuredClone(raw);key(input.key);key(input.enrollmentKey);
+  if(!positive(input.clientId)||!Array.isArray(input.subassessments??[]))fail('invalid correction client or rows');
+  if(typeof api.assessments?.create!=='function'||typeof enrollmentSession?.readEnrollment!=='function')fail('standard assessment writes and authoritative enrollment reader required for corrections');
+  return store.withLock(scope(input.clientId),async()=>{
+   const reservations=await store.withLock(reservationScope(input.clientId),()=>store.read(reservationScope(input.clientId)));
+   if(!Array.isArray(reservations)||reservations.some(r=>r.stage!=='verified'))fail('unfinished household workflow must be reconciled first');
+   const records=await store.read(scope(input.clientId));
+   if(!Array.isArray(records)||records.some(r=>!object(r)||r.version!==1||!object(r.steps)))fail('invalid workflow journal');
+   if(records.some(r=>r.stage!=='verified'&&r.key!==input.key))fail('another unfinished workflow must be reconciled first');
+   const entries=records.filter(r=>r.kind==='entry'&&r.key===input.enrollmentKey&&r.stage==='verified');
+   if(entries.length!==1)fail('verified enrollment workflow required');const entry=entries[0];
+   const matches=records.filter(r=>r.key===input.key);if(matches.length>1)fail('duplicate correction journal keys');let record=matches[0];
+   const intentHash=hash(input);if(record&&(record.kind!=='correction'||record.intentHash!==intentHash))fail('correction key conflicts with previous intent');
+   if(!record&&records.some(r=>r.enrollmentId===entry.enrollmentId&&!['entry','correction'].includes(r.kind)))fail('entry correction must precede interim or exit workflows');
+   const {providerId,type,entryDate}=entry.context,at=new Date(parseRestInstant(entryDate)).toISOString(),readAt=new Date(parseRestInstant(at)+1000).toISOString();
+   const target={clientId:input.clientId,enrollmentId:entry.enrollmentId};
+   const verifyEnrollment=async()=>{
+    const s=await enrollmentSession.readEnrollment(target);
+    if(s?.source!=='gwt-rpc'||s.tenant!==api.tenant||s.clientId!==target.clientId||s.enrollmentId!==target.enrollmentId||s.providerId!==providerId||s.enrollmentType!==type||parseRestInstant(s.projectStartDate)!==parseRestInstant(at)||!Array.isArray(s.members)||s.members.filter(m=>m.clientId===target.clientId&&m.enrollmentId===target.enrollmentId).length!==1)fail('entry correction enrollment context mismatch');
+    const exits=s.exits?.filter(e=>e.clientId===target.clientId&&e.enrollmentId===target.enrollmentId);
+    if(exits?.length!==1||exits[0].projectExitDate!==null||!Array.isArray(s.reviews)||s.reviews.length)fail('entry correction requires an open enrollment without reviews');
+   };
+   await verifyEnrollment();
+   const discovered=await discover({clientId:input.clientId,providerId,type,entryDate:at});
+   const schemaHash=hash({providerId:discovered.provider.providerId,entry:{assessment:discovered.entry.assessment,questions:discovered.entry.definition.questions},interim:{assessment:discovered.interim.assessment,questions:discovered.interim.definition.questions}});
+   if(schemaHash!==entry.schemaHash||record&&schemaHash!==record.schemaHash)fail('program assessment configuration changed');
+   const definition=discovered.entry.definition,code=definition.assessmentCode;
+   const snapshot=async()=>{
+    const raw=await readQuestions(input.clientId,code,readAt),current=await readQuestions(input.clientId,code,new Date(Math.max(Date.now(),parseRestInstant(readAt))).toISOString());
+    const scalars={},rows={};
+    for(const q of definition.questions){
+     if(['blank','label'].includes(q.questionType))continue;
+     if(q.questionType!=='sub_assessment'){
+      const actual=raw.find(r=>r.virt_field_name===q.fieldName);if(!actual)fail('correction scalar read missing');
+      const date=actual.date_effective?parseRestInstant(actual.date_effective):null;if(date!==null&&!Number.isFinite(date))fail('invalid correction effective date');
+      scalars[q.fieldName]={type:q.questionType,value:value(q.questionType,actual.answer_value),date};
+      continue;
+     }
+     const parent=current.find(r=>r.virt_field_name===q.fieldName);if(!parent||!Array.isArray(parent.sub_assessment_answer_list??[]))fail('correction subassessment read missing');
+     rows[q.fieldName]={};
+     for(const row of parent.sub_assessment_answer_list??[]){
+      if(!positive(row.recordset_id)||Object.hasOwn(rows[q.fieldName],row.recordset_id)||!Array.isArray(row.sub_assessment_list))fail('ambiguous correction row');
+      const cells={};
+      for(const child of q.children){
+       if(['label','blank'].includes(child.questionType))continue;
+       const found=row.sub_assessment_list.filter(c=>c.virt_field_name===child.fieldName);if(found.length>1||found[0]&&found[0].question_type!==child.questionType)fail('ambiguous correction row cell');
+       cells[child.fieldName]={type:child.questionType,value:value(child.questionType,found[0]?.answer_value)};
+      }
+      if(row.sub_assessment_list.some(c=>!q.children.some(child=>child.fieldName===c.virt_field_name)))fail('correction row metadata incomplete');
+      rows[q.fieldName][row.recordset_id]=cells;
+     }
+    }
+    return {raw,scalars,rows};
+   };
+   const observed=await snapshot();
+   const readOverrides=state=>{
+    for(const q of Object.values(entry.correctedScalars??{})){
+     const actual=state.scalars[q.virt_field_name];if(!actual||actual.value!==value(q.question_type,q.answer_value)||actual.value!==null&&actual.date!==parseRestInstant(at))fail('verified entry correction changed');
+    }
+    for(const [parent,group]of Object.entries(entry.correctedRows??{}))for(const [id,cells]of Object.entries(group))for(const q of Object.values(cells))if(state.rows[parent]?.[id]?.[q.virt_field_name]?.value!==value(q.question_type,q.answer_value))fail('verified row correction changed');
+   };
+   const result=outcome=>({key:input.key,enrollmentKey:input.enrollmentKey,outcome,clientId:input.clientId,enrollmentId:entry.enrollmentId,assessmentCode:code,effectiveDate:at,recordsetIds:structuredClone(entry.rows)});
+   if(record?.stage==='verified'){readOverrides(observed);return result('already-present');}
+   if(!record){
+    readOverrides(observed);
+    const answers=input.answers??{},clear=input.clear??[];
+    const scalarBody=encode(definition.questions,answers,clear,'standalone'),scalarExpected=expected(definition.questions,scalarBody,answers);
+    // The standard endpoint requires every mandatory scalar, even if this patch leaves it unchanged.
+    if(scalarBody.length)for(const q of definition.questions.filter(q=>q.mandatory&&!['label','blank','sub_assessment'].includes(q.questionType)&&!scalarBody.some(c=>c.virt_field_name===q.fieldName))){
+     if(q.fieldName==='SVPPROFDOB'||!scalarTypes.has(q.questionType))fail('unsupported mandatory correction field');
+     const prior=observed.raw.find(r=>r.virt_field_name===q.fieldName);
+     if(prior?.answer_value===null||prior?.answer_value===undefined||prior?.answer_value==='')fail('mandatory correction field requires an explicit answer or clear');
+     let body;
+     if(q.questionType==='lookup'){
+      const options=q.options.filter(o=>String(o.id)===String(prior.answer_value)),label=options.length===1?writeLabel?.(q,options[0]):undefined;
+      if(!label)fail('mandatory correction lookup label unavailable');
+      body=[{question_id:q.questionId,question_type:q.questionType,virt_field_name:q.fieldName,answer_value:label}];
+     }else body=encodeAnswers([q],{[q.fieldName]:{value:prior.answer_value}},{endpoint:'standalone',writeLabel});
+     if(body.length!==1)fail('mandatory correction field could not be encoded');scalarBody.push(body[0]);
+     scalarExpected.push({...body[0],answer_value:prior.answer_value});
+    }
+    const rowPlans=[],ids=new Set();
+    for(const patch of input.subassessments??[]){
+     fields(patch,['key','parentField','answers','clear']);key(patch.key);
+     const id=entry.rows[patch.key],parent=definition.questions.find(q=>q.fieldName===patch.parentField&&q.questionType==='sub_assessment');
+     if(!positive(id)||ids.has(id)||!parent||!observed.rows[parent.fieldName]?.[id])fail('correction requires an existing entry row key and matching parent');ids.add(id);
+     const cells=encode(parent.children,patch.answers??{},patch.clear??[],'mobile');if(!cells.length)fail('empty row correction');
+     rowPlans.push({id,parentField:parent.fieldName,questionId:parent.questionId,cells});
+    }
+    if(!scalarBody.length&&!rowPlans.length)fail('empty entry correction');
+    record={version:1,key:input.key,kind:'correction',enrollmentKey:input.enrollmentKey,intentHash,schemaHash,context:structuredClone(entry.context),enrollmentId:entry.enrollmentId,assessmentCode:code,stage:'pending',steps:{},rows:structuredClone(entry.rows),before:{scalars:observed.scalars,rows:observed.rows},scalarBody,scalarExpected,rowPlans};records.push(record);
+   }
+   const persist=()=>store.write(scope(input.clientId),structuredClone(records));await persist();
+   const inspect=async(candidate,complete=false)=>{
+    const state=await snapshot(),want=structuredClone(record.before);
+    if(complete||candidate==='scalars'||record.steps.scalars?.state==='verified')for(const q of record.scalarExpected)want.scalars[q.virt_field_name]={type:q.question_type,value:value(q.question_type,q.answer_value),date:parseRestInstant(at)};
+    for(const plan of record.rowPlans)if(complete||candidate==='row:'+plan.id||record.steps['row:'+plan.id]?.state==='verified')for(const q of plan.cells)want.rows[plan.parentField][plan.id][q.virt_field_name]={type:q.question_type,value:value(q.question_type,q.answer_value)};
+    const scalarsMatch=Object.keys(state.scalars).length===Object.keys(want.scalars).length&&Object.entries(want.scalars).every(([field,e])=>{const a=state.scalars[field];return a&&a.type===e.type&&a.value===e.value&&(e.value===null||a.date===e.date);});
+    return scalarsMatch&&canonical(state.rows)===canonical(want.rows);
+   };
+   const step=async(name,submit)=>{
+    if(await inspect(name)){record.steps[name]={state:'verified'};await persist();return;}
+    if(record.steps[name])throw makeError('uncertain entry correction requires reconciliation',{step:name});
+    if(!await inspect(null))fail('entry changed since correction preflight');
+    await verifyEnrollment();record.steps[name]={state:'attempted'};await persist();let cause;
+    try{await submit();}catch(e){cause=e;}
+    if(!await inspect(name))throw makeError('uncertain entry correction requires reconciliation',{step:name,cause});
+    record.steps[name]={state:'verified'};await persist();
+   };
+   if(record.scalarBody.length)await step('scalars',()=>api.assessments.create({path:{clientId:input.clientId,assessmentCode:code},query:{dateEffective:at},body:record.scalarBody}));
+   for(const plan of record.rowPlans)await step('row:'+plan.id,()=>api.assessmentsMobile.addAnswer({path:{clientId:input.clientId,assessmentCode:code},query:{dateEffective:at},body:[{question_id:plan.questionId,question_type:'sub_assessment',virt_field_name:plan.parentField,answer_value:'',subAssessmentQuestionAnswers:[{recordset_id:plan.id,isDeleted:false,subAssessments:plan.cells}]}]}));
+   if(!await inspect(null,true))fail('entry correction did not verify');await verifyEnrollment();
+   entry.correctedScalars??={};for(const q of record.scalarExpected)entry.correctedScalars[q.virt_field_name]=q;
+   entry.correctedRows??={};for(const plan of record.rowPlans){entry.correctedRows[plan.parentField]??={};entry.correctedRows[plan.parentField][plan.id]??={};for(const q of plan.cells)entry.correctedRows[plan.parentField][plan.id][q.virt_field_name]=q;}
+   record.stage='verified';await persist();return result('verified');
+  });
+ };
+}

package/browser/household-exit.d.mts

@@ -27,7 +27,7 @@ export interface HouseholdExitUi {
  /** Reopen the saved member exit and read the persisted conditional fields, then cancel. */
  readExitDetails(target:HouseholdExitTarget):Promise<HouseholdExitStoredDetails>;
  validateExit(input:HouseholdExitUiInput):Promise<void>;
- /** One save attempt only. Use through the durable exitHousehold workflow. */
+ /** One save attempt only. Use through the durable exitEnrollment or exitHousehold workflow. */
  saveExit(input:HouseholdExitUiInput):Promise<void>;
 }
 /** UI port with fresh conditional choices and per-member readback. */

package/browser/household-exit.mjs

@@ -5,7 +5,7 @@ import {expectedExitDetails,rentalDestination} from './exit-details.mjs';
 
 const label=value=>value.replace(/\s*\(HUD\)\s*$/,'').trim();
 const id=value=>Number.isSafeInteger(value)&&value>0;
-/** Low-level UI port. Use through exitHousehold, which journals before save.
+/** Low-level UI port. Use through exitEnrollment or exitHousehold, which journal before save.
  * This port makes at most one Save click and never retries an uncertain write. */
 export function createHouseholdExitUi({page}){
  const connection=pageConnection(page),base=connection.moduleBaseUrl;
@@ -80,7 +80,9 @@ export function createHouseholdExitUi({page}){
    if((await box.isChecked())!==desired.includes(clientId))throw Error('Exit household selection mismatch');
   }
   const selected=await page.locator('[id^="HouseholdsCheckboxTree.householdCheckbox."]:visible input:checked').evaluateAll(es=>es.map(e=>Number(e.parentElement.id.match(/\.client-(\d+)$/)?.[1])).sort((a,b)=>a-b));
-  if(JSON.stringify(selected)!==JSON.stringify(desired))throw Error('Exit household selection incomplete');
+  // A standalone person's form can bind the target without rendering a household tree.
+  const implicit=await boxes.count()===0&&snapshot.members.length===1&&snapshot.members[0].clientId===input.clientId&&snapshot.members[0].enrollmentId===input.enrollmentId&&desired.length===1&&desired[0]===input.clientId;
+  if(!implicit&&JSON.stringify(selected)!==JSON.stringify(desired))throw Error('Exit household selection incomplete');
   const parts=await page.evaluate(value=>{const d=new Date(value),local=new Date(d.getFullYear(),d.getMonth(),d.getDate(),d.getHours(),d.getMinutes(),d.getSeconds());if(+d!==+local)throw Error('Ambiguous local exit time');return {Month:String(d.getMonth()+1).padStart(2,'0'),Day:String(d.getDate()).padStart(2,'0'),Year:String(d.getFullYear()),Hour:String(d.getHours()%12||12),Minute:String(d.getMinutes()).padStart(2,'0'),Second:String(d.getSeconds()).padStart(2,'0'),'AM/PM':d.getHours()<12?'AM':'PM'};},input.exitDate);
   for(const [part,value]of Object.entries(parts)){const field=page.getByLabel(`Exit Date ${part}`,{exact:true});if(['Month','Day','Year'].includes(part))await field.fill(value);else await field.selectOption({label:value});if(await field.inputValue()!==value)throw Error('Exit date did not match');}
   for(const [field,name]of [['destination','Destination'],['reasonForLeaving','Reason for Leaving']])if(await page.getByLabel(name,{exact:true}).inputValue()!==chosen[field])throw Error('Exit choice did not match');

package/browser/index.d.mts

@@ -18,14 +18,27 @@ export class LoginError extends Error {
 export interface UiSession {readonly connection:UiConnection;browser: Browser;context: BrowserContext;page: Page;passwordRecovery:'restored-original'|'not-needed';ensureAuthenticated():Promise<void>;reauthenticate():Promise<void>;close():Promise<void>;}
 export interface PlaywrightGwtOptions {page:Page;tenant:string;moduleBaseUrl:string;}
 export interface PlaywrightEnrollmentSnapshot extends GwtEnrollmentSnapshot {providerId:number;enrollmentType:string;exits:readonly GwtEnrollmentExit[];}
+export interface EnrollmentListRow {
+ enrollmentId:number;clientId:number;enrollmentProvider:number;type:string;
+ projectStartDate:string;projectExitDate:string|null;isActive:boolean;
+}
+export interface EnrollmentListSnapshot {
+ source:'gwt-rpc';tenant:string;clientId:number;count:number;values:EnrollmentListRow[];
+}
 export interface EnrollmentReader {
   readonly connection?:UiConnection;
   readEnrollment(target:{clientId:number;enrollmentId:number}):Promise<PlaywrightEnrollmentSnapshot>;
+  /** Built-in sessions supply this complete, counted list, including exited entries.
+   * Legacy custom readers without it retain REST list behavior. */
+  listEnrollments?(target:{clientId:number}):Promise<EnrollmentListSnapshot>;
+}
+export interface EnrollmentCatalogReader extends EnrollmentReader {
+ listEnrollments(target:{clientId:number}):Promise<EnrollmentListSnapshot>;
 }
 export function openUiSession(options:LoginOptions):Promise<UiSession>;
 /** The read-only enrollment session shares the page lock with mutation helpers. */
-export function openEnrollmentSession(options:LoginOptions&{store:GwtMutationStore & UiMutationStore}):Promise<UiSession&{helpers:GwtEnrollmentHelpers;enrollmentSession:EnrollmentReader;workflows:ClientWorkflows}>;
-export function createPlaywrightGwtSession(options:PlaywrightGwtOptions):Omit<GwtEnrollmentSession,'readEnrollment'>&EnrollmentReader;
+export function openEnrollmentSession(options:LoginOptions&{store:GwtMutationStore & UiMutationStore}):Promise<UiSession&{helpers:GwtEnrollmentHelpers;enrollmentSession:EnrollmentCatalogReader;workflows:ClientWorkflows}>;
+export function createPlaywrightGwtSession(options:PlaywrightGwtOptions):Omit<GwtEnrollmentSession,'readEnrollment'>&EnrollmentCatalogReader;
 export function createPlaywrightEnrollmentHelpers(options:PlaywrightGwtOptions&{store:GwtMutationStore}):GwtEnrollmentHelpers;
 
 /** Durable JSON journal. Use a separate namespace from enrollment intents. */

package/browser/index.mjs

@@ -10,7 +10,7 @@ export async function openEnrollmentSession({store,...loginOptions}) {
   try {
     const helpers=createPlaywrightEnrollmentHelpers({page:session.page,store,...session.connection});
     const reader=createPlaywrightGwtSession({page:session.page,...session.connection});
-    const enrollmentSession={connection:session.connection,readEnrollment:target=>withPageLock(session.page,()=>reader.readEnrollment(target))};
+    const enrollmentSession={connection:session.connection,readEnrollment:target=>withPageLock(session.page,()=>reader.readEnrollment(target)),listEnrollments:target=>withPageLock(session.page,()=>reader.listEnrollments(target))};
     return Object.assign(session,{helpers,enrollmentSession,workflows:createClientWorkflows({page:session.page,store})});
   }catch(error){await session.close();throw error;}
 }
@@ -21,7 +21,7 @@ export {createServiceUi} from './service-ui.mjs';
 export {createServiceRecorder} from './service-recording.mjs';
 export {getSsvfServiceRules} from './ssvf-rules.mjs';
 export {createProgramDiscovery} from './program-discovery.mjs';
-export {createEnrollmentWorkflow,EnrollmentWorkflowError} from './enrollment-workflow.mjs';
+export {createEnrollmentWorkflow,EnrollmentWorkflowError,EnrollmentReadError} from './enrollment-workflow.mjs';
 export {createMemberEntryDatePort} from './member-entry-date.mjs';
 export {createHouseholdExitUi} from './household-exit.mjs';
 

package/browser/playwright-session.mjs

@@ -47,22 +47,25 @@ export function createPlaywrightGwtSession({page,tenant,moduleBaseUrl}) {
     }
     throw Error('Could not close enrollment dialogs');
   };
-  const openTarget=async(target)=>{
-    id(target.clientId);id(target.enrollmentId);await guard();await closeDialogs();
-    const clientHeading=page.getByText(new RegExp(`^Client - \\(${target.clientId}\\)`));
+  const openClient=async(clientId)=>{
+    id(clientId);await guard();await closeDialogs();
+    const clientHeading=page.getByText(new RegExp(`^Client - \\(${clientId}\\)`));
     if(!await clientHeading.isVisible()){
-      const switcher=page.locator('select:visible').filter({has:page.locator(`option[value="${target.clientId}"]`)});
+      const switcher=page.locator('select:visible').filter({has:page.locator(`option[value="${clientId}"]`)});
       if(await switcher.count()===1&&await control(page,'ClientMainView.householdSubmitButton').isVisible()){
-        await switcher.selectOption(String(target.clientId));await control(page,'ClientMainView.householdSubmitButton').click();
+        await switcher.selectOption(String(clientId));await control(page,'ClientMainView.householdSubmitButton').click();
       }else{
         // A hash alone is not proof that GWT switched the displayed client.
-        if(new URL(page.url()).hash===`#loadClient;clientId=${target.clientId}`)throw Error('Client navigation did not load the requested client');
-        await page.goto(moduleBaseUrl+`index.html#loadClient;clientId=${target.clientId}`);
+        if(new URL(page.url()).hash===`#loadClient;clientId=${clientId}`)throw Error('Client navigation did not load the requested client');
+        await page.goto(moduleBaseUrl+`index.html#loadClient;clientId=${clientId}`);
       }
       await clientHeading.waitFor();await ready();
     }
     await page.getByRole('tab',{name:'Summary',exact:true}).click();await ready();
     await page.getByRole('tab',{name:'Entry / Exit',exact:true}).click();await ready();
+  };
+  const openTarget=async(target)=>{
+    id(target.enrollmentId);await openClient(target.clientId);
     const edit=control(page,`ClientEntryExitTab.editEntry-imageLink_${target.enrollmentId}`);
     await edit.waitFor();
     const response=page.waitForResponse(r=>r.url()===endpoint&&r.request().postData()?.includes('|getEntryExit|')&&r.request().postData()?.endsWith(`|${target.enrollmentId}|`));
@@ -97,6 +100,25 @@ export function createPlaywrightGwtSession({page,tenant,moduleBaseUrl}) {
     if(ids.some(n=>!Number.isSafeInteger(n)||n<=0))throw Error('Invalid household tree');
     await closeDialogs();return [...new Set([target.clientId,...ids])].sort((a,b)=>a-b);
   };
+  const listEnrollments=async({clientId})=>{
+    id(clientId);await guard();wire=undefined;let captured;
+    const listener=request=>{
+      if(request.url()===moduleBaseUrl+'service/MetaQueryService'&&request.postData()?.startsWith('7|0|')){
+        const policy=request.postData().split('|')[4];
+        captured=request.allHeaders().then(headers=>({policy,headers:Object.fromEntries(['content-type','x-gwt-module-base','x-gwt-permutation'].map(k=>[k,headers[k]]))}));
+      }
+    };
+    page.on('request',listener);
+    try{await openClient(clientId);wire=await captured;}finally{page.off('request',listener);}
+    if(!wire?.policy||Object.values(wire.headers).some(v=>!v))throw Error('Fresh enrollment list context unavailable');
+    const rows=await mapped(`SELECT e.entryExitId AS enrollmentId, e.clientId AS clientId, e.entryDate AS projectStartDate, e.exitDate AS projectExitDate, e.providerId AS enrollmentProvider, e.typeEntryExit.name AS type FROM SpEntryExit AS e WHERE e.active = TRUE AND e.client.active = TRUE AND e.clientId = ${clientId} ORDER BY e.entryExitId`);
+    const ids=new Set();
+    for(const row of rows){
+      if(!Number.isSafeInteger(row.enrollmentId)||row.enrollmentId<=0||row.clientId!==clientId||!Number.isSafeInteger(row.enrollmentProvider)||row.enrollmentProvider<=0||typeof row.type!=='string'||!row.type.trim()||typeof row.projectStartDate!=='string'||!Number.isFinite(Date.parse(row.projectStartDate))||row.projectExitDate!==null&&(typeof row.projectExitDate!=='string'||!Number.isFinite(Date.parse(row.projectExitDate)))||ids.has(row.enrollmentId))throw Error('Invalid enrollment list');
+      ids.add(row.enrollmentId);
+    }
+    return {source:'gwt-rpc',tenant,clientId,count:rows.length,values:rows.map(row=>({...row,isActive:true}))};
+  };
   const readEnrollment=async target=>{
     const model=await openTarget(target),householdClientIds=await householdIds(target);
     const entries=await mapped(`SELECT e.entryExitId AS enrollmentId, e.clientId AS clientId, e.entryDate AS projectStartDate, e.groupId AS groupId, e.providerId AS providerId, e.typeEntryExit.name AS enrollmentType FROM SpEntryExit AS e WHERE e.active = TRUE AND e.entryExitId = ${id(target.enrollmentId)} AND e.clientId = ${id(target.clientId)}`);
@@ -190,7 +212,7 @@ export function createPlaywrightGwtSession({page,tenant,moduleBaseUrl}) {
     try{await save.click();const result=await Promise.race([captured,new Promise(resolve=>{timer=setTimeout(()=>resolve(null),15000);})]);if(!result)throw Error('Expected mutation was not captured');pending=digest(JSON.stringify({url:result.url,headers:result.headers,body:result.body}));return result;}
     finally{clearTimeout(timer);await page.unroute('**/service/**',handler);await ready();await closeDialogs();}
   };
-  return {connection:resolveUiConnection({tenant,moduleBaseUrl}),readEnrollment,prepare,async send(request){
+  return {connection:resolveUiConnection({tenant,moduleBaseUrl}),readEnrollment,listEnrollments,prepare,async send(request){
     checkGeneration();const fingerprint=digest(JSON.stringify(request));if(!pending||fingerprint!==pending)throw Error('Only the newly prepared request can be sent once');pending=undefined;return post(request);
   }};
 }

package/docs/capabilities.md

@@ -21,6 +21,7 @@ The generated client covers the pinned V2/V3 Swagger operations. The following f
 | Later child or member | `addHouseholdMembers` | Must already belong to household; own later entry date, assessment, and DOB; existing dates preserved |
 | Interims | Workflow `createInterim`, `createHouseholdInterim` or low-level GWT `createInterimUpdate` | Workflow populates answers; low-level helper creates only review/participant links. Selected household members supported |
 | Household exit | `exitHousehold` with exit UI port | Selected members, staggered dates, subsidy/Other details, per-member exit assessments; all-member metadata uses one GWT save, assessments follow separately |
+| Individual enrollment exit | `exitEnrollment` with enrollment reader and exit UI port | Standalone participant, verified entry journal, exit details and assessment, same-key reconciliation; integrator-reported sandbox acceptance November 10, 2026 |
 | Head of household | Enrollment workflow guards | Missing or mid-enrollment replacement head rejected. Head cannot exit before remaining members. Retroactive replacement is not implemented |
 | Verification records at entry | `readEnrollmentVerifications` | Reads generic assessment and filters intervals; complete-enrollment entry arrays can omit valid UI rows |
 | Existing verification end dates | `api.subassessments.setEndDate` | Preserves row ID and other values, verifies result; no blind resend or delete/recreate |
@@ -43,7 +44,7 @@ The generated client covers the pinned V2/V3 Swagger operations. The following f
 
 ## Known server gaps
 
-Grouped REST enrollment reads can return `42703: column v.entry_date_effective does not exist` after both UI and RPC saves. This is not specific to replay. A broken read is not an absent enrollment. The browser enrollment reader uses current UI/GWT evidence. The enrollment workflow and, given `enrollmentSession`, the Current Living Situation and Coordinated Entry Event recorders read household enrollments through it.
+Grouped REST enrollment reads can return `42703: column v.entry_date_effective does not exist` after both UI and RPC saves. This is not specific to replay. A broken read is not an absent enrollment. The browser enrollment reader uses current UI/GWT evidence. The configured enrollment workflow now uses its counted GWT catalog for creation preflight as well as targeted GWT reads. The Current Living Situation and Coordinated Entry Event recorders use targeted GWT reads when given `enrollmentSession`. Legacy custom readers without `listEnrollments` retain REST list behavior.
 
 The October 24 [V2/V3 comparison](vendor-issues/enrollment-effective-date-column.md) reproduced the missing-column error for all 16 tested grouped complete enrollments in each version. Individual-only client lists succeeded, and individual pages within a mixed client also succeeded. Switching to V2 does not fix the issue. One individual complete read had a separate `Non-static method requires a target.` error.
 
@@ -75,3 +76,13 @@ Independent needs and AIRS/service-type discovery use UI/GWT helpers. See [indep
 The [separate complete-enrollment target error](vendor-issues/enrollment-complete-target-error.md) was isolated to missing DOB information in controlled sandbox fixtures. Adding only `SVPPROFDOB`, or only `SVPPROFDOBTYPE` with `DOBTYPE_DONTKNOW` or `DOBTYPE_REFUSED`, changed HTTP 400 to success in V2 and V3. The quality-only fixtures retained empty DOB values, confirmed through REST and the UI. Never invent a DOB or recreate an enrollment to recover a read.
 
 Current Living Situation contact recording is available through `createCurrentLivingSituationRecorder`. It preserves distinct contacts with program-entry starts and optional recording-program verification. See the [contact guide](current-living-situation.md) for metadata mapping, date contracts, blocked server reads, and acceptance limits.
+
+## Integrator-reported acceptance, November 10, 2026
+
+The integrator reported these results using SDK 0.4.1 in the training tenant. They are reported live evidence, not a fresh SDK-team rerun. Client and enrollment identifiers are omitted from this public package.
+
+- A standalone enrollment exited on November 9 and the person was re-enrolled. Repeating the same keys produced no additional writes.
+- Two household cohorts exited successfully using plans from `discoverExit`, carrying forward fields with values and marking the rest not applicable.
+- After those household exits, both re-enrollment attempts failed on the pre-create REST list with HTTP 400 from the grouped-enrollment `42703` gap. This confirms that an exited household enrollment can still break that REST list.
+
+The GWT catalog correction has regression coverage for individual creation, household heads and member preflight, failed-read classification and re-enrollment. Same-date entry corrections and adoption of manual enrollments have synthetic coverage. These newer paths have not been independently verified live.

package/docs/development.md

@@ -53,7 +53,7 @@ See [CHANGELOG.md](../CHANGELOG.md) for compatibility changes. This package is a
 
 GitLab is the source of truth. Its push mirror copies branches and tags to `nmbgeek/communityservices-sdk` on GitHub. Commit changes, including `.github/workflows/publish.yml`, in GitLab. Do not edit the mirror or push independent commits there.
 
-The GitHub workflow checks Node 22, Node 24, and Chromium using synthetic fixtures. A matching `v<version>` tag publishes the tested Chromium-job tarball as public `@choiceapps/communityservices-sdk`. Main pushes only verify. To recover an interrupted release, run `publish.yml` manually against the existing version tag. An identical existing artifact is verified without republishing; a different artifact under the same version fails. npm versions cannot be replaced.
+The GitHub workflow uses Ubuntu 24.04 runners and checks Node 22, Node 24, and Chromium using synthetic fixtures. The runner version is explicit because the pinned Playwright version cannot install Chromium on Ubuntu 26.04. A matching `v<version>` tag publishes the tested Chromium-job tarball as public `@choiceapps/communityservices-sdk`. Main pushes only verify. To recover an interrupted release, run `publish.yml` manually against the existing version tag. An identical existing artifact is verified without republishing; a different artifact under the same version fails. npm versions cannot be replaced.
 
 Configure the npm package's trusted publisher for GitHub owner `nmbgeek`, repository `communityservices-sdk`, workflow filename `publish.yml`, with publishing allowed and no environment name. The workflow runs on GitHub-hosted runners, grants `id-token: write` only to the publish job, and uses npm 11.19.1. It needs no `NPM_TOKEN` or `NODE_AUTH_TOKEN` secret. The package's repository URL points to this public mirror so npm can attach provenance. GitLab publication remains a separate job using `CI_JOB_TOKEN`.
 

package/docs/enrollments.md

@@ -128,8 +128,40 @@ In this mode the mobile batch carries no yes/no answers. After it verifies, a se
 
 Every mandatory label is resolved before the first write. The `yesno` stage verifies with a generic read one second after the effective instant, because a read at the instant omits yes/no answers, and requires each answer and its effective timestamp to match. The mode is recorded in the journal. An unfinished workflow started in one mode fails in the other rather than switching endpoints, including journals left pending by earlier mobile yes/no attempts; those require separate reconciliation. Yes/no children of new subassessment rows still use the mobile row write, which drops them, so leave them unanswered in workflow rows. Record Coordinated Entry Events, which need yes/no and provider answers, with the [event recorder](coordinated-entry-events.md).
 
+## Correct an existing entry assessment
+
+`correctEntry` patches an entry at its original effective timestamp. Supply the verified `createEnrollment` key as `enrollmentKey` and a new stable `key` for each correction. Configure `enrollmentSession` and a `writeLabel` resolver for tenant-verified lookup labels. A correction requires an open enrollment with no interim reviews or exit workflows.
+
+```ts
+const corrected = await workflow.correctEntry({
+  key: sourceCorrectionId,
+  enrollmentKey: sourceEnrollmentId,
+  clientId,
+  answers: changedScalarAnswers,
+  clear: scalarFieldsNoLongerAsked,
+  subassessments: [{
+    key: originalEntryRowKey,
+    parentField,
+    answers: changedRowAnswers,
+    clear: rowFieldsToClear,
+  }],
+});
+```
+
+`answers` uses the ordinary answer and option selectors. `clear` explicitly removes a recorded value; an omitted field stays unchanged. Clearing a yes/no answer is distinct from answering `No`. Do not use `notApplicable` to clear an old answer. Every row key must identify an existing row returned by the original entry operation. The correction never creates a second row, deletes a row, or changes the enrollment date.
+
+Scalars use the standard assessment endpoint, which supports same-date updates. The batch includes every mandatory scalar, preserving its current value unless the patch explicitly answers or clears it. Missing mandatory values require an explicit answer or clear; lookup values require verified write labels. Readback checks one second after the original instant so stored yes/no values are visible.
+
+Row edits send only the changed cells to the existing recordset through the mobile endpoint. Lookup, text, numeric and date cells are supported; provider and yes/no row cells are refused before any write. Untouched cells, all other rows and row IDs must remain unchanged. DOB and household-head changes require their dedicated workflows and cannot be supplied as corrections here. An unmodified mandatory DOB is also refused because the standard batch cannot safely resend it through the DOB helper.
+
+All changes are validated before the first write. Scalar and row batches have separate journal stages, so a partial correction is not rolled back. Retry the same intent and key to reconcile; an uncertain batch is never resent automatically. `getStatus({clientId, key})` reports correction progress. Verified corrections update the original entry's verification expectations, so retrying `createEnrollment` under its old key does not restore the old path. A later correction uses a new correction key. See the [typed example](../examples/entry-correction-workflow.mts).
+
 ## Household enrollment and interim assessments
 
+Enrollment creation and member preflight use the complete GWT list when the configured `enrollmentSession` supplies `listEnrollments`. The built-in sessions supply it. This avoids the REST `42703` failure for clients with existing household enrollments, including exited enrollments and enrollments in other programs. Reads verify the client, tenant, row identities and count; a failed GWT read never falls back to REST or means an empty list. The current GWT reader refuses lists above 1,000 records. Legacy custom readers without this method retain the counted REST path.
+
+An unreadable list throws `EnrollmentReadError` with `code: 'ENROLLMENT_READ_FAILED'`, `source`, `clientId`, and the original error as `cause`. `phase: 'preflight'` and `committed: false` mean this workflow has not attempted a server write. After a write attempt, the error reports `phase: 'reconciliation'` and `committed: 'unknown'`. Retain the existing key and journal in both cases. A lost write followed by a failed read is never a non-commit.
+
 The same workflow exposes `createHouseholdEnrollment` and `createHouseholdInterim`. Supply `enrollmentSession: session.enrollmentSession` when constructing it. Initial household enrollment requires an existing household and at least two existing clients, including its head. Later interims and exits accept a nonempty subset of enrolled members. Establish household membership separately before enrollment.
 
 ```ts
@@ -164,6 +196,38 @@ Client locks coordinate overlapping household and single-client operations. Dura
 
 See the typed [household example](../examples/household-enrollment-workflow.mts) and [live household verification](capabilities.md). The integration uses the configured tenant and uses an isolated authenticated page.
 
+## Individual enrollment exits
+
+Use `exitEnrollment` to end a standalone person's program enrollment. It requires a verified `createEnrollment` entry in the same durable store. Supply `enrollmentSession: session.enrollmentSession` and `exitUi: createHouseholdExitUi({page: session.page})` when constructing the workflow. The same exit UI port serves individual and household forms.
+
+Call `discoverExit` with the person's client, provider, type and entry date, then build their assessment plan from `catalog.exit.definition`.
+
+```ts
+const exit = await workflow.exitEnrollment({
+  key: sourceExitId,
+  enrollmentKey: sourceEnrollmentId,
+  clientId,
+  exitDate,
+  destination: 'Rental by client, no ongoing housing subsidy',
+  reasonForLeaving: 'Completed program',
+  assessment: exitPlan,
+});
+```
+
+The workflow verifies the exact enrollment and sole participant through fresh GWT reads, checks exit dates against entry and interim dates, and validates the assessment before saving. It journals one exit save attempt and verifies the date, destination, reason and conditional details before writing the assessment. Individual exits can have a null `exitSubgroupId`; the result preserves that value. The journal pins any returned subgroup identity on retries.
+
+Retain the same key, intent and store after failures. A lost save response triggers readback, never an automatic resend. Use `getStatus({clientId, key})` to inspect local progress. Exit metadata and assessment writes are separate stages, so a saved exit can remain pending assessment verification. `endDates` closes only the explicitly selected verification rows; enrollment exit does not automatically end every verification record.
+
+For a person in a linked household enrollment, use `exitHousehold` with that person as the only selected member. `exitEnrollment` rejects linked groups to preserve household head coverage. Neither method ends household membership. See the [typed individual exit example](../examples/individual-exit-workflow.mts). The integrator reported successful standalone exit and same-key no-write retry acceptance on November 10, 2026; see [reported sandbox acceptance](capabilities.md#integrator-reported-acceptance-november-10-2026).
+
+## Adopt an enrollment entered manually in WellSky
+
+Use `adoptEnrollment({key, clientId, enrollmentId})` for a standalone enrollment. For linked household enrollments, use `adoptHouseholdEnrollment({key, householdId, headClientId, members})`, where each member supplies both `clientId` and `enrollmentId`. Supply the complete linked cohort, including members already exited, and the original enrollment head. Adoption verifies authoritative GWT identities, program/type, entry dates, current household membership, head relationships when present, and head coverage across all enrollment intervals.
+
+Adoption writes only to the local durable journal. It does not create, attach, exit or modify an HMIS record. Later entrants retain their own original entry dates. An enrollment already tracked under another entry key is rejected; use its existing key. Retry an interrupted adoption with the same inputs and store.
+
+After adoption, pass its key as `enrollmentKey` to `exitEnrollment` or `exitHousehold`. Exit assessment plans and normal household head rules still apply. Adoption records existing enrollment identities, not historical subassessment row-key mappings, so its returned `recordsetIds` is empty. It cannot identify rows for `correctEntry` by a new invented key. See [manual-entry exit examples](../examples/existing-enrollment-exits.mts).
+
 ## Household exits
 
 Add `exitUi: createHouseholdExitUi({page: session.page})` to the workflow options. `discoverExit` returns the provider's entry, interim and exit definitions; use the exit definition to build each person's plan.
@@ -183,6 +247,8 @@ const exit = await workflow.exitHousehold({
 
 This requires a verified household entry in the same durable workflow store. Supply only the members exiting on this date, including a single member if needed; the household head need not be selected. Use separate stable keys for exits on different dates. Every exit plan is validated before saving. The browser submits one shared exit, then authoritative GWT reads verify every member's exit date, destination, reason and exact linked exit group before individual assessment writes. The returned members include `projectExitDate`, `exitSubgroupId` and any new verification `recordsetIds`. Exit dates cannot precede entry or an existing interim.
 
+To end the entire household's program enrollment, include every enrolled member who has not already exited. Already exited members retain their earlier dates. The existing head-coverage checks still apply.
+
 Use `endDates` only for verification records that changed, with replacement rows in `subassessments`; use `carryForward` for unchanged groups. Ending enrollment does not automatically end all verification records. Stored dates are never shifted. Discovery and completeness checks do not decide individual eligibility or which verification types apply.
 
 Reusing the same key and unchanged plans reconciles against fresh reads without repeating writes, including after a lost save response. A partial household exit, unexpected linked member, conflicting exit metadata, schema drift, or an uncertain uncommitted save fails closed. Do not change keys or delete journals to bypass these checks. This remains a non-atomic sequence and does not prevent unrelated integrations or users from editing concurrently.

package/docs/reference.md

@@ -25,7 +25,7 @@ Runtime exports at the root: `AmbiguousCommitError`, `AssessmentMetadata`, `Auth
 
 Import from `@choiceapps/communityservices-sdk/browser` in server-side ESM. These helpers use the tenant supplied by your application. Browser interfaces require `playwright-core`; some orchestration helpers use REST plus injected UI ports rather than directly launching a browser.
 
-Runtime exports: `AttachmentConflictError`, `CoordinatedEntryEventConflictError`, `EnrollmentWorkflowError`, `LoginError`, `SessionInterruptedError`, `createFileGwtMutationStore`, `createPlaywrightEnrollmentHelpers`, `createPlaywrightGwtSession`, `createCasePlanUi`, `createCasePlans`, `createClientCreator`, `createClientProfile`, `createClientProfileUi`, `createClientWorkflows`, `createCoordinatedEntryEventRecorder`, `createDateOfBirth`, `createDateOfBirthUi`, `createEnrollmentWorkflow`, `createHouseholdExitUi`, `createHouseholdUi`, `createHouseholds`, `createMemberEntryDatePort`, `createProgramDiscovery`, `createServiceRecorder`, `createServiceUi`, `getHouseholdOptions`, `getSsvfServiceRules`, `openEnrollmentSession`, `openUiSession`, `validateBirthDate`, `resolveUiConnection`.
+Runtime exports: `AttachmentConflictError`, `CoordinatedEntryEventConflictError`, `EnrollmentWorkflowError`, `EnrollmentReadError`, `LoginError`, `SessionInterruptedError`, `createFileGwtMutationStore`, `createPlaywrightEnrollmentHelpers`, `createPlaywrightGwtSession`, `createCasePlanUi`, `createCasePlans`, `createClientCreator`, `createClientProfile`, `createClientProfileUi`, `createClientWorkflows`, `createCoordinatedEntryEventRecorder`, `createDateOfBirth`, `createDateOfBirthUi`, `createEnrollmentWorkflow`, `createHouseholdExitUi`, `createHouseholdUi`, `createHouseholds`, `createMemberEntryDatePort`, `createProgramDiscovery`, `createServiceRecorder`, `createServiceUi`, `getHouseholdOptions`, `getSsvfServiceRules`, `openEnrollmentSession`, `openUiSession`, `validateBirthDate`, `resolveUiConnection`.
 
 | Task | Contract | Methods or behavior |
 | --- | --- | --- |
@@ -36,7 +36,7 @@ Runtime exports: `AttachmentConflictError`, `CoordinatedEntryEventConflictError`
 | Profile fields and Sex | [Client profile](../browser/client-profile.d.mts) | `read`, `update` |
 | Calendar DOB | [Birth dates](../browser/date-of-birth.d.mts) | `read`, `validate`, `verify`, `update` |
 | Provider assessment defaults | [Discovery](../browser/program-discovery.d.mts) | `listAssessments`, `getProviderAssessments` |
-| Enrollment and household lifecycle | [Workflow](../browser/enrollment-workflow.d.mts) | Discovery, entry, member additions, interim, exit, journal status; `EntryExitType` and per-type `assessmentLocations` in [enrollments](enrollments.md) |
+| Enrollment and household lifecycle | [Workflow](../browser/enrollment-workflow.d.mts) | Discovery, entry, `correctEntry`, `adoptEnrollment`, `adoptHouseholdEnrollment`, member additions, interim, `exitEnrollment`, `exitHousehold`, journal status; `EntryExitType` and per-type `assessmentLocations` in [enrollments](enrollments.md) |
 | Entry-date and exit UI ports | [Member entry](../browser/member-entry-date.d.mts), [exit](../browser/household-exit.d.mts) | Fresh reads and targeted completion |
 | Services and recovery diagnostics | [Service recording](../browser/service-recording.d.mts) | `record`, `recordBulk`, Funding Sources, `RecoveryDiagnostic` |
 | SSVF conditional rules | [SSVF types](../browser/ssvf-rules.d.mts) | [Field rules](../SSVF.md) and dated option snapshots |

package/examples/README.md

@@ -14,6 +14,9 @@ Every file here ships with the package and imports the public `@choiceapps/commu
 | [verification-snapshot.ts](verification-snapshot.ts) | Read assessment records effective at enrollment | Exported function; caller supplies assessment context |
 | [program-discovery.ts](program-discovery.ts) | Program and VA-entry assessment discovery | Exported function; authenticated page required |
 | [enrollment-workflow.mts](enrollment-workflow.mts) | Single entry and interim assessment plans | Exported function; caller supplies plans and dependencies |
+| [individual-exit-workflow.mts](individual-exit-workflow.mts) | Standalone program enrollment exit and assessment | Verified entry key, enrollment reader, exit UI port and durable store required |
+| [entry-correction-workflow.mts](entry-correction-workflow.mts) | Same-date scalar clears and existing row edits | Original entry/row keys, verified lookup labels and durable store required |
+| [existing-enrollment-exits.mts](existing-enrollment-exits.mts) | Adopt manual individual or household entries, then exit | Explicit enrollment identities and original household head required |
 | [household-enrollment-workflow.mts](household-enrollment-workflow.mts) | Per-member enrollment and review | Existing household and per-member answer plans required |
 | [household-lifecycle-workflow.mts](household-lifecycle-workflow.mts) | Selected exits and a later child entry | Household membership precedes program attachment |
 | [household-exit-workflow.mts](household-exit-workflow.mts) | Household exit with destination details | Explicit exit dates and per-member plans required |

package/examples/entry-correction-workflow.mts

@@ -0,0 +1,14 @@
+import {
+ createEnrollmentWorkflow,
+ type EnrollmentWorkflowOptions,
+ type EntryCorrectionInput,
+} from '@choiceapps/communityservices-sdk/browser';
+
+/** The application supplies explicit answers, clears and original row keys.
+ * Dependencies include enrollmentSession and a verified writeLabel resolver.
+ * Reuse the original entry store; input.key identifies this correction, while
+ * input.enrollmentKey identifies the existing createEnrollment operation. */
+export async function correctOriginalEntry(dependencies:EnrollmentWorkflowOptions,input:EntryCorrectionInput){
+ const workflow=createEnrollmentWorkflow(dependencies);
+ return workflow.correctEntry(input);
+}

package/examples/existing-enrollment-exits.mts

@@ -0,0 +1,30 @@
+import {
+ createEnrollmentWorkflow,
+ type EnrollmentWorkflowOptions,
+ type AdoptEnrollmentInput,
+ type AdoptHouseholdEnrollmentInput,
+ type ExitEnrollmentInput,
+ type HouseholdExitInput,
+} from '@choiceapps/communityservices-sdk/browser';
+
+/** Adoption reads WellSky and records its identities locally; it creates no enrollment. */
+export async function exitManualEnrollment(
+ dependencies:EnrollmentWorkflowOptions,
+ existing:AdoptEnrollmentInput,
+ exit:Omit<ExitEnrollmentInput,'enrollmentKey'|'clientId'>,
+){
+ const workflow=createEnrollmentWorkflow(dependencies);
+ await workflow.adoptEnrollment(existing);
+ return workflow.exitEnrollment({...exit,enrollmentKey:existing.key,clientId:existing.clientId});
+}
+
+/** Adopt the complete linked cohort, then exit only the members selected in exit.members. */
+export async function exitManualHousehold(
+ dependencies:EnrollmentWorkflowOptions,
+ existing:AdoptHouseholdEnrollmentInput,
+ exit:Omit<HouseholdExitInput,'enrollmentKey'|'headClientId'>,
+){
+ const workflow=createEnrollmentWorkflow(dependencies);
+ await workflow.adoptHouseholdEnrollment(existing);
+ return workflow.exitHousehold({...exit,enrollmentKey:existing.key,headClientId:existing.headClientId});
+}

package/examples/individual-exit-workflow.mts

@@ -0,0 +1,16 @@
+import {
+  createEnrollmentWorkflow,
+  type EnrollmentWorkflowOptions,
+  type ExitEnrollmentInput,
+  type ExitEnrollmentResult,
+} from '@choiceapps/communityservices-sdk/browser';
+
+/** Supply enrollmentSession and exitUi, and the durable store containing the
+ * verified createEnrollment operation identified by input.enrollmentKey.
+ * Build input.assessment from workflow.discoverExit before calling this function. */
+export async function exitIndividualEnrollment(
+  dependencies:EnrollmentWorkflowOptions,
+  input:ExitEnrollmentInput,
+):Promise<ExitEnrollmentResult> {
+  return createEnrollmentWorkflow(dependencies).exitEnrollment(input);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@choiceapps/communityservices-sdk",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "SDK for WellSky Community Services (HMIS), formerly ServicePoint, Client API V2 and V3",
   "type": "module",
   "main": "./dist/cjs/index.js",