@gitroll/tacitt-cli 0.6.12 → 0.6.14

package/skills/tacitt/scripts/journey.mjs

@@ -12,6 +12,7 @@ import {
   interruptedReviews,
   isIncluded,
   leftOutField,
+  accountFormationField,
   activeTerms,
   stageFingerprint,
   procedureFor,
@@ -87,6 +88,27 @@ async function prepareInitialFreeze(run, journeyId, call, view) {
   } catch (error) {
     // A large first freeze can outlast one helper command; captured roots persist for the rerun.
     if (error?.code === 'CLI_UNAVAILABLE') return { stage: 'freeze', status: 'running', startedAt }
+    // Every session is already on the profile or left out (ADR 0276): there is no Send.
+    if (error?.code === 'ACCOUNT_NOTHING_TO_SEND') {
+      const stopped = await call('journey.get', { journeyId })
+      return {
+        stage: 'freeze',
+        status: 'nothing-to-send',
+        startedAt,
+        ...accountFormationField(stopped),
+      }
+    }
+    if (['ACCOUNT_WORKS_UNAVAILABLE', 'ACCOUNT_SIGNED_OUT'].includes(error?.code)) {
+      const stopped = await call('journey.get', { journeyId })
+      if (stopped.accountReadRecovery)
+        return {
+          stage: 'freeze',
+          status: 'blocked',
+          startedAt,
+          accountReadRecovery: stopped.accountReadRecovery,
+          next: 'journey.prepare',
+        }
+    }
     throw error
   }
   const completed = await call('journey.get', { journeyId })
@@ -194,12 +216,16 @@ async function awaitDecision(run, journeyId, waitMs, call, sleep, ensureHost) {
         command: 'await',
         from,
         phase,
+        ...(view.accountReadRecovery
+          ? { accountReadRecovery: view.accountReadRecovery, next: 'journey.prepare' }
+          : {}),
         changed,
         waitedMs: Date.now() - started,
         revision: view.revision,
         blockedWorks: blocked,
         ...(held.length ? { interruptedReviews: held } : {}),
         ...leftOutField(view),
+        ...accountFormationField(view),
         ...(retried.length ? { retriedWorks: retried, next: 'journey.prepare' } : {}),
         ...(handoff ? { handoff: { panel: await ensureHost(), next: 'end-turn' } } : {}),
       }
@@ -212,7 +238,7 @@ async function runPhaseCore(
   { run, journeyId, command, stage, refresh = false, limit = 3, waitMs = 0, sleep, ensureHost },
   call,
 ) {
-  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 16) throw new Error('INVALID_ARGUMENTS')
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 24) throw new Error('INVALID_ARGUMENTS')
   // Append-batch consolidation uses immutable local drafts. No current journey view is
   // needed until publication; retain write recovery and live value settlement on that path.
   if (stage === 'cards' && !refresh && ['consolidate', 'ingest'].includes(command)) {
@@ -264,12 +290,16 @@ async function runPhaseCore(
         ? { classification: await classificationProgress(manifest) }
         : {}),
       phase: await currentPhase(run, view),
+      ...(view.accountReadRecovery
+        ? { accountReadRecovery: view.accountReadRecovery, next: 'journey.prepare' }
+        : {}),
       revision: view.revision,
       readingComplete: view.readingComplete,
       pending: activeTerms(view).filter((term) => term.disposition === 'pending').length,
       blockedWorks: blockedWorks(view),
       ...(interruptions.length ? { interruptedReviews: interruptions } : {}),
       ...leftOutField(view),
+      ...accountFormationField(view),
       answersRevision: view.privacy.answersRevision,
       ...packagingProgress(view),
       coldElapsedMs,

package/skills/tacitt/scripts/privacy-validator.mjs

@@ -5112,6 +5112,14 @@ function object(shape, params) {
 	};
 	return new ZodObject(def);
 }
+function strictObject(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape,
+		catchall: never(),
+		...normalizeParams(params)
+	});
+}
 function looseObject(shape, params) {
 	return new ZodObject({
 		type: "object",
@@ -5400,7 +5408,7 @@ const range = object({
 	start: number().int().nonnegative(),
 	end: number().int().nonnegative()
 }).strict();
-const digest$3 = string().regex(/^[a-f0-9]{64}$/u);
+const digest$4 = string().regex(/^[a-f0-9]{64}$/u);
 /** Original static title mask provenance for keyword-only preview/packaging. */
 const classificationTitleMaskSchema = object({
 	inputRange: range,
@@ -5417,14 +5425,66 @@ const classificationTitleMaskSchema = object({
 	originalPointer: string().nullable(),
 	outputPointer: string().nullable(),
 	sourceRange: range.nullable(),
-	inputSha256: digest$3,
-	outputSha256: digest$3,
+	inputSha256: digest$4,
+	outputSha256: digest$4,
 	context: object({
 		start: number().int().nonnegative(),
 		text: string()
 	}).strict()
 }).strict();
 //#endregion
+//#region packages/application/src/journey/account-works.ts
+const digest$3 = string().regex(/^[0-9a-f]{64}$/u);
+const stored = object({
+	/** Wire field from issue #131; a formation reply without it is read as no stored metadata. */
+	metadataSha256: digest$3.nullish().transform((value) => value ?? null),
+	key: digest$3,
+	sessionKey: string().regex(/^sess-pilot\/[^/]+\/[^/]+\/[^/]+$/u).nullable(),
+	sha256: digest$3,
+	byteLength: number().int().positive(),
+	lastAt: datetime()
+});
+const access = _enum([
+	"public",
+	"private",
+	"removed"
+]);
+const accountWorksInventorySchema = object({
+	works: array(object({
+		logicalWorkId: uuid(),
+		title: string().min(1).max(300),
+		access,
+		unitAccess: access,
+		sessions: array(stored)
+	})),
+	unassigned: array(stored.extend({ removedFromWork: uuid().nullish().transform((value) => value ?? null) }))
+});
+const accountWorksSchema = discriminatedUnion("status", [
+	strictObject({
+		status: literal("read"),
+		subject: string().min(1).max(128),
+		at: datetime(),
+		inventory: accountWorksInventorySchema,
+		/** Families with a key unassigned after its Work's removal: no Work, not sent (D4). */
+		leftOut: array(strictObject({
+			rootSessionId: string().min(1).max(128),
+			removedWorkId: uuid()
+		})).default([]),
+		/** Families with a held key that are not cleanly placed: no Work, not sent (D9). */
+		heldBack: array(string().min(1).max(128)).default([]),
+		/** Every family was left out or held back: no Work and no snapshot (#129 review). */
+		nothingToSend: literal(true).optional()
+	}),
+	strictObject({
+		status: literal("signed-out"),
+		at: datetime()
+	}),
+	strictObject({
+		status: literal("unavailable"),
+		at: datetime()
+	})
+]);
+//#endregion
 //#region packages/application/src/journey/profile.ts
 /**
 * Passport's own rules (talent-platform `profile-settings.ts`): 1 to 39 letters and digits with
@@ -9833,6 +9893,8 @@ const decisionCardSchema = decisionCardInputSchema.extend({ answer: object({
 	rule: string().max(4001),
 	additionalRule: string().max(2e3),
 	remember: boolean(),
+	/** Where the answer came from; only the person's panel Hide is remembered (issue #126). */
+	source: _enum(["conversation", "panel"]).optional(),
 	excludedTermKeys: array(string().min(1)).max(2e4).optional()
 }).strict().nullable() }).strict();
 const journeyPrivacySchema = object({
@@ -10165,7 +10227,8 @@ const reviewInterruptionSchema = object({
 }).strict();
 const journeyWorkSchema = object({
 	id: journeyIdSchema,
-	title: label,
+	/** 240 characters; an `account` title holds the server's 300 (ADR 0276 D2). */
+	title: string().trim().min(1).max(300),
 	/** Statically processed repository or folder name; the original stays in the private plan. */
 	projectName: label,
 	projectType: journeyWorkTypeSchema.nullable(),
@@ -10181,7 +10244,11 @@ const journeyWorkSchema = object({
 		description: string(),
 		reason: string()
 	}).strict().optional(),
-	titleOrigin: _enum(["model", "explicit"]),
+	titleOrigin: _enum([
+		"model",
+		"explicit",
+		"account"
+	]),
 	explicitTitleId: journeyIdSchema.nullable(),
 	accessOrigin: _enum([
 		"default",
@@ -10219,6 +10286,8 @@ const journeyWorkSchema = object({
 	inputRevision: count$1.min(1),
 	/** Placement created this Work (create-work or a sorting "new" decision): its name is generic. */
 	createdByPlacement: literal(true).optional(),
+	/** Rebuilt at formation from the account Work with this id (ADR 0276 D1); never classified. */
+	accountWork: literal(true).optional(),
 	/** Host-owned eligibility after removal-only regrouping; never authorizes output by itself. */
 	reviewReuseFrom: object({
 		inputRevision: count$1.min(1),
@@ -10274,7 +10343,7 @@ const journeyWorkSchema = object({
 		sentBundleId: journeyIdSchema.optional(),
 		sentAccess: _enum(["public", "private"]).optional()
 	}).strict().nullable()
-}).strict();
+}).strict().refine((work) => work.titleOrigin === "account" || work.title.length <= 240, { path: ["title"] });
 const journeyConsentSchema = object({
 	provider: label,
 	allowedAt: datetime(),
@@ -10296,7 +10365,7 @@ const journeyExceptionSchema = object({
 	value: string().min(1).max(1024)
 }).strict();
 object({
-	formatVersion: literal(10),
+	formatVersion: literal([10, 11]),
 	outputVersion: number().int().positive().optional(),
 	classificationRevision: count$1.nullable(),
 	privacy: journeyPrivacySchema,
@@ -10340,6 +10409,11 @@ object({
 	/** ADR 0086: per-value Hide or Keep over the term types' answers; absent means none. */
 	valueOverrides: array(journeyValueOverrideSchema).max(1e4).optional(),
 	/**
+	* Values the person hid in earlier journeys on this machine, frozen at formation (issue #126).
+	* Private: never in a view, reader guidance or anything sent.
+	*/
+	rememberedHides: array(string().min(1).max(1024)).max(1e5).optional(),
+	/**
 	* ADR 0086: the snapshot is read by dictionary review. A snapshot without it was read by B
 	* review, whose evidence this release no longer renders, so it is obsolete.
 	*/
@@ -10361,6 +10435,8 @@ object({
 	* confirmation and Retry set `read`; late classification records only a failure. Absent in a
 	* journey of an earlier version, which reads as not `read`.
 	*/
+	/** Formation read only; never establishes access proof. */
+	accountWorks: accountWorksSchema.optional(),
 	accountRead: object({
 		status: _enum([
 			"read",
@@ -10644,43 +10720,82 @@ object({
 reviewBatchSchema.omit({ digest: true });
 //#endregion
 //#region packages/application/src/journey/terms/locate.ts
-/** NFC core text of each analysed field, contiguous core chunks joined, with its Work. */
-function coreTexts(batches) {
-	const texts = [];
+/**
+* Issue #140: per batch and field, contiguous core and context chunks in offset order, never
+* joined across fields, field revisions or gaps. A core boundary maps to the NFC length of the
+* text before it.
+*/
+function* termSearchRuns(batches) {
 	for (const batch of batches) {
-		const fields = Map.groupBy(batch.chunks.filter((chunk) => chunk.core), (chunk) => JSON.stringify([chunk.fieldId, chunk.fieldHash]));
-		for (const chunks of fields.values()) {
-			let end = -1, text = "";
-			for (const chunk of chunks.toSorted((a, b) => a.offset - b.offset)) {
-				if (chunk.offset !== end && text) {
-					texts.push({
-						workId: batch.workId,
-						text: text.normalize("NFC")
-					});
-					text = "";
+		const fields = Map.groupBy(batch.chunks, (chunk) => JSON.stringify([chunk.fieldId, chunk.fieldHash]));
+		for (const group of fields.values()) {
+			let run = [];
+			const runs = [run];
+			for (const chunk of group.toSorted((a, b) => a.offset - b.offset)) {
+				const last = run.at(-1);
+				if (last && last.offset + last.text.length !== chunk.offset) runs.push(run = []);
+				run.push(chunk);
+			}
+			for (const chunks of runs) {
+				if (!chunks.some((chunk) => chunk.core)) continue;
+				const raw = chunks.map((chunk) => chunk.text).join("");
+				const text = raw.normalize("NFC");
+				const at = (end) => Math.min(text.length, raw.slice(0, end).normalize("NFC").length);
+				const cores = [];
+				let offset = 0;
+				for (const chunk of chunks) {
+					const start = offset;
+					offset += chunk.text.length;
+					if (!chunk.core) continue;
+					const last = cores.at(-1);
+					if (last && last[1] === start) last[1] = offset;
+					else cores.push([start, offset]);
 				}
-				text += chunk.text;
-				end = chunk.offset + chunk.text.length;
+				yield {
+					batch,
+					chunks,
+					text,
+					cores: cores.map(([start, end]) => [at(start), at(end)])
+				};
 			}
-			if (text) texts.push({
-				workId: batch.workId,
-				text: text.normalize("NFC")
-			});
 		}
 	}
-	return texts;
 }
-function occurrences(text, term) {
-	let count = 0;
-	for (let at = text.indexOf(term); at >= 0; at = text.indexOf(term, at + term.length)) count++;
-	return count;
+/**
+* Occurrences of `value` in a run: `owned` counts non-overlapping occurrences that start in a
+* core range; `first` is the first occurrence overlapping a core range, or -1. An occurrence that
+* starts outside the core is skipped by one position only, so it never hides an owned one.
+*/
+function runOccurrences(run, value) {
+	let owned = 0, first = -1;
+	if (!value) return {
+		owned,
+		first
+	};
+	for (let at = run.text.indexOf(value); at >= 0;) {
+		const end = at + value.length;
+		if (run.cores.some(([start, stop]) => at >= start && at < stop)) {
+			owned++;
+			if (first < 0) first = at;
+			at = run.text.indexOf(value, end);
+			continue;
+		}
+		if (first < 0 && run.cores.some(([start, stop]) => at < stop && end > start)) first = at;
+		at = run.text.indexOf(value, at + 1);
+	}
+	return {
+		owned,
+		first
+	};
 }
 /**
-* ADR 0086: a value is kept only if it occurs verbatim (NFC, case-sensitive) in a core chunk of
-* the pack's units; its complete admitted NFC value becomes one dictionary entry (ADR 0088).
+* ADR 0086, refined by issue #140: a value is kept only if it occurs verbatim (NFC,
+* case-sensitive) in a pack field's contiguous core and context text, overlapping a core chunk;
+* only occurrences that start in a core chunk are counted. Its complete admitted NFC value
+* becomes one dictionary entry (ADR 0088).
 */
 function locateTerms(batches, terms) {
-	const texts = coreTexts(batches);
+	const runs = [...termSearchRuns(batches)];
 	const located = /* @__PURE__ */ new Map();
 	const unlocatedIndices = [];
 	let kept = 0, unlocated = 0;
@@ -10693,20 +10808,25 @@ function locateTerms(batches, terms) {
 		}];
 	}));
 	for (const { type, value, index } of unique.values()) {
-		if (value.includes("█") || admitCustomTerm(value)?.value !== value || !texts.some((item) => item.text.includes(value))) {
+		let count = 0;
+		let workId;
+		if (!value.includes("█") && admitCustomTerm(value)?.value === value) for (const run of runs) {
+			const { owned, first } = runOccurrences(run, value);
+			if (first < 0) continue;
+			count += owned;
+			workId ??= run.batch.workId;
+		}
+		if (workId === void 0) {
 			unlocated++;
 			unlocatedIndices.push(index);
 			continue;
 		}
 		kept++;
-		const holders = texts.filter((item) => item.text.includes(value));
-		const first = holders[0];
-		if (!first) continue;
 		located.set(JSON.stringify([type, value]), {
 			type,
 			value,
-			count: holders.reduce((sum, item) => sum + occurrences(item.text, value), 0),
-			workId: first.workId
+			count,
+			workId
 		});
 	}
 	return {

package/skills/tacitt/scripts/review.d.mts

@@ -85,4 +85,5 @@ export function writePackTask(
     }[]
   }[],
   attemptId?: string,
+  reader?: { readerId?: string; readerTurn?: string; repair?: boolean },
 ): Promise<string>