@gitroll/tacitt-cli 0.6.10 → 0.6.12

package/dist/{heap-CM298Yu0.mjs → heap-Blrat--4.mjs}

@@ -1,6 +1,6 @@
-import { S as readPrivateReviewPayload, at as windowsOwnerOnly, it as restrictToOwner, rt as openPrivateFile, tt as exclusiveLock, x as writePrivateReviewPayload } from "./src-3jvMvSQn.mjs";
-import { At as journeyTermSchema, It as termTypeSchema, Mt as reviewTermsResultSchema, Xt as ApplicationError, _ as semanticFindingSchema, b as validateBReview, c as textDigest, d as reviewAlignmentAudit, dt as nativeJourneySchema, er as isStaticCategory, ft as journeyGuidanceSchema, g as validateReviewAlignment, gt as journeyWorkSuggestionSchema, ht as journeyDescribeSchema, i as reviewBatchSchema, it as journeyDigestSchema, jt as reviewTermsInputSchema, kt as privacyTermSchema, l as validateReview, m as reviewAlignmentSchema, nn as reviewFamilies, o as reviewDigest, ot as journeyIdSchema, r as reviewBatchChunks, s as reviewSubmitSchema, sn as fileIdentitySchema, tn as familySelected, tr as staticCategories, u as findingReferenceKey, v as bContextEvidence, wn as createDetectionSummary } from "./locate-Cwv6WH8n.mjs";
-import { $ as validateDetectionSummary, $t as searchScopeDigest, At as obsoleteJourney, Bn as confirmedHideKey, Cn as journeyEventSchema, Cr as validatePreparationFacts, Ft as journeyGuidance, Gn as maskedHitsStale, Hn as confirmedHideTerms, In as bMaskedHits, It as journeyBatchReadSchema, J as validateInspectionFence, Jn as workDecisionDigest, Jt as hideBeginSchema, Kn as syncTermGroups, Kr as journeySendSchema, Kt as journeyContextQuerySchema, Lt as journeyReviewStorageQuerySchema, Mr as applyCardAnswers, Nt as attemptBudgetCodePoints, On as settleConfirmedHides, Ot as settleCorrections, Pt as validateAttemptAppend, Q as validateInspectionContribution, Qn as reviewCandidateResourceSchema, Qt as journeySearchSaveSchema, Rr as mergePrivacyTerms, Rt as applyClassificationProposal, Sn as journeyCommitSchema, Sr as preparationStartSchema, Tn as confirmedHideDeltaSchema, U as validateInspectionBatch, Un as dictionaryHides, Vr as staticSessionId, W as validateInspectionBatches, Wt as newJourneyWork, X as validateInspectionInputs, Xt as hidePublishSchema, Y as validateInspectionHead, Yn as workPrivacyDecisions, Yt as hideFinishSchema, Z as validateInspectionQuery, Zt as journeySearchResultSchema, _n as sessionReviewResourceSchema, _r as journeyInventorySchema, ai as withReadingProgress, an as journeyPlaceSchema, ar as scanAliasResourceSchema, bn as sessionUsefulnessResourceSchema, br as preparationBeginSchema, c as reconstructBFields, cn as reviewAttemptsQuerySchema, cr as scanSessionResourceSchema, d as resolveGroupSplit, dn as sessionReconcileResultSchema, en as journeyPolicyRespondSchema, er as reviewRepairResourceSchema, et as inspectionInputs, fi as stateSchema, fn as sessionReconciliationResourceSchema, g as semanticGroupKey, gn as sessionReviewQuerySchema, gr as journeyInventoryReadSchema, gt as manualUploadSchema, h as hideScopeDigest, ii as selectedWorks, in as journeyIsolateSchema, l as chooseCheapPlacement, ln as reviewAttemptsResultSchema, lr as scanGitSeedsId, mn as sessionRereadResourceSchema, ni as isSelectedWork, nn as journeyResourceQuerySchema, nr as bReviewDigest, o as bRereadDigest, on as sortingApplySchema, or as scanCanonicalResourceSchema, pr as validateScanExclusion, pt as manualUploadBindingSchema, q as validateInspectionClaim, qn as retireWorkDescription, qt as journeyContextSchema, ri as isSkippedWork, rn as journeyResourceSchema, rr as mergeBRepair, s as reconcileBSession, sn as reviewAttemptResourceSchema, t as scanBatchContextDigest, ti as isReadingComplete, tn as projectPreparationProgress, u as reviseGroupMembership, v as projectJourneyInventory, vn as sessionReviewStatusSchema, vr as journeyPreparationProgressSchema, vt as candidateSortAvailable, x as bReviewScope, xn as journeyCommitResultSchema, xr as preparationSettlementSchema, y as preparationScope, yn as sessionUsefulnessInputSchema, zn as confirmedHideGroupIds, zt as classificationCommitSchema } from "./src-BqtdFVq7.mjs";
+import { C as writePrivateReviewPayload, ct as windowsOwnerOnly, it as exclusiveLock, ot as openPrivateFile, st as restrictToOwner, w as readPrivateReviewPayload } from "./src-DeNJ8vOD.mjs";
+import { An as createDetectionSummary, Ft as emptyReviewCorrectionSchema, Ht as termTypeSchema, It as journeyTermSchema, Lt as reviewTermsInputSchema, Nt as privacyTermSchema, Pt as emptyReviewCorrectionResultSchema, Rt as reviewTermsResultSchema, S as validateBReview, a as reviewBatchChunks, b as bContextEvidence, bt as journeyWorkSuggestionSchema, c as reviewDigest, cn as reviewFamilies, d as validateReview, f as findingReferenceKey, g as reviewAlignmentSchema, gt as journeyGuidanceSchema, l as reviewSubmitSchema, lt as journeyIdSchema, mt as nativeJourneySchema, nn as ApplicationError, o as reviewBatchSchema, or as isStaticCategory, p as reviewAlignmentAudit, pn as fileIdentitySchema, sn as familySelected, sr as staticCategories, st as journeyDigestSchema, u as textDigest, v as validateReviewAlignment, y as semanticFindingSchema, yt as journeyDescribeSchema } from "./locate-D-ZaHpI0.mjs";
+import { $ as validateDetectionSummary, $t as journeyPlaceSchema, Ai as stateSchema, At as validateAttemptAppend, Bn as journeySearchSaveSchema, Bt as newJourneyWork, Ci as withReadingProgress, Cn as scanAliasResourceSchema, Cr as preparationStateSchema, Dn as scanGitSeedsId, En as scanSessionResourceSchema, Fn as journeyInventoryReadSchema, Fr as assertJourneyPrivacyReady, Ft as classificationCommitSchema, Gt as hideFinishSchema, Hn as journeyCommitResultSchema, Ht as journeyContextQuerySchema, In as journeyInventorySchema, J as validateInspectionFence, Jr as obsoleteJourney, Jt as sendOutputQuerySchema, Kn as confirmedHideDeltaSchema, Kt as hidePublishSchema, Ln as journeyPreparationProgressSchema, Lr as reconcileReaderKeeps, Mt as journeyBatchReadSchema, Nn as projectPreparationProgress, Nt as journeyReviewStorageQuerySchema, Ot as settleCorrections, Pr as applyCardAnswers, Pt as applyClassificationProposal, Q as validateInspectionContribution, Qt as journeyIsolateSchema, Sr as preparationStartSchema, Tr as validatePreparationFacts, U as validateInspectionBatch, Un as journeyCommitSchema, Ut as journeyContextSchema, Vn as searchScopeDigest, W as validateInspectionBatches, Wn as journeyEventSchema, Wt as hideBeginSchema, X as validateInspectionInputs, Xr as sendReachedPassport, Xt as journeyResourceQuerySchema, Y as validateInspectionHead, Yn as settleConfirmedHides, Yr as sendOwesPassport, Yt as sendOutputSchema, Z as validateInspectionQuery, Zt as journeyResourceSchema, an as sessionReconcileResultSchema, bi as isSkippedWork, bn as bReviewDigest, br as preparationPermissionSchema, c as reconstructBFields, ci as journeySendSchema, cn as sessionRereadResourceSchema, d as resolveGroupSplit, dn as sessionReviewResourceSchema, ei as mergePrivacyTerms, en as sortingApplySchema, et as inspectionInputs, fn as sessionReviewStatusSchema, fr as maskedHitsStale, g as semanticGroupKey, gn as reviewCandidateResourceSchema, gr as workPrivacyDecisions, gt as manualUploadSchema, h as hideScopeDigest, hi as hasCompleteWorkDescription, hr as workDecisionDigest, jn as validateScanExclusion, jt as journeyGuidance, kt as attemptBudgetCodePoints, l as chooseCheapPlacement, lr as confirmedHideTerms, mn as sessionUsefulnessResourceSchema, mr as retireWorkDescription, nn as reviewAttemptsQuerySchema, o as bRereadDigest, on as sessionReconciliationResourceSchema, or as confirmedHideGroupIds, pi as sendSessionUploadSchema, pn as sessionUsefulnessInputSchema, pr as syncTermGroups, pt as manualUploadBindingSchema, q as validateInspectionClaim, qt as journeyPolicyRespondSchema, ri as staticSessionId, rn as reviewAttemptsResultSchema, rr as bMaskedHits, s as reconcileBSession, sr as confirmedHideKey, t as scanBatchContextDigest, tn as reviewAttemptResourceSchema, u as reviseGroupMembership, un as sessionReviewQuerySchema, ur as dictionaryHides, v as projectJourneyInventory, vi as isReadingComplete, vn as reviewRepairResourceSchema, vt as candidateSortAvailable, wn as scanCanonicalResourceSchema, wr as preparationUpdateSchema, x as bReviewScope, xi as selectedWorks, xn as mergeBRepair, xr as preparationSettlementSchema, y as preparationScope, yi as isSelectedWork, yr as preparationBeginSchema, zn as journeySearchResultSchema, zt as isolatedWorkId } from "./src-Do-qzuMn.mjs";
 import { constants } from "node:fs";
 import { z } from "zod";
 import { copyFile, link, lstat, mkdir, mkdtemp, open, readFile, realpath, rm, unlink } from "node:fs/promises";
@@ -346,9 +346,26 @@ function readJourney(db, journeyId) {
 		if (typeof text !== "string") throw new ApplicationError("CORRUPTED_STATE");
 		const state = JSON.parse(text);
 		if (typeof state === "object" && state !== null && "formatVersion" in state && state.formatVersion !== 10) throw new StoreError("OBSOLETE_SCHEMA", "Stored native Journey state uses an obsolete candidate format and has been preserved.");
+		let value = reconcileReaderKeeps(nativeJourneySchema.parse(state));
+		if (value.outputVersion !== void 0 && value.outputVersion > 1) throw new StoreError("OBSOLETE_SCHEMA", "This journey requires a newer final writer.");
+		if (value.outputVersion !== 1 && value.phase !== "completed" && !obsoleteJourney(value)) value = {
+			...value,
+			outputVersion: 1,
+			phase: value.phase === "ready" ? "review" : value.phase,
+			privacy: {
+				...value.privacy,
+				packageApproval: null
+			},
+			works: value.works.map((work) => ({
+				...work,
+				revision: work.revision + 1,
+				status: work.status === "ready" ? "review" : work.status,
+				artifact: null
+			}))
+		};
 		return {
 			text,
-			value: nativeJourneySchema.parse(state)
+			value
 		};
 	});
 }
@@ -362,23 +379,29 @@ function insertCorrectionReport(db, resource) {
 	}
 	db.prepare("INSERT INTO journey_resources VALUES(?,?,?,?)").run(resource.journeyId, resource.kind, resource.id, json);
 }
-/**
-* A snapshot of an earlier release cannot render, so a new Journey may replace it, but never
-* one with a Send record or a sent Work: that Send stays for the person to finish.
-*/
-/** A receipt or persisted session mutation intent means a Send may have reached Passport. */
+/** Whether any Send of this Journey may have reached Passport (`sendReachedPassport`). */
 function reachedPassport(db, journeyId) {
 	return db.prepare("SELECT json FROM journey_sends WHERE journey_id=?").all(journeyId).some((row) => {
 		if (typeof row["json"] !== "string") throw new ApplicationError("CORRUPTED_STATE");
-		return journeySendSchema.parse(JSON.parse(row["json"])).items.some((item) => item.receipt || item.previousReceipts.length || item.sessionUpload !== void 0 || item.sessionMembership || item.sessionAssembly);
+		return sendReachedPassport(journeySendSchema.parse(JSON.parse(row["json"])));
 	});
 }
 /** An abandoned Journey gives way to a new one unless one of its Sends reached Passport. */
 function abandoned(db, current) {
 	return current.abandonedAt !== void 0 && !reachedPassport(db, current.journeyId);
 }
+/**
+* A snapshot of an earlier release cannot render, so a new Journey replaces it unless its current
+* Send still owes Passport something its next advance sends without the person
+* (`sendOwesPassport`, ADR 0284, owner answer A): sent Works stay on Passport, and the new Journey
+* reads every Work again. Replacement cancels its unfinished Sends.
+*/
 function replaceable(db, current) {
-	return obsoleteJourney(current) && !current.works.some((work) => work.binding) && !db.prepare("SELECT 1 FROM journey_sends WHERE journey_id=? LIMIT 1").get(current.journeyId);
+	if (!obsoleteJourney(current)) return false;
+	const row = db.prepare("SELECT json FROM journey_sends JOIN journey_current_send ON journey_sends.id=journey_current_send.send_id WHERE journey_current_send.journey_id=?").get(current.journeyId);
+	if (!row) return true;
+	if (typeof row["json"] !== "string") throw new ApplicationError("CORRUPTED_STATE");
+	return !sendOwesPassport(current, journeySendSchema.parse(JSON.parse(row["json"])));
 }
 /** An addition counts only when one of its findings was assigned to a confirmed Hide category. */
 function joinedHideValues(db, state, delta) {
@@ -439,6 +462,7 @@ function commitJourney(db, input) {
 			...input,
 			state: {
 				...input.state,
+				outputVersion: 1,
 				privacy: {
 					...input.state.privacy,
 					rememberedRules
@@ -453,7 +477,25 @@ function commitJourney(db, input) {
 			state: current
 		};
 	}
+	if (input.expectedRevision === null && current && replaceable(db, current)) db.prepare("DELETE FROM journey_current_send WHERE journey_id=?").run(current.journeyId);
 	if (input.state.journeyId !== input.event.journeyId) throw new ApplicationError("INVALID_ARGUMENTS");
+	if (input.closedReader) {
+		const hold = input.closedReader;
+		const unread = db.prepare(`SELECT 1 FROM journey_batches
+      WHERE id=? AND journey_id=? AND work_id=? AND input_revision=? AND review_ref_json IS NULL`);
+		if (hold.batchIds.some((id) => !unread.get(id, input.state.journeyId, hold.workId, hold.inputRevision))) throw new ApplicationError("REVISION_CONFLICT");
+		const save = db.prepare("INSERT OR IGNORE INTO journey_resources VALUES(?,?,?,?)");
+		for (const batchId of hold.batchIds) {
+			const fence = {
+				kind: "closed-reader",
+				journeyId: input.state.journeyId,
+				id: batchId + ":" + hold.packId,
+				packId: hold.packId,
+				batchId
+			};
+			save.run(fence.journeyId, fence.kind, fence.id, JSON.stringify(fence));
+		}
+	}
 	if (input.state.abandonedAt && current?.journeyId === input.state.journeyId && !current.abandonedAt) {
 		if (reachedPassport(db, current.journeyId)) throw new ApplicationError("INVALID_TRANSITION");
 		db.prepare("DELETE FROM journey_current_send WHERE journey_id=?").run(current.journeyId);
@@ -2265,6 +2307,14 @@ function putSessionUsefulness(db, value) {
 const privateReviewHash = (value) => textDigest(JSON.stringify(value));
 //#endregion
 //#region packages/local-host/src/store/journey/terms/aliases.ts
+function scanAliasRequestKey(alias, requestKey) {
+	const digest = textDigest(JSON.stringify([
+		"scan-alias-v1",
+		alias,
+		requestKey
+	]));
+	return `${digest.slice(0, 8)}-${digest.slice(8, 12)}-4${digest.slice(13, 16)}-8${digest.slice(17, 20)}-${digest.slice(20, 32)}`;
+}
 const scanAliasQuerySchema = z.object({ journeyId: z.uuid() }).strict();
 const scanAliasSelectionSchema = z.array(z.object({
 	alias: scanAliasResourceSchema,
@@ -2288,7 +2338,8 @@ function selectScanAliases(db, input) {
 		requireActiveBatch(state, canonical.header);
 		if (canonical.header.digest !== alias.canonicalBatchDigest || target.header.digest !== alias.targetBatchDigest || canonical.header.workId !== target.header.workId || target.header.id !== alias.targetBatchId) throw new ApplicationError("CORRUPTED_STATE");
 		if (!canonical.termPack) return [];
-		const packs = db.prepare(`SELECT p.payload_ref_json,p.request_hash,r.request_hash AS receipt_hash FROM journey_term_pack_batches m JOIN journey_term_packs p ON p.request_key=m.request_key LEFT JOIN journey_receipts r ON r.request_key=p.request_key AND r.journey_id=p.journey_id WHERE m.batch_id=? AND p.journey_id=? ORDER BY p.rowid`).all(canonical.header.id, input.journeyId).map((pack) => {
+		const packs = db.prepare(`SELECT p.payload_ref_json,p.request_hash,r.request_hash AS receipt_hash FROM journey_term_pack_batches m JOIN journey_term_packs p ON p.request_key=m.request_key LEFT JOIN journey_receipts r ON r.request_key=p.request_key AND r.journey_id=p.journey_id WHERE m.batch_id=? AND p.journey_id=?
+          AND NOT EXISTS (SELECT 1 FROM journey_resources w WHERE w.journey_id=p.journey_id AND w.kind='withdrawn-term-pack' AND w.id=m.batch_id||':'||json_extract(p.payload_ref_json,'$.packId')) ORDER BY p.rowid`).all(canonical.header.id, input.journeyId).map((pack) => {
 			if (typeof pack["payload_ref_json"] !== "string" || typeof pack["receipt_hash"] !== "string") throw new ApplicationError("CORRUPTED_STATE");
 			const reference = termPackReferenceSchema.parse(JSON.parse(pack["payload_ref_json"]));
 			if (reference.requestHash !== pack["request_hash"] || reference.requestHash !== pack["receipt_hash"]) throw new ApplicationError("CORRUPTED_STATE");
@@ -2307,6 +2358,107 @@ function selectScanAliases(db, input) {
 	});
 }
 //#endregion
+//#region packages/local-host/src/store/journey/terms/reopen.ts
+/** A permanent fence for an accepted pack whose empty coverage was withdrawn. */
+function withdrawnTermPack(db, journeyId, batchId, packId) {
+	return Boolean(db.prepare("SELECT 1 FROM journey_resources WHERE journey_id=? AND kind='withdrawn-term-pack' AND id=?").get(journeyId, batchId + ":" + packId));
+}
+function reopenEmptyReview(db, input) {
+	const state = requireReviewState(db, input.journeyId);
+	if (state.scope.status !== "confirmed" || ![
+		"processing",
+		"review",
+		"ready"
+	].includes(state.phase) || db.prepare("SELECT 1 FROM journey_current_send WHERE journey_id=?").get(input.journeyId)) throw new ApplicationError("INVALID_TRANSITION");
+	const row = db.prepare("SELECT * FROM journey_batches WHERE journey_id=? AND id=?").get(input.journeyId, input.batchId);
+	if (!row) throw new ApplicationError("UNKNOWN_ITEM");
+	const batch = parseStoredBatch(row);
+	const work = requireActiveBatch(state, batch.header);
+	if (work.access === "drop" || batch.header.digest !== input.batchDigest) throw new ApplicationError("REVISION_CONFLICT");
+	if (input.kind === "apply" && withdrawnTermPack(db, input.journeyId, input.batchId, input.expectedPackId)) return {
+		status: "replayed",
+		packId: input.expectedPackId
+	};
+	const ref = batch.termPack;
+	if (!ref || input.kind === "apply" && ref.packId !== input.expectedPackId) throw new ApplicationError("REVISION_CONFLICT");
+	if (db.prepare("SELECT 1 FROM journey_resources WHERE journey_id=? AND kind='scan-alias' AND id=?").get(input.journeyId, input.batchId)) throw new ApplicationError("INVALID_SELECTION");
+	const aliases = db.prepare(`SELECT b.*,a.json AS alias_json FROM journey_batches b ${activeBatchJoin}
+     JOIN journey_resources a ON a.journey_id=b.journey_id AND a.kind='scan-alias' AND a.id=b.id
+     WHERE b.journey_id=? AND json_extract(a.json,'$.canonicalBatchId')=?`).all(input.journeyId, input.batchId).map((row) => {
+		if (typeof row["alias_json"] !== "string") throw new ApplicationError("CORRUPTED_STATE");
+		const alias = scanAliasResourceSchema.parse(JSON.parse(row["alias_json"]));
+		const stored = parseStoredBatch(row);
+		const packId = scanAliasRequestKey(alias, ref.idempotencyKey);
+		if (stored.termPack && stored.termPack.packId !== packId) throw new ApplicationError("REVISION_CONFLICT");
+		return {
+			batch: stored,
+			packId
+		};
+	});
+	const attempts = [{
+		batch,
+		packId: ref.packId
+	}, ...aliases];
+	const targets = attempts.map((a) => a.batch).filter((b) => b.termPack);
+	for (const target of targets) {
+		const pointer = target.termPack;
+		if (!pointer || target.header.workId !== work.id) throw new ApplicationError("CORRUPTED_STATE");
+		const receipt = db.prepare(`SELECT p.request_hash, r.request_hash AS confirmed_hash, json_extract(p.json,'$.terms.kept') AS kept
+      FROM journey_term_packs p JOIN journey_receipts r ON r.journey_id=p.journey_id AND r.request_key=p.request_key
+      WHERE p.journey_id=? AND p.request_key=?`).get(input.journeyId, pointer.idempotencyKey);
+		if (!receipt || receipt["request_hash"] !== pointer.requestHash || receipt["confirmed_hash"] !== pointer.requestHash) throw new ApplicationError("CORRUPTED_STATE");
+		if (receipt["kept"] !== 0 || db.prepare("SELECT 1 FROM journey_term_occurrences WHERE journey_id=? AND batch_id=? LIMIT 1").get(input.journeyId, target.header.id)) throw new ApplicationError("INVALID_SELECTION");
+	}
+	if (input.kind === "inspect") return {
+		status: "eligible",
+		packId: ref.packId
+	};
+	if (work.completedBatches < targets.length) throw new ApplicationError("CORRUPTED_STATE");
+	for (const { batch: target, packId } of attempts) {
+		const id = target.header.id + ":" + packId;
+		db.prepare("INSERT INTO journey_resources VALUES(?,?,?,?)").run(input.journeyId, "withdrawn-term-pack", id, JSON.stringify({
+			kind: "withdrawn-term-pack",
+			id,
+			journeyId: input.journeyId,
+			batchId: target.header.id,
+			packId
+		}));
+		db.prepare("UPDATE journey_batches SET review_ref_json=NULL,review_sequence=NULL WHERE id=?").run(target.header.id);
+	}
+	if (commitJourney(db, {
+		state: {
+			...state,
+			readingComplete: false,
+			phase: "processing",
+			privacy: {
+				...state.privacy,
+				packageApproval: null,
+				confirmedAnswersRevision: null
+			},
+			works: state.works.map((item) => item.id === work.id ? {
+				...item,
+				status: "reading",
+				revision: item.revision + 1,
+				completedBatches: item.completedBatches - targets.length,
+				artifact: null
+			} : item)
+		},
+		expectedRevision: state.revision,
+		requestKey: input.idempotencyKey,
+		requestHash: textDigest(JSON.stringify(input)),
+		event: {
+			journeyId: input.journeyId,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			kind: "batch",
+			source: "conversation"
+		}
+	}).status !== "applied") throw new ApplicationError("REVISION_CONFLICT");
+	return {
+		status: "reopened",
+		packId: ref.packId
+	};
+}
+//#endregion
 //#region packages/local-host/src/store/journey/finding-groups.ts
 function findingPreference(db, key) {
 	const choice = db.prepare("SELECT choice FROM journey_preferences WHERE group_key=?").get(key)?.["choice"];
@@ -2442,6 +2594,7 @@ function selectTerms(db, query) {
 	const batches = input.units.map((unit) => {
 		const row = db.prepare("SELECT * FROM journey_batches WHERE journey_id=? AND id=?").get(input.journeyId, unit.batchId);
 		if (!row) throw new ApplicationError("UNKNOWN_ITEM");
+		if (withdrawnTermPack(db, input.journeyId, unit.batchId, input.packId)) throw new ApplicationError("REVISION_CONFLICT");
 		const batch = parseStoredBatch(row);
 		const alias = db.prepare("SELECT json FROM journey_resources WHERE journey_id=? AND kind='scan-alias' AND id=?").get(input.journeyId, unit.batchId);
 		if (alias) {
@@ -2449,7 +2602,9 @@ function selectTerms(db, query) {
 			const source = db.prepare("SELECT b.review_ref_json FROM journey_batches b WHERE b.journey_id=? AND b.id=json_extract(?,'$.canonicalBatchId')").get(input.journeyId, alias["json"]);
 			if (!source || source["review_ref_json"] === null) throw new ApplicationError("SCOPE_NOT_READY");
 		}
-		requireActiveBatch(state, batch.header);
+		const work = requireActiveBatch(state, batch.header);
+		if (work.access === "drop") throw new ApplicationError("REVISION_CONFLICT");
+		if (work.reviewInterruptions?.some((hold) => hold.inputRevision === work.inputRevision && hold.batchIds.includes(unit.batchId)) || db.prepare("SELECT 1 FROM journey_resources WHERE journey_id=? AND kind='closed-reader' AND id=?").get(state.journeyId, unit.batchId + ":" + input.packId)) throw new ApplicationError("REVISION_CONFLICT");
 		if (batch.header.digest !== unit.batchDigest) throw new ApplicationError("REVISION_CONFLICT");
 		return batch;
 	});
@@ -2613,7 +2768,8 @@ const termReuseSelectionSchema = z.object({
 */
 function selectTermReuse(db, input) {
 	const state = requireReviewState(db, input.journeyId);
-	const targets = db.prepare(`SELECT b.* FROM journey_batches b ${activeBatchJoin} WHERE b.journey_id=? AND b.work_id=? AND b.review_ref_json IS NULL ${notScanAlias} AND json_extract(b.header_json,'\$.unit.sessionId')=? ORDER BY b.rowid`).all(input.journeyId, input.workId, input.sessionId).map(parseStoredBatch).filter((batch) => isLegacyBatch(db, batch.header));
+	const targets = db.prepare(`SELECT b.* FROM journey_batches b ${activeBatchJoin} WHERE b.journey_id=? AND b.work_id=? AND b.review_ref_json IS NULL ${notScanAlias}
+      AND NOT EXISTS (SELECT 1 FROM journey_resources wr WHERE wr.journey_id=b.journey_id AND wr.kind='withdrawn-term-pack' AND json_extract(wr.json,'$.batchId')=b.id) AND json_extract(b.header_json,'\$.unit.sessionId')=? ORDER BY b.rowid`).all(input.journeyId, input.workId, input.sessionId).map(parseStoredBatch).filter((batch) => isLegacyBatch(db, batch.header));
 	if (!targets.length) return {
 		targets,
 		origins: []
@@ -3557,7 +3713,7 @@ function readInventoryFamilies(db, state) {
 //#endregion
 //#region packages/local-host/src/store/journey/resources.ts
 function saveJourneyResource(db, resource) {
-	if (resource.kind === "scan-canonical" || resource.kind === "scan-alias" || resource.kind === "b-attempt" || resource.kind === "preparation-start" || resource.kind === "preparation-settlement" || resource.kind === "b-usefulness" || resource.kind === "b-candidate" || resource.kind === "b-repair" || resource.kind === "b-session" || resource.kind === "b-reread" || resource.kind === "b-reconciliation" || resource.kind === "correction-report") throw new ApplicationError("INVALID_TRANSITION");
+	if (resource.kind === "closed-reader" || resource.kind === "withdrawn-term-pack" || resource.kind === "scan-canonical" || resource.kind === "scan-alias" || resource.kind === "b-attempt" || resource.kind === "preparation-start" || resource.kind === "preparation-settlement" || resource.kind === "b-usefulness" || resource.kind === "b-candidate" || resource.kind === "b-repair" || resource.kind === "b-session" || resource.kind === "b-reread" || resource.kind === "b-reconciliation" || resource.kind === "correction-report") throw new ApplicationError("INVALID_TRANSITION");
 	const state = readJourney(db, resource.journeyId);
 	if (!state?.consent) throw new ApplicationError("CONFIRMATION_REQUIRED");
 	if (state.pendingHideId && (resource.kind === "base" || resource.kind === "scan-session" || resource.kind === "static-session" || resource.kind === "output")) throw new ApplicationError("SCOPE_NOT_READY");
@@ -3644,6 +3800,64 @@ function readJourneyResources(db, input) {
 }
 //#endregion
 //#region packages/local-host/src/store/journey/preparation.ts
+function projection(fields) {
+	const sql = `SELECT state_json ->> '$.formatVersion' AS format, ${fields.map((key) => `state_json -> '$.${key}' AS "${key}"`).join(",")} FROM journey_runs WHERE id=?`;
+	return (db, journeyId) => {
+		const row = db.prepare(sql).get(journeyId);
+		if (!row) return null;
+		if (row["format"] !== 10) throw new StoreError("OBSOLETE_SCHEMA", "Stored Journey preparation format is obsolete.");
+		const result = {};
+		for (const key of fields) {
+			const value = row[key];
+			if (typeof value === "string") result[key] = JSON.parse(value);
+		}
+		return result;
+	};
+}
+const selectPermission = projection(preparationPermissionSchema.keyof().options);
+const selectState = projection(preparationStateSchema.keyof().options);
+function readPreparationPermission(db, journeyId) {
+	return preparationPermissionSchema.nullable().parse(selectPermission(db, journeyId));
+}
+function readPreparationState(db, journeyId) {
+	return preparationStateSchema.nullable().parse(selectState(db, journeyId));
+}
+/** Merge the small set of changed Work rows into the current state under its revision fence.
+* The normal commit owns its receipts, input generations, hide and correction invalidation. */
+function updatePreparation(db, input) {
+	const current = readJourney(db);
+	if (!current || current.journeyId !== input.journeyId) throw new ApplicationError("REVISION_CONFLICT");
+	const replacements = new Map(input.works.map((work) => [work.id, work]));
+	if (current.revision === input.expectedRevision && (replacements.size !== input.works.length || input.works.some((work) => !current.works.some((item) => item.id === work.id)))) throw new ApplicationError("INVALID_ARGUMENTS");
+	const result = commitJourney(db, {
+		expectedRevision: input.expectedRevision,
+		requestKey: input.requestKey,
+		requestHash: textDigest(JSON.stringify(input)),
+		event: {
+			journeyId: input.journeyId,
+			kind: input.kind,
+			source: "system",
+			at: input.at
+		},
+		state: {
+			...current,
+			works: current.works.map((work) => replacements.get(work.id) ?? work),
+			phase: input.phase,
+			readingComplete: input.readingComplete,
+			readingStartedAt: input.readingStartedAt,
+			privacy: input.clearPackageApproval ? {
+				...current.privacy,
+				packageApproval: null
+			} : current.privacy
+		}
+	});
+	const state = readPreparationState(db, result.state.journeyId);
+	if (!state) throw new ApplicationError("CORRUPTED_STATE");
+	return {
+		status: result.status,
+		state
+	};
+}
 function readPreparationReceipts(db, journeyId) {
 	const starts = [], settlements = [];
 	for (const row of db.prepare("SELECT kind,id,json FROM journey_resources WHERE journey_id=? AND kind IN ('preparation-start','preparation-settlement')").all(journeyId)) {
@@ -3665,9 +3879,9 @@ function activeScope(db, input, starting) {
 	if (state.pendingHideId) throw new ApplicationError("SCOPE_NOT_READY");
 	const work = state.works.find((item) => item.id === input.workId);
 	if (!work || input.inputRevision !== work.inputRevision || input.snapshotId !== state.snapshotId) throw new ApplicationError("REVISION_CONFLICT");
-	const plan = readInventoryPlan(db, state);
+	const { plan, families } = readInventoryFamilies(db, state);
 	if (!plan.approval.inventory.complete) throw new ApplicationError("CORRUPTED_STATE");
-	return preparationScope(plan.approval.inventory, work);
+	return preparationScope(plan.approval.inventory, work, families);
 }
 function insert(db, record) {
 	db.prepare("INSERT INTO journey_resources VALUES(?,?,?,?)").run(record.journeyId, record.kind, record.id, JSON.stringify(record));
@@ -3738,7 +3952,16 @@ function readJourneyPreparationProgress(db, input) {
 	const state = readFencedJourney(db, input);
 	if (!state.consent || !state.snapshotId) return null;
 	const { starts, settlements } = readPreparationReceipts(db, state.journeyId);
-	return projectPreparationProgress(state, readInventoryPlan(db, state), readCaptures(db, state.journeyId), starts, settlements);
+	const captures = db.prepare(`SELECT id, json_extract(json,'$.capture.partId') AS partId,
+    json_extract(json,'$.capture.facts.byteLength') AS bytes FROM journey_resources
+    WHERE journey_id=? AND kind='capture'`).all(state.journeyId).map(({ id, partId, bytes }) => {
+		if (id !== partId || typeof partId !== "string" || typeof bytes !== "number" || !Number.isSafeInteger(bytes) || bytes < 0) throw new ApplicationError("CORRUPTED_STATE");
+		return {
+			partId,
+			bytes
+		};
+	});
+	return projectPreparationProgress(state, readInventoryFamilies(db, state).families, captures, starts, settlements);
 }
 //#endregion
 //#region packages/local-host/src/store/journey/hide.ts
@@ -4544,14 +4767,6 @@ function finishJourneyPlacement(db, packet) {
 //#endregion
 //#region packages/local-host/src/store/journey/isolation.ts
 const reason = " – couldn't prepare";
-/** Stable blocked Work IDs per parent, so later failing roots join one instead of multiplying. */
-function isolatedWorkId(parentId, ordinal) {
-	const bytes = createHash("sha256").update(`isolated-roots:${parentId}:${ordinal}`).digest().subarray(0, 16);
-	bytes[6] = (bytes[6] ?? 0) & 15 | 64;
-	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
-	const hex = bytes.toString("hex");
-	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
 /**
 * Moves identified failing roots out of a pending multi-root Work into its visible blocked
 * Work, carrying their public-safe codes; the parent returns to pending for the rest.
@@ -4595,8 +4810,15 @@ function isolateJourneyRoots(db, input) {
 		})),
 		blocks: /* @__PURE__ */ new Map([[targetId, [...codes]]])
 	});
+	const classified = !existing && parent.classificationRecommendation && hasCompleteWorkDescription(parent) && !parent.suggestion ? {
+		description: parent.description,
+		classificationRecommendation: parent.classificationRecommendation,
+		reason: parent.classificationRecommendation.reason,
+		projectType: parent.projectType?.origin === "model" ? parent.projectType : null
+	} : {};
 	const works = next.works.map((work) => work.id === targetId ? {
 		...work,
+		...classified,
 		...access
 	} : work);
 	return commitJourney(db, commit(input, {
@@ -4724,9 +4946,197 @@ function finishJourneyDescription(db, packet) {
 }
 //#endregion
 //#region packages/local-host/src/store/journey/send.ts
+/** Run the privacy fence against the store's current immutable row on every request.
+* Only the approved output and this Work's frozen upload identities cross the worker boundary. */
+function readSendOutput(db, input) {
+	const { journeyId, workId, revision } = input;
+	const state = readJourney(db, journeyId);
+	if (!state?.consent) throw new ApplicationError("CONFIRMATION_REQUIRED");
+	if (state.phase === "completed" && state.outputVersion !== 1) throw new ApplicationError("SCOPE_NOT_READY");
+	assertJourneyPrivacyReady(state, true);
+	if (state.phase === "paused") throw new ApplicationError("OPERATION_CANCELED");
+	const work = state.works.find((item) => item.id === workId);
+	if (!work?.artifact || work.revision !== revision || work.artifact.revision !== revision) throw new ApplicationError("REVISION_CONFLICT");
+	const [output] = readJourneyResources(db, {
+		journeyId,
+		kind: "output",
+		id: `${workId}:${revision}`
+	});
+	if (output?.kind !== "output" || output.workId !== workId || output.revision !== revision || output.primary.sha256 !== work.artifact.sha256) throw new ApplicationError("ARTIFACT_IDENTITY_MISMATCH");
+	if (!input.sessions) return {
+		output,
+		identities: []
+	};
+	const [base] = readJourneyResources(db, {
+		journeyId,
+		kind: "base",
+		id: `${workId}:${output.finalMaskLedger.inputRevision}`
+	});
+	if (base?.kind !== "base" || base.workId !== workId || base.inputRevision !== output.finalMaskLedger.inputRevision || base.primary.sha256 !== output.finalMaskLedger.basePrimarySha256) throw new ApplicationError("ARTIFACT_IDENTITY_MISMATCH");
+	const plan = readInventoryPlan(db, state);
+	const sessions = new Map(plan.approval.inventory.sessions.map((session) => [session.id, session]));
+	const groups = /* @__PURE__ */ new Map();
+	const identities = base.sessions.map((binding) => {
+		const session = sessions.get(binding.applicationSessionId);
+		const part = session?.parts[0];
+		const lastAt = session?.lastInteractionAt ?? session?.createdAt;
+		if (!session || !part || !lastAt || !Number.isFinite(Date.parse(lastAt))) throw new ApplicationError("ARTIFACT_IDENTITY_MISMATCH");
+		const native = part.nativeEvidence?.identity;
+		if (native?.sessionId?.trim() && native.role !== "unknown" && (native.role !== "worker" || native.agentId?.trim() && session.harness === "claude")) {
+			const key = JSON.stringify([
+				session.harness,
+				native.sessionId,
+				native.role === "worker" ? native.agentId : null
+			]);
+			const group = groups.get(key) ?? [];
+			group.push(binding.archiveSessionId);
+			groups.set(key, group);
+		}
+		const nativeId = part.nativeEvidence?.identity?.sessionId ?? session.sourceSessionId;
+		const path = part.harnessRelativePath ?? "";
+		if (!path && !nativeId?.trim() || isAbsolute(path) || path.includes("\\") || path.split("/").some((segment) => segment === ".." || segment === ".")) throw new ApplicationError("ARTIFACT_IDENTITY_MISMATCH");
+		return {
+			archiveSessionId: binding.archiveSessionId,
+			relativePath: path,
+			lastAt: new Date(lastAt).toISOString()
+		};
+	});
+	const duplicates = [...groups.values()].filter((group) => group.length > 1);
+	if (!duplicates.length) return {
+		output,
+		identities
+	};
+	const duplicateIds = new Set(duplicates.flat());
+	const owners = new Map(base.sessions.map((s) => [s.archiveSessionId, s.applicationSessionId]));
+	const sources = base.sourceBindings.flatMap((binding) => {
+		if (!duplicateIds.has(binding.sessionId) || binding.bundleId !== base.bundleId || owners.get(binding.sessionId) !== binding.applicationSessionId) return [];
+		const part = sessions.get(binding.applicationSessionId)?.parts.find((p) => p.id === binding.sourcePartId);
+		return part ? [{
+			session: binding.sessionId,
+			source: binding.bundleSourceId,
+			part
+		}] : [];
+	});
+	const outputs = state.works.filter(isSelectedWork).flatMap((w) => w.artifact ? [{
+		workId: w.id,
+		revision: w.revision,
+		sha256: w.artifact.sha256,
+		bundleId: w.artifact.bundleId
+	}] : []);
+	const approval = state.privacy.packageApproval;
+	if (!approval) throw new ApplicationError("CONFIRMATION_REQUIRED");
+	return {
+		output,
+		identities,
+		extension: {
+			groups: duplicates,
+			sources,
+			outputs,
+			approval
+		}
+	};
+}
+const sendCurrentSchema = z.object({
+	journeyId: journeyIdSchema,
+	sendId: journeyIdSchema,
+	revision: z.number().int().nonnegative()
+}).strict();
+function isCurrentSend(db, input) {
+	return !!db.prepare(`SELECT 1 FROM journey_runs r JOIN journey_current_send s ON s.journey_id=r.id
+    JOIN journey_current c ON c.journey_id=r.id AND c.singleton=1
+    WHERE r.id=? AND r.revision=? AND s.send_id=?`).get(input.journeyId, input.revision, input.sendId);
+}
+const transferCountSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const sendTransferSchema = z.object({
+	journeyId: journeyIdSchema,
+	sendId: journeyIdSchema,
+	workId: journeyIdSchema,
+	expectedJourneyRevision: transferCountSchema,
+	expectedSendRevision: transferCountSchema,
+	storedSessions: transferCountSchema.optional(),
+	sessionUpload: sendSessionUploadSchema,
+	requestKey: journeyIdSchema,
+	at: z.iso.datetime()
+}).strict();
+const sendTransferResultSchema = z.discriminatedUnion("status", [z.object({
+	status: z.literal("applied"),
+	revision: transferCountSchema,
+	lastEvent: transferCountSchema,
+	sendRevision: transferCountSchema
+}).strict(), z.object({ status: z.enum(["stale", "replayed"]) }).strict()]);
+/** Update only transfer fields in the Send document and stamp its Journey revision/event. */
+function checkpointJourneySendTransfer(db, input) {
+	const requestHash = createHash("sha256").update(JSON.stringify(input)).digest("hex");
+	const receipt = db.prepare("SELECT request_hash,journey_id FROM journey_receipts WHERE request_key=?").get(input.requestKey);
+	if (receipt) {
+		if (receipt["request_hash"] !== requestHash || receipt["journey_id"] !== input.journeyId) throw new ApplicationError("OPERATION_CONFLICT");
+		return { status: "replayed" };
+	}
+	const row = db.prepare(`SELECT r.revision,r.state_json ->> '$.formatVersion' AS formatVersion,
+        r.state_json ->> '$.phase' AS phase,
+        json_type(r.state_json,'$.consent') AS consentType,
+        r.state_json ->> '$.pendingHideId' AS pendingHideId,
+        json_type(r.state_json,'$.abandonedAt') AS abandonedType,s.json
+      FROM journey_runs r
+      JOIN journey_current c ON c.singleton=1 AND c.journey_id=r.id
+      JOIN journey_current_send cs ON cs.journey_id=r.id AND cs.send_id=?
+      JOIN journey_sends s ON s.journey_id=r.id AND s.id=cs.send_id
+      WHERE r.id=?`).get(input.sendId, input.journeyId);
+	if (!row) return { status: "stale" };
+	const revisionValue = row["revision"];
+	if (typeof revisionValue !== "number" || !Number.isSafeInteger(revisionValue) || revisionValue < 0) throw new ApplicationError("CORRUPTED_STATE");
+	if (revisionValue !== input.expectedJourneyRevision) return { status: "stale" };
+	if (row["formatVersion"] !== 10) throw new StoreError("OBSOLETE_SCHEMA", "Stored native Journey state uses an obsolete candidate format and has been preserved.");
+	if (row["consentType"] !== "object") throw new ApplicationError("CONFIRMATION_REQUIRED");
+	if (row["phase"] !== "sending") throw new ApplicationError(row["phase"] === "paused" ? "OPERATION_CANCELED" : "INVALID_TRANSITION");
+	if (row["pendingHideId"] !== null && row["pendingHideId"] !== void 0) throw new ApplicationError("REVISION_CONFLICT");
+	if (row["abandonedType"] !== null && row["abandonedType"] !== void 0) throw new ApplicationError("INVALID_TRANSITION");
+	if (typeof row["json"] !== "string") throw new ApplicationError("CORRUPTED_STATE");
+	const send = journeySendSchema.parse(JSON.parse(row["json"]));
+	if (send.revision !== input.expectedSendRevision) return { status: "stale" };
+	if (!send.subject || !send.confirmedAt) throw new ApplicationError("CONFIRMATION_REQUIRED");
+	if (send.status === "paused") throw new ApplicationError("OPERATION_CANCELED");
+	if (!["sending", "waiting"].includes(send.status)) throw new ApplicationError("INVALID_TRANSITION");
+	const index = send.items.findIndex((item) => item.workId === input.workId);
+	if (index < 0) throw new ApplicationError("INVALID_SELECTION");
+	const item = send.items[index];
+	if (!item) throw new ApplicationError("CORRUPTED_STATE");
+	if (item.status !== "uploading") throw new ApplicationError("INVALID_TRANSITION");
+	const revision = revisionValue + 1;
+	const sendRevision = send.revision + 1;
+	const next = journeySendSchema.parse({
+		...send,
+		revision: sendRevision,
+		items: send.items.map((candidate, candidateIndex) => candidateIndex === index ? {
+			...candidate,
+			sessionUpload: input.sessionUpload,
+			...input.storedSessions === void 0 ? {} : { storedSessions: input.storedSessions }
+		} : candidate)
+	});
+	if (db.prepare("UPDATE journey_sends SET json=? WHERE journey_id=? AND id=?").run(JSON.stringify(next), input.journeyId, input.sendId).changes !== 1) throw new ApplicationError("REVISION_CONFLICT");
+	const inserted = db.prepare("INSERT INTO journey_events(journey_id,event_json) VALUES(?,?)").run(input.journeyId, JSON.stringify({
+		journeyId: input.journeyId,
+		revision,
+		kind: "send",
+		source: "system",
+		at: input.at
+	}));
+	const lastEvent = Number(inserted.lastInsertRowid);
+	if (!Number.isSafeInteger(lastEvent) || lastEvent < 1) throw new ApplicationError("CORRUPTED_STATE");
+	if (db.prepare(`UPDATE journey_runs SET revision=?,state_json=json_set(
+      state_json,'$.revision',?,'$.lastEvent',?) WHERE id=? AND revision=?`).run(revision, revision, lastEvent, input.journeyId, input.expectedJourneyRevision).changes !== 1) throw new ApplicationError("REVISION_CONFLICT");
+	db.prepare("INSERT INTO journey_receipts VALUES(?,?,?,?)").run(input.requestKey, requestHash, input.journeyId, revision);
+	return {
+		status: "applied",
+		revision,
+		lastEvent,
+		sendRevision
+	};
+}
 const sendLoadSchema = z.object({
 	journeyId: journeyIdSchema,
-	sendId: journeyIdSchema.optional()
+	sendId: journeyIdSchema.optional(),
+	observedRevision: z.number().int().nonnegative().optional()
 }).strict();
 const sendSnapshotSchema = z.object({
 	journey: nativeJourneySchema,
@@ -4747,6 +5157,7 @@ const sendCommitResultSchema = sendSnapshotSchema.extend({ status: z.enum([
 	"stale"
 ]) });
 function loadJourneySend(db, input) {
+	if (input.observedRevision !== void 0 && !input.sendId && db.prepare("SELECT 1 AS same FROM journey_runs WHERE id=? AND revision=?").get(input.journeyId, input.observedRevision)) return null;
 	const journey = readJourney(db, input.journeyId);
 	if (!journey) return null;
 	const row = input.sendId ? db.prepare("SELECT json FROM journey_sends WHERE journey_id=? AND id=?").get(input.journeyId, input.sendId) : db.prepare("SELECT json FROM journey_sends JOIN journey_current_send ON journey_sends.id=journey_current_send.send_id WHERE journey_current_send.journey_id=?").get(input.journeyId);
@@ -4784,6 +5195,7 @@ function commitJourneySend(db, input) {
 		...input.state,
 		revision
 	});
+	if (!prior && obsoleteJourney(current.journey)) throw new ApplicationError("JOURNEY_OBSOLETE");
 	const skipped = (workId) => current.journey.works.some((work) => work.id === workId && isSkippedWork(work));
 	const finished = send.status === "completed" && send.omitted.every((work) => [
 		"drop",
@@ -4858,7 +5270,10 @@ function admitScanSession(db, input) {
 	const state = readJourney(db, input.resource.journeyId);
 	if (!state) throw new ApplicationError("UNKNOWN_ITEM");
 	return {
-		state,
+		state: preparationStateSchema.strip().parse({
+			...state,
+			works: state.works.filter((work) => work.id === input.resource.workId)
+		}),
 		priors: input.headers.map((header) => admitReviewBatch(db, header))
 	};
 }
@@ -6867,6 +7282,9 @@ const operations = {
 	"journey.policy.respond": define(true, policyRespondSchema, respondJourneyPolicy, (value) => journeyCommitResultSchema.parse(value)),
 	"journey.policy.batches": define(false, policyBatchesSchema, selectPolicyBatches, (value) => z.array(z.uuid()).parse(value)),
 	"journey.send.load": define(false, sendLoadSchema, loadJourneySend, (value) => sendSnapshotSchema.nullable().parse(value)),
+	"journey.send.current": define(false, sendCurrentSchema, isCurrentSend, (value) => z.boolean().parse(value)),
+	"journey.send.transfer": define(true, sendTransferSchema, checkpointJourneySendTransfer, (value) => sendTransferResultSchema.parse(value)),
+	"journey.send.output": define(false, sendOutputQuerySchema, readSendOutput, (value) => sendOutputSchema.parse(value)),
 	"journey.send.commit": define(true, sendCommitSchema, commitJourneySend, (value) => sendCommitResultSchema.parse(value)),
 	"manual.upload.load": define(false, manualUploadLoadSchema, loadManualUpload, (value) => manualUploadSchema.nullable().parse(value)),
 	"manual.upload.commit": define(true, manualUploadCommitSchema, commitManualUpload, (value) => manualUploadResultSchema.parse(value)),
@@ -6884,13 +7302,34 @@ const operations = {
 	"journey.batch.put": define(true, batchPublicationSchema, putStoredBatch, nothing),
 	"journey.batch.admit": define(false, batchHeaderSchema, admitReviewBatch, (value) => storedBatchSchema.nullable().parse(value)),
 	"journey.scan.admit": define(true, scanAdmissionSchema, admitScanSession, (value) => z.object({
-		state: nativeJourneySchema,
+		state: preparationStateSchema,
 		priors: z.array(storedBatchSchema.nullable())
 	}).strict().parse(value)),
 	"journey.scan.put": define(true, scanBatchesSchema, putScanBatches, nothing),
 	"journey.batch.read": define(false, journeyBatchReadSchema, selectReviewBatch, (value) => batchSelectionSchema.parse(value)),
 	"journey.review.attempts": define(false, reviewAttemptsQuerySchema, readReviewAttempts, (value) => reviewAttemptsResultSchema.parse(value)),
+	"journey.preparation.state": define(false, z.object({ journeyId: z.uuid() }), (db, { journeyId }) => readPreparationState(db, journeyId), (value) => preparationStateSchema.nullable().parse(value)),
+	"journey.preparation.permission": define(false, z.object({ journeyId: z.uuid() }), (db, { journeyId }) => readPreparationPermission(db, journeyId), (value) => preparationPermissionSchema.nullable().parse(value)),
+	"journey.preparation.update": define(true, preparationUpdateSchema, updatePreparation, (value) => z.object({
+		status: z.enum([
+			"applied",
+			"stale",
+			"replayed"
+		]),
+		state: preparationStateSchema
+	}).strict().parse(value)),
+	"journey.receipt.revision": define(false, z.object({
+		journeyId: z.uuid(),
+		key: z.uuid(),
+		hash: z.string().regex(/^[0-9a-f]{64}$/u)
+	}).strict(), (db, { journeyId, key, hash }) => {
+		const row = db.prepare("SELECT journey_id,request_hash,revision FROM journey_receipts WHERE request_key=?").get(key);
+		if (!row) return null;
+		if (row["journey_id"] !== journeyId || row["request_hash"] !== hash) throw new ApplicationError("OPERATION_CONFLICT");
+		return z.number().int().nonnegative().parse(row["revision"]);
+	}, (value) => z.number().int().nonnegative().nullable().parse(value)),
 	"journey.current": define(false, z.object({ journeyId: z.uuid().optional() }), (db, input) => readJourney(db, input.journeyId), (value) => nativeJourneySchema.nullable().parse(value)),
+	"journey.terms.reopen-empty": define(true, emptyReviewCorrectionSchema, reopenEmptyReview, (value) => emptyReviewCorrectionResultSchema.parse(value)),
 	"journey.terms.select": define(false, termsQuerySchema, selectTerms, (value) => termsSelectionSchema.parse(value)),
 	"journey.terms.finish": define(true, termsFinishSchema, finishTerms, (value) => reviewTermsResultSchema.parse(value)),
 	"journey.terms.read": define(false, journeyTermsQuerySchema, readJourneyTerms, (value) => z.array(journeyTermSchema).parse(value)),
@@ -7412,4 +7851,4 @@ function assertStoreHeap(limitBytes = getHeapStatistics().heap_size_limit) {
 	return limitBytes;
 }
 //#endregion
-export { checkVersion as $, resourceSelectionQuerySchema as A, termReuseQuerySchema as B, loadAcceptedReview as C, aggregateUsefulness as D, loadPrivateResource as E, validateUnitCandidate as F, requireActiveBatch as G, batchHeader as H, reuseQuerySchema as I, validateDatabase as J, initializeAndClaim as K, batchQuery as L, evaluateUnitEvidence as M, sameCandidateRequest as N, sessionUsefulnessRecommendation as O, validateCandidateAttempt as P, validateState as Q, isPrivateResourceKind as R, validateSessionBindings as S, loadBatch as T, createJourneyPayloadFiles as U, privateReviewHash as V, validateBatchBody as W, readBundleDirectory as X, withDatabase as Y, readStoredState as Z, loadReconciliation as _, isCoordinationBusy as _t, decodeError as a, hasResetMarker as at, validatePreparationSelection as b, dropsAnchor as c, privatePath as ct, parseDelivery as d, stateDirectory as dt, schemaVersion as et, validateCandidate as f, syncDirectory as ft, loadPreparedBodies as g, errorCode as gt, loadPreparation as h, StoreError as ht, createExecutor as i, finishReset as it, inspectionQuerySchema as j, sessionQuery as k, replySchema as l, readResetMarker as lt, loadStatus as m, withFileCheckTimings as mt, releaseInheritedHeapFlags as n, createDatabaseFile as nt, ProtocolError as o, inspectStateFiles as ot, classificationJourneyCommit as p, withStateSnapshot as pt, ownership as q, storeHeapLimits as r, databaseName as rt, allowedReplies as s, present as st, assertStoreHeap as t, beginReset as tt, operations as u, recheckPrivatePath as ut, loadRereadBodies as v, isSqliteCorruption as vt, loadAuthenticatedReview as w, validateSessionReconciliation as x, loadSessionBodies as y, privateResourceHeader as z };
+export { validateState as $, resourceSelectionQuerySchema as A, termReuseQuerySchema as B, loadAcceptedReview as C, aggregateUsefulness as D, loadPrivateResource as E, validateUnitCandidate as F, validateBatchBody as G, privateReviewHash as H, reuseQuerySchema as I, ownership as J, requireActiveBatch as K, batchQuery as L, evaluateUnitEvidence as M, sameCandidateRequest as N, sessionUsefulnessRecommendation as O, validateCandidateAttempt as P, readStoredState as Q, isPrivateResourceKind as R, validateSessionBindings as S, loadBatch as T, batchHeader as U, scanAliasRequestKey as V, createJourneyPayloadFiles as W, withDatabase as X, validateDatabase as Y, readBundleDirectory as Z, loadReconciliation as _, errorCode as _t, decodeError as a, finishReset as at, validatePreparationSelection as b, dropsAnchor as c, present as ct, parseDelivery as d, recheckPrivatePath as dt, checkVersion as et, validateCandidate as f, stateDirectory as ft, loadPreparedBodies as g, StoreError as gt, loadPreparation as h, withFileCheckTimings as ht, createExecutor as i, databaseName as it, inspectionQuerySchema as j, sessionQuery as k, replySchema as l, privatePath as lt, loadStatus as m, withStateSnapshot as mt, releaseInheritedHeapFlags as n, beginReset as nt, ProtocolError as o, hasResetMarker as ot, classificationJourneyCommit as p, syncDirectory as pt, initializeAndClaim as q, storeHeapLimits as r, createDatabaseFile as rt, allowedReplies as s, inspectStateFiles as st, assertStoreHeap as t, schemaVersion as tt, operations as u, readResetMarker as ut, loadRereadBodies as v, isCoordinationBusy as vt, loadAuthenticatedReview as w, validateSessionReconciliation as x, loadSessionBodies as y, isSqliteCorruption as yt, privateResourceHeader as z };