@choiceapps/communityservices-sdk 0.4.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.6.0 - 2026-11-10
+
+- Reject yes/no fields in `correctEntry.clear` before any correction write or new journal entry. Correct synthetic fixtures that incorrectly accepted blank yes/no values. Setting `No` remains supported.
+- Surface correction HTTP status and preserve allowlisted kind/status across retries without journaling response bodies. Retain write and read causes when reconciliation also fails.
+- Add explicit `resolveEntryCorrection` with independent confirmation and two unchanged-state checks. Preserve attempted history, refuse partial/verified commits, and require a new key for corrected intent after rejection. Never reset a sent request automatically from a 4xx response.
+- Clarify shared answers across assessment instruments, the public GWT enrollment catalog, and adoption for interims and scalar corrections. HUD label resolution and household-ID discovery still require authoritative metadata.
+- Correct password recovery documentation: WellSky permits immediately resetting back to the previous password.
+
+## 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.
@@ -7,7 +23,7 @@
 ## 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. Added synthetic regression coverage; live standalone acceptance remains pending.
+- 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
 

package/browser/enrollment-workflow.d.mts

@@ -67,6 +67,46 @@ export interface ExitEnrollmentInput extends HouseholdExitDetailInput {
   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 EntryCorrectionFailure {
+ status?:number;
+ kind?:'http'|'auth'|'timeout'|'network'|'aborted'|'protocol'|'validation'|'throttled'|'cooldown';
+}
+export interface EntryCorrectionResolution {
+ kind:'not-applied';evidenceReference:string;resolvedAt:string;
+}
+export interface EntryCorrectionResolutionEvidence {
+ key:string;enrollmentKey:string;clientId:number;enrollmentId:number;effectiveDate:string;matchesBefore:true;
+ steps:Array<{name:string;state:'attempted'|'verified';failure?:EntryCorrectionFailure}>;
+}
+export interface ResolveEntryCorrectionInput {
+ key:string;enrollmentKey:string;clientId:number;
+ /** Opaque reference to independent non-application evidence, not a response body. */
+ evidenceReference:string;
+ /** Read-only confirmation using independent server/administrative evidence.
+  * A 4xx response plus matchesBefore alone is not sufficient. */
+ confirmNotApplied:(evidence:EntryCorrectionResolutionEvidence)=>boolean|Promise<boolean>;
+}
+export interface ResolveEntryCorrectionResult {
+ key:string;enrollmentKey:string;clientId:number;outcome:'rejected'|'already-rejected';resolution:EntryCorrectionResolution;
+}
+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';
@@ -86,15 +126,16 @@ export interface ExitEnrollmentResult extends EnrollmentWorkflowResult {projectE
 export interface ExitWorkflowDiscovery extends EnrollmentWorkflowDiscovery {exit:{assessment:ProviderAssessmentItem;definition:AssessmentDefinition};}
 export interface EnrollmentWorkflowStatus {
   key:string;
-  kind:'entry'|'interim'|'exit';
-  stage:'pending'|'verified';
+  kind:'entry'|'interim'|'exit'|'correction';
+  stage:'pending'|'verified'|'rejected';
   assessmentCode:string;
   enrollmentId?:number;
   reviewId?:number;
   projectExitDate?:string;
   exitSubgroupId?:string|null;
   recordsetIds:Record<string,number>;
-  steps:{name:string;state:'attempted'|'verified'}[];
+  steps:{name:string;state:'attempted'|'verified';failure?:EntryCorrectionFailure}[];
+  resolution?:EntryCorrectionResolution;
 }
 export interface EnrollmentWorkflow {
   discover(input:EnrollmentDiscoveryInput):Promise<EnrollmentWorkflowDiscovery>;
@@ -103,6 +144,14 @@ export interface EnrollmentWorkflow {
   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 unchanged state and independently confirmed rejection; keeps the attempt history. */
+  resolveEntryCorrection(input:ResolveEntryCorrectionInput):Promise<ResolveEntryCorrectionResult>;
+  /** 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>;
@@ -193,9 +242,22 @@ export interface EnrollmentWorkflowOptions {
 }
 export class EnrollmentWorkflowError extends Error {
   readonly reason:string;
+  readonly code?:string;
+  readonly fields?:string[];
+  readonly status?:number;
   /** Failed durable stage, when known. The original write error is available as cause in memory. */
   readonly step?:string;
-  constructor(reason:string,options?:ErrorOptions&{step?:string});
+  constructor(reason:string,options?:ErrorOptions&{step?:string;code?:string;fields?:string[];status?:number});
+}
+/** 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. */

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,correctionFailureDetails} from './entry-correction.mjs';
 import {createHash} from 'node:crypto';
 import {readProgramCatalog,encodeAnswers,encodeNewSubassessmentRow,toItems,parseRestInstant} from '../dist/esm/index.js';
 
@@ -10,7 +11,21 @@ const entryExitTypes=['HUD','Basic','Standard','RHY','VA','Basic Center Program
 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 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 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;
+  if(options?.code!==undefined)this.code=options.code;
+  if(options?.fields!==undefined)this.fields=[...options.fields];
+  const status=options?.status??options?.cause?.status;
+  if(Number.isInteger(status)&&status>=100&&status<=599)this.status=status;
+ }
+}
+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 +93,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,6 +138,7 @@ 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,resolveEntryCorrection}=createEntryCorrector({api,store,enrollmentSession,writeLabel,discover,scope,reservationScope,makeError:(reason,options)=>new EnrollmentWorkflowError(reason,options)});
  const run=async(kind,raw,internal={})=>{
   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']:[])]);
@@ -133,7 +154,7 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
    const reservations=await store.withLock(reservationScope(input.clientId),()=>store.read(reservationScope(input.clientId)));
    if(!Array.isArray(reservations)||reservations.some(r=>r.stage!=='verified'&&r.owner!==internal.owner))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');
+   if(records.some(r=>r.stage!=='verified'&&!(r.kind==='correction'&&r.stage==='rejected')&&r.key!==input.key))fail('another unfinished workflow must be reconciled first');
    const matches=records.filter(r=>r.key===input.key);if(matches.length>1)fail('duplicate journal keys');let record=matches[0];
    const intentHash=hash({kind,input,...(internal.owner?{household:internal.owner}:{})});if(record&&record.intentHash!==intentHash)fail('key conflicts with previous intent');
    // Changing the yes/no endpoint after an attempt would be an endpoint switch, not reconciliation.
@@ -206,9 +227,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));
@@ -222,6 +245,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);
@@ -259,9 +286,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});
+    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),found=list.filter(e=>e.enrollmentProvider===context.providerId&&e.type===context.type&&restDate(e.projectStartDate)===restDate(context.entryDate)&&e.isActive!==false);
+    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};
@@ -300,12 +329,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.
@@ -314,8 +343,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};
@@ -343,6 +372,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.kind==='correction'&&r.stage==='rejected')&&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']:[])]);
@@ -374,7 +479,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');
@@ -434,11 +539,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};
@@ -462,7 +577,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();
@@ -483,7 +598,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});
@@ -583,6 +698,9 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
   }));
  };
  return {
+  correctEntry,
+  resolveEntryCorrection,
+  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),
@@ -602,7 +720,7 @@ export function createEnrollmentWorkflow({api,discovery,helpers,store,enrollment
     const records=await store.read(scope(input.clientId));if(!Array.isArray(records))fail('invalid workflow journal');
     const matches=records.filter(r=>r.key===input.key);if(matches.length>1)fail('duplicate journal keys');const r=matches[0];if(!r)return null;
     if(r.version!==1||!object(r.steps))fail('invalid workflow journal');
-    return {key:r.key,kind:r.kind,stage:r.stage,assessmentCode:r.assessmentCode,...(r.enrollmentId?{enrollmentId:r.enrollmentId}:{}),...(r.reviewId?{reviewId:r.reviewId}:{}),...(r.projectExitDate?{projectExitDate:r.projectExitDate,exitSubgroupId:r.exitSubgroupId}:{}),recordsetIds:structuredClone(r.rows),steps:Object.entries(r.steps).map(([name,step])=>({name,state:step.state}))};
+    return {key:r.key,kind:r.kind,stage:r.stage,assessmentCode:r.assessmentCode,...(r.enrollmentId?{enrollmentId:r.enrollmentId}:{}),...(r.reviewId?{reviewId:r.reviewId}:{}),...(r.projectExitDate?{projectExitDate:r.projectExitDate,exitSubgroupId:r.exitSubgroupId}:{}),...(r.resolution?{resolution:structuredClone(r.resolution)}:{}),recordsetIds:structuredClone(r.rows),steps:Object.entries(r.steps).map(([name,step])=>({name,state:step.state,...(step.failure?{failure:correctionFailureDetails(step.failure)}:{})}))};
    });
   },
  };

package/browser/entry-correction.mjs

@@ -0,0 +1,205 @@
+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']);
+export function correctionFailureDetails(error){
+ const failure={};
+ if(Number.isInteger(error?.status)&&error.status>=100&&error.status<=599)failure.status=error.status;
+ if(['http','auth','timeout','network','aborted','protocol','validation','throttled','cooldown'].includes(error?.kind))failure.kind=error.kind;
+ return failure;
+}
+
+/** 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]));
+  const unsupportedClears=clear.filter(field=>index.get(field)?.questionType==='yes_no');
+  if(unsupportedClears.length)throw makeError('yes/no answers cannot be cleared',{code:'UNSUPPORTED_YES_NO_CLEAR',fields:unsupportedClears});
+  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;
+ };
+ const run=async(mode,raw)=>{
+  const resolving=mode==='resolve';
+  fields(raw,resolving?['key','enrollmentKey','clientId','evidenceReference','confirmNotApplied']:['key','enrollmentKey','clientId','answers','clear','subassessments']);
+  const {confirmNotApplied,...serializable}=raw;
+  const input=structuredClone(serializable);key(input.key);key(input.enrollmentKey);
+  if(resolving){key(input.evidenceReference);if(typeof confirmNotApplied!=='function')fail('independent non-application confirmation required');}
+  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.kind==='correction'&&r.stage==='rejected')&&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(resolving){
+    if(!record||record.kind!=='correction'||record.enrollmentKey!==input.enrollmentKey)fail('matching correction journal required');
+    if(record.stage==='verified')fail('verified correction cannot be rejected');
+    if(record.stage==='rejected'){
+     if(record.resolution?.evidenceReference!==input.evidenceReference)fail('resolution evidence reference changed');
+     return {key:input.key,enrollmentKey:input.enrollmentKey,clientId:input.clientId,outcome:'already-rejected',resolution:structuredClone(record.resolution)};
+    }
+   }else{
+    if(record?.kind==='correction'&&record.stage==='rejected')throw makeError('correction was resolved as not applied; use a new key for a corrected intent',{code:'ENTRY_CORRECTION_REJECTED'});
+    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();
+   if(resolving){
+    if(record.stage!=='pending'||!Object.values(record.steps).some(s=>s.state==='attempted'))fail('attempted correction required for resolution');
+    const unchanged=state=>canonical({scalars:state.scalars,rows:state.rows})===canonical(record.before);
+    if(!unchanged(observed))fail('correction state differs from its pre-write snapshot; non-application cannot be resolved');
+    const evidence={clientId:input.clientId,enrollmentId:entry.enrollmentId,enrollmentKey:input.enrollmentKey,key:input.key,effectiveDate:at,matchesBefore:true,steps:Object.entries(record.steps).map(([name,s])=>({name,state:s.state,...(s.failure?{failure:correctionFailureDetails(s.failure)}:{})}))};
+    if(await confirmNotApplied(evidence)!==true)fail('independent non-application confirmation required');
+    await verifyEnrollment();if(!unchanged(await snapshot()))fail('correction state changed during resolution');
+    record.resolution={kind:'not-applied',evidenceReference:input.evidenceReference,resolvedAt:new Date().toISOString()};record.stage='rejected';
+    await store.write(scope(input.clientId),structuredClone(records));
+    return {key:input.key,enrollmentKey:input.enrollmentKey,clientId:input.clientId,outcome:'rejected',resolution:structuredClone(record.resolution)};
+   }
+   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)=>{
+    const uncertain=cause=>makeError('uncertain entry correction requires reconciliation',{step:name,code:'ENTRY_CORRECTION_UNCERTAIN',status:record.steps[name]?.failure?.status,...(cause===undefined?{}:{cause})});
+    let found;try{found=await inspect(name);}catch(readError){if(record.steps[name])throw uncertain(readError);throw readError;}
+    if(found){record.steps[name]={state:'verified'};await persist();return;}
+    if(record.steps[name])throw uncertain();
+    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;const failure=correctionFailureDetails(e);
+     if(Object.keys(failure).length){record.steps[name].failure=failure;await persist();}
+    }
+    let saved;
+    try{saved=await inspect(name);}catch(readError){throw uncertain(cause===undefined?readError:new AggregateError([cause,readError],'Correction write and reconciliation read failed'));}
+    if(!saved)throw uncertain(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');
+  });
+ };
+ return {correctEntry:raw=>run('correct',raw),resolveEntryCorrection:raw=>run('resolve',raw)};
+}

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/assessments.md

@@ -29,7 +29,7 @@ The default metadata cache TTL is 60 seconds with 100 entries per client. Config
 
 WellSky requires a client context and known assessment code for these reads. There is no documented global assessment-list or standalone picklist-list endpoint. Mobile option metadata has no effective-date filter, so definitions explicitly identify its options as current even when the generic assessment read is dated. Metadata also does not provide a complete questionnaire branching engine.
 
-Use the raw `assessments.get`, `assessmentsMobile.getAnswers`, and `enrollments.getAssessment` methods for recorded answers. Use `encodeAnswers` and `encodeNewSubassessmentRow` for endpoint-specific encoding. Mobile lookups use option IDs; standalone/enrollment lookups require an explicit `writeLabel` resolver with tenant-verified labels. Raw option names are not assumed to be valid write labels. Provider answers are refused for mobile writes because that endpoint can silently discard them. Answer-state code mappings and multi-value serialization are caller-supplied; a refusal is never converted to `No`.
+Use the raw `assessments.get`, `assessmentsMobile.getAnswers`, and `enrollments.getAssessment` methods for recorded answers. Use `encodeAnswers` and `encodeNewSubassessmentRow` for endpoint-specific encoding. Mobile lookups use option IDs; standalone/enrollment lookups require an explicit `writeLabel` resolver with tenant-verified labels. Raw option names are not assumed to be valid write labels. Some HUD-marked choices require `(HUD)` in the full write label even when metadata `name` omits it. Do not infer this from trailing whitespace or append the suffix to every option. Continue supplying tenant-verified labels until a label resolver has authoritative metadata; recorded `answer_value_text` is useful evidence for the corresponding option. Provider answers are refused for mobile writes because that endpoint can silently discard them. Answer-state code mappings and multi-value serialization are caller-supplied; a refusal is never converted to `No`.
 
 ## Yes/no answer acceptance
 
@@ -48,6 +48,12 @@ Reproduced on November 2, 2026 in a sandbox tenant with synthetic clients:
 
 The enrollment workflow writes yes/no answers through the mobile batch by default. That keeps their stage pending because the saved values never verify. Construct it with `yesNoWrites: 'standard'` and a `writeLabel` resolver to send them through `assessments.create` instead; see [the enrollment workflow](enrollments.md#yesno-answers). It never treats an empty yes/no answer as `No`, skips a requested field, or switches endpoints for a stage that was already attempted. For a minimal reproduction, [enable private error diagnostics](troubleshooting.md#inspect-an-upstream-error-privately) and retain the question's current metadata.
 
+## Shared questions across assessment instruments
+
+An entry assessment and a standalone form can reference the same stored question. Changing `assessmentCode` does not make a second answer at the same client/question/effective instant available for a mobile insert. The integrator reported this for `HPTARGETINGSCORETOTAL` on an entry and form 1002: when the stored value differed, the mobile batch was rejected. Compare question identifiers and effective dates, not only form names.
+
+Read the existing answer before planning a mobile scalar insert. If it already exists at that instant with another value, use a supported standard correction/update path after resolving the original operation; do not move its timestamp to evade the collision. Raw `assessmentsMobile.addAnswer` remains a raw write and performs no implicit read or cross-form collision check. Never switch endpoints to retry an uncertain batch.
+
 ## Race and ethnicity combinations
 
 `encodeAnswers` recognizes the standard `HUD_RACEETHNICITY` field. It resolves single-category and multiple-category answers to the tenant's `RACE_ETH_COMBO_*` option IDs. A single White answer uses `RACE_ETH_COMBO_WHI`, even when the caller supplies `RACE_ETH_WHI`. Atomic option IDs can read back with a label while appearing blank in the UI.

package/docs/browser-session.md

@@ -97,7 +97,7 @@ On the expired-login form, the helper appends the character to the original `HMI
 
 Use one shared, durable recovery store for every caller of the same UI account. Multi-host deployments must override the default with shared durable storage and locking. Keep using an existing custom recovery store if it has a pending recovery; changing stores does not reconcile it. The per-account lock covers the entire recovery. Its journal contains stages and the append character, never either password. The original must be 8–49 characters when a reset is needed so the temporary password fits the observed 50-character limit. A 50-character password can still log in normally. Keep the original credential and append character unchanged while a recovery is pending. The SDK sanitizes login errors; do not enable Playwright tracing, request-body capture, or debug logging containing credentials.
 
-A saved temporary-password attempt can resume with one authentication check of that temporary password. A saved restoration attempt can resume with one authentication check of the original. Neither uncertain password write is repeated. An interrupted or failed authentication check leaves a blocking journal stage and raises `RECOVERY_UNCERTAIN`; reconcile the account and journal before proceeding. A process crash may also leave the file store's exclusive lock. Do not delete journals or automatically expire locks to force retries. If server policy rejects restoring the original, the helper stops and the temporary password may remain active.
+A saved temporary-password attempt can resume with one authentication check of that temporary password. A saved restoration attempt can resume with one authentication check of the original. Neither uncertain password write is repeated. An interrupted or failed authentication check leaves a blocking journal stage and raises `RECOVERY_UNCERTAIN`; reconcile the account and journal before proceeding. A process crash may also leave the file store's exclusive lock. Do not delete journals or automatically expire locks to force retries. WellSky permits immediately resetting back to the previous password. Password history does not prevent the restore-original step.
 
 Both UI actions use GWT-RPC: the shipped expired-login handler calls `AuthenticationService.changePasswordHeartbeat`, while the user-settings restoration was observed calling `UserService.updateUserPassword` with HTTP 200 / GWT OK. The former uses the limited session established by the expired login. The helper currently drives the live forms to generate fresh requests. A standalone RPC-only password adapter has not been implemented or tested; captured password payloads must not be stored or replayed. See [sandbox findings](capabilities.md).
 

package/docs/capabilities.md

@@ -21,7 +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; synthetic regression coverage only, live acceptance pending |
+| 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 |
@@ -39,12 +39,12 @@ The generated client covers the pinned V2/V3 Swagger operations. The following f
 | Client Notes, goals, action steps | `createCasePlans` plus raw REST methods | Journaled create/update and supported-field verification; helper supplies clientId on goal updates; unreadable follow-up fields excluded |
 | Goal case notes | `session.workflows.createCaseNote` | Optional source key rejects changed intent and verifies saved note ID; legacy unkeyed matching remains; single client only. REST goal response does not expose these notes |
 | Multi-client/multi-case notes | No packaged bulk helper | Do not infer note participants from unrelated `households` nested in a goal response |
-| Expired UI password | Headless login, enabled by default | Temporary suffix then restore original, durable recovery stages, fresh-login verification; policy rejection may leave temporary password active |
+| Expired UI password | Headless login, enabled by default | Temporary suffix then restore original, durable recovery stages, fresh-login verification; WellSky permits immediate restoration of the previous password |
 | Session expiration | Managed session plus durable workflow journals | Reauthenticate and report interruption; caller retries original intent for reconciliation, not automatic callback replay |
 
 ## 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.
 
@@ -69,10 +69,20 @@ These observations explain the current contracts. They are dated acceptance resu
 | Household exits and head coverage, October 23, 2026 | An invalid early head exit was blocked before writes. Valid staggered exits and an all-member exit preserved dates, original heads, and selected subgroups; retries made no extra record writes. | Earlier server-accepted orphaned groups were invalid under the current SDK contract. See [head validation feedback](vendor-issues/household-head-validation.md) and [enrollments](enrollments.md). |
 | Attachment identity and content, October 24, 2026 | Profile, Case Plans, and goal files retained their IDs across fresh helpers, and downloaded bytes matched the originals. | Does not establish anonymous access or sharing permissions. REST authentication remained a separate failure. See [files and notes](files-and-notes.md). |
 | SSVF conditional forms, October 23, 2026 | Form inspection checked conditional branches and required-date validation without saving; four REST-supported dependencies were then saved and read back, with zero duplicate writes on same-key retries. | This is a dated rules snapshot, not exhaustive financial assistance or funding-allocation acceptance. See [SSVF rules](../SSVF.md) and [services](services.md). |
-| Expired-password recovery, October 23, 2026 | An expired account completed temporary-password recovery, restored its original password, and authenticated in a fresh context. | Account policy can reject a recovery stage; retain the durable recovery journal. See [browser sessions](browser-session.md). |
+| Expired-password recovery, October 23, 2026 | An expired account completed temporary-password recovery, restored its original password, and authenticated in a fresh context. | WellSky permits immediate restoration of the previous password; retain the durable recovery journal for interrupted operations. See [browser sessions](browser-session.md). |
 
 Independent needs and AIRS/service-type discovery use UI/GWT helpers. See [independent needs](independent-needs.md) for the creation, counted catalog, and retry contracts. The pinned Swagger exposes need reads but no independent-need creation.
 
 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/enrollments.md

@@ -128,8 +128,62 @@ 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. Yes/no fields cannot appear in `clear`: the SDK throws `UNSUPPORTED_YES_NO_CLEAR`, with the affected `fields`, before any correction write or new journal record. Use `{value: false}` to answer `No`; it does not mean blank. No alternative yes/no blanking route has been verified. 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 an explicit clear for a supported non-yes/no type; 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).
+
+## Resolve a rejected correction
+
+An attempted correction stays pending until its outcome is established. A 4xx response or an unchanged read alone does not prove non-application, so the SDK does not automatically reset or resend it. New failures expose `code: 'ENTRY_CORRECTION_UNCERTAIN'`, `step`, and an available HTTP `status`. The first failure retains its original `cause`; a failed reconciliation read retains both errors in an `AggregateError`. Only allowlisted failure kind/status are persisted and returned by `getStatus`. Response bodies, messages, credentials and stacks are not written to the journal. Older journals cannot recover diagnostics they never saved.
+
+If independent server or administrative evidence establishes that an attempted correction was not applied, call:
+
+```ts
+await workflow.resolveEntryCorrection({
+  key: failedCorrectionKey,
+  enrollmentKey,
+  clientId,
+  evidenceReference: independentReviewReference,
+  confirmNotApplied: async evidence => rejectionReview.confirmNotApplied(evidence),
+});
+```
+
+`rejectionReview` is application-owned. Its callback must be read-only and confirm non-application from independent evidence; do not implement it as `() => true` or infer its answer only from HTTP status and `matchesBefore`. The callback receives identities, effective date and sanitized step diagnostics. Do not call the same client's workflow methods from the callback: the client journal lock remains held.
+
+The SDK verifies the complete saved pre-write state before and after confirmation and rechecks enrollment context. A partial application, changed state or unavailable read prevents resolution. Successful resolution marks the correction `rejected` while retaining its original intent, attempted steps, diagnostics and evidence reference. It makes no SDK record writes to WellSky. Repeating the same resolution returns `already-rejected`; submitting that correction key again throws `ENTRY_CORRECTION_REJECTED`. Use a new correction key for the corrected intent only after resolution. A verified successful correction cannot be rejected.
+
+This also supports pending 0.5.0 journals, including those without failure metadata, when the required independent evidence exists. A new validation failure that occurs before journaling needs no resolution.
+
 ## 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 +218,22 @@ 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.
 
+## Public enrollment reads
+
+The managed session exposes a GWT-backed catalog independently of the workflow:
+
+```ts
+const {values: enrollments} =
+  await session.enrollmentSession.listEnrollments({clientId});
+
+const detail = await session.enrollmentSession.readEnrollment({
+  clientId: headClientId, enrollmentId: headEnrollmentId,
+});
+// detail.members contains the complete linked clientId/enrollmentId pairs.
+```
+
+Use the session returned by `openEnrollmentSession`. Lists include open and exited entries, validate complete counts, and refuse more than 1,000 records. The detail read currently exposes `householdClientIds`, not `householdId`; these client IDs and the enrollment's group are not interchangeable with a household ID. Household adoption still requires an explicitly verified household ID.
+
 ## 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.
@@ -186,7 +256,15 @@ The workflow verifies the exact enrollment and sole participant through fresh GW
 
 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). Standalone exit coverage is synthetic; it has not yet been accepted against a live tenant.
+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 standalone adoption, its key can be used as `enrollmentKey` for `createInterim`, scalar-only `correctEntry`, or `exitEnrollment`. After household adoption, the group key works with `createHouseholdInterim` and `exitHousehold`; use the returned member's `key` for that person's scalar-only `correctEntry`. Correction still requires an open entry without reviews or exits. Do not use an all-not-applicable `createEnrollment` call merely to link an existing entry: it can create an enrollment when no match exists. 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
 

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, `exitEnrollment`, `exitHousehold`, journal status; `EntryExitType` and per-type `assessmentLocations` in [enrollments](enrollments.md) |
+| Enrollment and household lifecycle | [Workflow](../browser/enrollment-workflow.d.mts) | Discovery, entry, `correctEntry`, `resolveEntryCorrection`, `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/docs/troubleshooting.md

@@ -28,6 +28,9 @@ Successful adoption of an existing record also needs its journal. Retain it even
 | `DefinitionDriftError`, `UnknownPicklistValueError` | Metadata or lookup assumption changed | Refresh/review definitions and application mapping. Do not guess a numeric option |
 | `AmbiguousCommitError` | Mutation outcome not established | Keep journal pending; re-read through the workflow's authoritative path |
 | `GwtEnrollmentConflictError` | Duplicate/partial/conflicting enrollment or review | Inspect membership and review instant. Do not replay the captured request |
+| `UNSUPPORTED_YES_NO_CLEAR` | A correction attempted to blank a yes/no field | Fix the plan before any write; `No` and blank are different states |
+| `ENTRY_CORRECTION_UNCERTAIN` | An attempted correction is not verified | Inspect `status`, `cause`, and journal step diagnostics; use [explicit resolution](enrollments.md#resolve-a-rejected-correction) only with independent non-application evidence |
+| `ENTRY_CORRECTION_REJECTED` | The old correction key was resolved as not applied | Keep its audit record and use a new key for corrected intent |
 | `EnrollmentWorkflowError` | Invalid plan, missing head, schema drift, conflict, or unresolved stage | Inspect the specific reason and local status; fix application inputs only before reservation, otherwise reconcile original intent |
 | `SessionInterruptedError`, `SESSION_INTERRUPTED` | Managed page operation ended around session expiry | Check `reauthenticated`; retry the original workflow call, never its prepared RPC |
 | `LoginError`, `PASSWORD_EXPIRED` | Expiration detected with recovery disabled | Use the documented recovery option or resolve the password outside the helper |

package/examples/README.md

@@ -15,6 +15,8 @@ Every file here ships with the package and imports the public `@choiceapps/commu
 | [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,22 @@
+import {
+ createEnrollmentWorkflow,
+ type EnrollmentWorkflowOptions,
+ type EntryCorrectionInput,
+  type ResolveEntryCorrectionInput,
+} 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);
+}
+
+/** The confirmation callback must use independent server or administrative evidence.
+ * The SDK also checks the complete pre-write state before and after that callback.
+ * Retain the rejected key; submit a corrected request under a new key afterward. */
+export async function resolveRejectedCorrection(dependencies:EnrollmentWorkflowOptions,input:ResolveEntryCorrectionInput){
+ return createEnrollmentWorkflow(dependencies).resolveEntryCorrection(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/package.json

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