@gitroll/tacitt-cli 0.6.1 → 0.6.2

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { _ as readStateDump, a as readAgentPresence, b as traceStartup, d as helpText, f as parseOptions, g as startupFailure, h as permissionDiagnostic, i as invoke, l as awaitingPassport, m as longCommands, n as readOperation, o as createRuntime, p as businessCommands, r as waitOperation, s as executorEventSchema, t as cancelOperation, u as createRenderActivity, v as createExecutionPort, y as startHost$1 } from "./query-BlisHJtP.mjs";
+import { _ as readStateDump, a as readAgentPresence, b as traceStartup, d as helpText, f as parseOptions, g as startupFailure, h as permissionDiagnostic, i as invoke, l as awaitingPassport, m as longCommands, n as readOperation, o as createRuntime, p as businessCommands, r as waitOperation, s as executorEventSchema, t as cancelOperation, u as createRenderActivity, v as createExecutionPort, y as startHost$1 } from "./query-CQ6Tr5zC.mjs";
 import { nt as makePrivateDirectory, rt as openPrivateFile } from "./src-JoT3L94j.mjs";
 import { $t as safeField, Qt as safeCode, Xt as ApplicationError } from "./locate-JYtFmKu-.mjs";
 import { Zn as reviewTransportBytes, et as readWorkspaceOutcomes, oi as stateSchema, st as resolveFailureLocation } from "./src--Ln5GHdz.mjs";

package/dist/operation-executor.mjs

@@ -1,4 +1,4 @@
-import { c as executorRequestSchema, f as parseOptions, g as startupFailure, i as invoke, m as longCommands, n as readOperation, o as createRuntime, r as waitOperation } from "./query-BlisHJtP.mjs";
+import { c as executorRequestSchema, f as parseOptions, g as startupFailure, i as invoke, m as longCommands, n as readOperation, o as createRuntime, r as waitOperation } from "./query-CQ6Tr5zC.mjs";
 import { $t as safeField, Qt as safeCode, Xt as ApplicationError } from "./locate-JYtFmKu-.mjs";
 import "./src--Ln5GHdz.mjs";
 import { z } from "zod";

package/dist/{query-BlisHJtP.mjs → query-CQ6Tr5zC.mjs}

@@ -13,7 +13,8 @@ import { execFile, spawn } from "node:child_process";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { createInterface } from "node:readline";
 import { Writable } from "node:stream";
-import { parseArgs, promisify, types } from "node:util";
+import { isDeepStrictEqual, parseArgs, promisify, types } from "node:util";
+import { pathToFileURL } from "node:url";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { fastify } from "fastify";
@@ -10275,6 +10276,27 @@ async function* sessionArtifacts(storage, find, journeyId, artifact, signal) {
 		}
 	};
 }
+/** Own one live upload iterator; advancing it releases the preceding session ZIP. */
+async function prepareSessionArtifacts(storage, find, journeyId, artifact, signal) {
+	const source = sessionArtifacts(storage, find, journeyId, artifact, signal);
+	let closed = false;
+	async function* iterate() {
+		try {
+			yield* source;
+		} finally {
+			closed = true;
+		}
+	}
+	const items = iterate();
+	return {
+		items,
+		async close() {
+			if (closed) return;
+			closed = true;
+			await items.return(void 0);
+		}
+	};
+}
 //#endregion
 //#region apps/cli/src/journey/send-artifacts.ts
 function createJourneySendArtifacts(storage) {
@@ -10293,6 +10315,7 @@ function createJourneySendArtifacts(storage) {
 		return output;
 	}
 	return {
+		prepareSessions: (journeyId, artifact, signal) => prepareSessionArtifacts(storage, find, journeyId, artifact, signal),
 		sessions: (journeyId, artifact, signal) => sessionArtifacts(storage, find, journeyId, artifact, signal),
 		async describe(journey, work, signal) {
 			const output = await find(journey.journeyId, work.id, work.revision);
@@ -10377,6 +10400,74 @@ async function putPrimary(primary, byteLength, upload, signal) {
 	}
 }
 //#endregion
+//#region apps/cli/src/account/journey/session-preparation.ts
+/** Phase-local facts retain no bytes; only upload steps acquire live iterators. */
+function createSessionPreparation(dependencies) {
+	const prepare = dependencies.artifacts.prepareSessions;
+	const prepared = [];
+	const facts = /* @__PURE__ */ new Map();
+	const sessions = async function* (journeyId, artifact, signal) {
+		if (!prepare) {
+			const original = dependencies.artifacts.sessions;
+			if (original) yield* original(journeyId, artifact, signal);
+			return;
+		}
+		const result = await prepare(journeyId, artifact, signal);
+		prepared.push(result);
+		for await (const item of result.items) {
+			signal.throwIfAborted();
+			yield item;
+		}
+	};
+	const sessionFacts = async function* (journeyId, artifact, signal) {
+		const key = JSON.stringify([
+			journeyId,
+			artifact.workId,
+			artifact.revision,
+			artifact.sha256
+		]);
+		let pending = facts.get(key);
+		if (!pending) {
+			pending = (async () => {
+				const original = dependencies.artifacts.sessionFacts ?? dependencies.artifacts.sessions;
+				const items = [];
+				if (original) for await (const item of original(journeyId, artifact, signal)) {
+					const { nativeSessionId, relativePath, harness, lastAt, metadata, sha256, byteLength, crc32 } = item;
+					items.push({
+						nativeSessionId,
+						relativePath,
+						harness,
+						lastAt,
+						metadata,
+						sha256,
+						byteLength,
+						crc32
+					});
+				}
+				return items;
+			})();
+			facts.set(key, pending);
+		}
+		for (const item of await pending) {
+			signal.throwIfAborted();
+			yield item;
+		}
+	};
+	return {
+		dependencies: {
+			...dependencies,
+			artifacts: {
+				...dependencies.artifacts,
+				sessions,
+				sessionFacts
+			}
+		},
+		async close() {
+			await createCleanup().run(...prepared.map((result) => () => result.close()));
+		}
+	};
+}
+//#endregion
 //#region apps/cli/src/account/journey/session-key.ts
 /** Engine native identity, or harness-root-relative path identity when native identity is absent. */
 async function sessionKeyFor(input) {
@@ -10395,12 +10486,25 @@ async function sessionKeyFor(input) {
 //#region apps/cli/src/account/journey/session-access.ts
 /** Check the entire pending Send before admitting any session mutation. */
 async function sessionAccessBlocked(dependencies, journeyId, items, inventory, signal) {
-	const sessions = dependencies.artifacts.sessions;
+	const sessions = dependencies.artifacts.sessionFacts ?? dependencies.artifacts.sessions;
 	if (!sessions) return false;
 	const requestedAccess = /* @__PURE__ */ new Map();
 	const requestedDigests = /* @__PURE__ */ new Map();
 	for (const item of items) {
-		if (item.sessionAssembly || item.status === "completed") continue;
+		if (item.status === "blocked" || item.sessionAssembly || !item.sessionMembership) continue;
+		const destination = inventory.works.find((work) => work.logicalWorkId === item.workId);
+		if (destination?.access === "removed") throw new ApplicationError("WORK_REMOVED");
+		for (const key of item.sessionMembership.keys) {
+			const access = requestedAccess.get(key);
+			if (access !== void 0 && access !== item.access) return true;
+			requestedAccess.set(key, item.access);
+			const source = inventory.works.find((work) => work.sessions.some((entry) => entry.key === key));
+			if (source && source.logicalWorkId !== item.workId && source.access !== item.access) return true;
+			if (destination && destination.access !== item.access && !destination.sessions.some((entry) => entry.key === key)) return true;
+		}
+	}
+	for (const item of items) {
+		if (item.sessionAssembly || item.sessionMembership || ["completed", "blocked"].includes(item.status)) continue;
 		const destination = inventory.works.find((work) => work.logicalWorkId === item.workId);
 		if (destination?.access === "removed") throw new ApplicationError("WORK_REMOVED");
 		for await (const session of sessions(journeyId, item.artifact, signal)) {
@@ -10420,14 +10524,14 @@ async function sessionAccessBlocked(dependencies, journeyId, items, inventory, s
 }
 /** Keep overlapping session ownership serial through membership, including retained members. */
 async function sessionIndependentItems(dependencies, journeyId, items, inventory, signal) {
-	const sessions = dependencies.artifacts.sessions;
+	const sessions = dependencies.artifacts.sessionFacts ?? dependencies.artifacts.sessions;
 	if (!sessions) return [];
 	const pending = items.filter((item) => item.status === "uploading" || item.status === "ready").toSorted((left, right) => Number(right.status === "uploading") - Number(left.status === "uploading") || right.artifact.byteLength - left.artifact.byteLength);
 	const claimed = /* @__PURE__ */ new Set();
 	const independent = [];
 	for (const item of pending) {
 		const keys = /* @__PURE__ */ new Set([...inventory.works.find((work) => work.logicalWorkId === item.workId)?.sessions.map((session) => session.key) ?? [], ...item.sessionMembership?.keys ?? []]);
-		for await (const session of sessions(journeyId, item.artifact, signal)) keys.add(await sessionKeyFor(session));
+		if (!item.sessionMembership && !item.sessionAssembly) for await (const session of sessions(journeyId, item.artifact, signal)) keys.add(await sessionKeyFor(session));
 		if (![...keys].some((key) => claimed.has(key))) independent.push(item);
 		for (const key of keys) claimed.add(key);
 	}
@@ -11188,7 +11292,7 @@ function renewed(item, error) {
 //#endregion
 //#region apps/cli/src/account/journey/session-step.ts
 /** Reconcile against completed server facts on every retry, including after process loss. */
-async function stepSessionWork(dependencies, journeyId, context, item, connection, signal) {
+async function stepSessionWork(dependencies, journeyId, context, item, connection, signal, checkpoint) {
 	const remote = connection.sessions;
 	const sessions = dependencies.artifacts.sessions;
 	if (!remote || !sessions) throw new ApplicationError("INVALID_STATE");
@@ -11267,7 +11371,6 @@ async function stepSessionWork(dependencies, journeyId, context, item, connectio
 			throw error;
 		}
 	}
-	const assembly = await remote.assembly(item.workId, signal);
 	const inventory = await remote.inventory(signal);
 	const stored = new Map([...inventory.unassigned, ...inventory.works.flatMap((work) => work.sessions)].map((session) => [session.key, session]));
 	const keys = [];
@@ -11283,13 +11386,17 @@ async function stepSessionWork(dependencies, journeyId, context, item, connectio
 			lastAt: session.lastAt,
 			harness: session.harness
 		};
-		if (item.sessionUpload?.key !== key || item.sessionUpload.sha256 !== session.sha256) return {
-			...item,
-			sessionUpload: {
-				key,
-				sha256: session.sha256
-			}
-		};
+		if (item.sessionUpload?.key !== key || item.sessionUpload.sha256 !== session.sha256) {
+			await guard();
+			item = {
+				...item,
+				sessionUpload: {
+					key,
+					sha256: session.sha256
+				}
+			};
+			await checkpoint(item);
+		}
 		await guard();
 		try {
 			await remote.complete({
@@ -11311,13 +11418,14 @@ async function stepSessionWork(dependencies, journeyId, context, item, connectio
 			}
 		}
 		await guard();
-		return {
+		item = {
 			...item,
 			sessionUpload: null
 		};
 	}
 	await guard();
-	const current = inventory.works.find((work) => work.logicalWorkId === item.workId);
+	const assembly = await remote.assembly(item.workId, signal);
+	const current = (await remote.inventory(signal)).works.find((work) => work.logicalWorkId === item.workId);
 	if (current && current.access !== item.access) {
 		const resolution = await connection.resolve(resolveInput(item, context.bindingId), signal);
 		const [candidate] = resolution.candidates;
@@ -11558,9 +11666,12 @@ async function captureProfile(connection, guard, signal, failure) {
 //#region apps/cli/src/account/journey/advance.ts
 /** A Work Passport is done with: assessed, or stopped unless Resume retries it. */
 const settled = (item) => ["completed", "blocked"].includes(item.status);
+/** Stored state equality: key order and explicit undefined fields do not count. */
+const sameJson = (left, right) => isDeepStrictEqual(JSON.parse(JSON.stringify(left)), JSON.parse(JSON.stringify(right)));
 /** The stored Send still holds exactly this Work state, whatever else changed meanwhile. */
 function sameItem(items, item) {
-	return JSON.stringify(items.find((value) => value.workId === item.workId)) === JSON.stringify(item);
+	const current = items.find((value) => value.workId === item.workId);
+	return current !== void 0 && sameJson(current, item);
 }
 /** Shared sign-in, account and per-item rules for native Send and Manual upload. */
 async function advanceItems(host, signal) {
@@ -11679,7 +11790,7 @@ async function advanceItems(host, signal) {
 			status: "sign-in",
 			error: null
 		});
-		if (JSON.stringify(items) === JSON.stringify(send.items) && send.error === error) return host.applied();
+		if (sameJson(items, send.items) && send.error === error) return host.applied();
 		return host.save(aggregate({
 			...send,
 			error,
@@ -11737,7 +11848,7 @@ function completeAtUpload(send, sessions) {
 	};
 }
 async function advanceSend(dependencies, address, signal, chain) {
-	const snapshot = requireSend(await dependencies.storage.loadSend(address.journeyId, address.sendId));
+	let snapshot = requireSend(await dependencies.storage.loadSend(address.journeyId, address.sendId));
 	if (chain) chain.revision = snapshot.send.revision;
 	if ((await dependencies.storage.loadSend(address.journeyId))?.send?.id !== snapshot.send.id) return {
 		...snapshot,
@@ -11748,13 +11859,36 @@ async function advanceSend(dependencies, address, signal, chain) {
 		...snapshot,
 		status: "applied"
 	};
-	const save = (next) => !completed ? saveSend(dependencies, snapshot, completeAtUpload(next, usesSessionSend(dependencies, next))) : JSON.stringify(next.items) === JSON.stringify(snapshot.send.items) ? Promise.resolve({
-		...snapshot,
-		status: "applied"
-	}) : saveSend(dependencies, snapshot, {
-		...snapshot.send,
-		items: next.items
-	});
+	const checkpoints = /* @__PURE__ */ new Map();
+	const fulfilled = /* @__PURE__ */ new Set();
+	let saving = Promise.resolve();
+	async function active(item) {
+		const current = requireSend(await dependencies.storage.loadSend(address.journeyId));
+		if (current.send.id !== snapshot.send.id || !sameItem(current.send.items, checkpoints.get(item.workId) ?? item) || current.send.status === "paused" || current.journey.phase === "paused") throw new ApplicationError("REVISION_CONFLICT");
+		assertScope(current.journey, current.send);
+		return current;
+	}
+	const save = (proposed) => {
+		const next = {
+			...proposed,
+			items: proposed.items.map((item) => {
+				const checkpoint = checkpoints.get(item.workId);
+				return checkpoint && !fulfilled.has(item.workId) ? {
+					...checkpoint,
+					...item,
+					sessionUpload: checkpoint.sessionUpload
+				} : item;
+			})
+		};
+		return !completed ? saveSend(dependencies, snapshot, completeAtUpload(next, usesSessionSend(dependencies, next))) : sameJson(next.items, snapshot.send.items) ? Promise.resolve({
+			...snapshot,
+			status: "applied"
+		}) : saveSend(dependencies, snapshot, {
+			...snapshot.send,
+			items: next.items
+		});
+	};
+	const send = withoutQuestions(snapshot.send);
 	try {
 		assertScope(snapshot.journey, snapshot.send);
 	} catch (error) {
@@ -11776,67 +11910,94 @@ async function advanceSend(dependencies, address, signal, chain) {
 		...snapshot,
 		status: "applied"
 	};
-	const send = withoutQuestions(snapshot.send);
 	if (send !== snapshot.send) return save(send);
 	let independentItems = [];
-	return advanceItems({
-		send,
-		failure: dependencies.failure,
-		...usesSessionSend(dependencies, send) ? {
-			batch: () => {
-				const limit = send.parallelCompletes ? 3 : 1;
-				return independentItems.length ? pickBatch(independentItems, Date.now(), limit) : pickBatch(send.items, Date.now(), limit);
-			},
-			preflight: async (connection, preflightSignal) => {
-				if (!connection.sessions) throw new ApplicationError("INVALID_STATE");
-				const inventory = await connection.sessions.inventory(preflightSignal);
-				if (!await sessionAccessBlocked(dependencies, snapshot.journey.journeyId, send.items, inventory, preflightSignal)) {
-					independentItems = await sessionIndependentItems(dependencies, snapshot.journey.journeyId, send.items, inventory, preflightSignal);
-					return null;
-				}
-				await connection.assertCurrent(preflightSignal);
-				return save({
-					...send,
-					status: "blocked",
-					items: send.items.map((item) => item.sessionAssembly || item.status === "completed" ? item : {
-						...item,
+	const preparation = createSessionPreparation(dependencies);
+	const cleanup = createCleanup();
+	try {
+		return await advanceItems({
+			send,
+			failure: dependencies.failure,
+			...usesSessionSend(dependencies, send) ? {
+				batch: () => {
+					const limit = send.parallelCompletes ? 3 : 1;
+					return independentItems.length ? pickBatch(independentItems, Date.now(), limit) : pickBatch(send.items, Date.now(), limit);
+				},
+				preflight: async (connection, preflightSignal) => {
+					if (!connection.sessions) throw new ApplicationError("INVALID_STATE");
+					if (!send.items.some((item) => item.status === "uploading" && !item.sessionAssembly && !item.receipt && !item.reservation)) return null;
+					const inventory = await connection.sessions.inventory(preflightSignal);
+					if (!await sessionAccessBlocked(preparation.dependencies, snapshot.journey.journeyId, send.items, inventory, preflightSignal)) {
+						independentItems = await sessionIndependentItems(preparation.dependencies, snapshot.journey.journeyId, send.items, inventory, preflightSignal);
+						return null;
+					}
+					await connection.assertCurrent(preflightSignal);
+					return save({
+						...send,
 						status: "blocked",
-						error: "SESSION_MOVE_ACCESS_REQUIRED"
-					})
-				});
-			},
-			step: (context, item, connection, stepSignal) => stepSessionWork(dependencies, snapshot.journey.journeyId, context, item, connection, stepSignal)
-		} : {},
-		connect: chain?.connect ?? dependencies.auth.connect,
-		profile: (connection, profileSignal) => prepareProfile(dependencies, snapshot, connection, profileSignal),
-		context: (item) => {
-			const binding = snapshot.journey.works.find((value) => value.id === item.workId)?.binding;
-			return {
-				snapshot: true,
-				...chain ? { fresh: chain.fresh } : {},
-				active: async () => {
-					const current = requireSend(await dependencies.storage.loadSend(snapshot.journey.journeyId));
-					if (current.send.id !== snapshot.send.id || !sameItem(current.send.items, item) || current.send.status === "paused" || current.journey.phase === "paused") throw new ApplicationError("REVISION_CONFLICT");
-					assertScope(current.journey, current.send);
+						items: send.items.map((item) => item.sessionAssembly || item.status === "completed" ? item : {
+							...item,
+							status: "blocked",
+							error: "SESSION_MOVE_ACCESS_REQUIRED"
+						})
+					});
 				},
-				bindingId: binding?.subject === send.subject ? binding.bundleRecordId : void 0,
-				upload: async (artifact, upload, uploadSignal) => {
-					const started = performance.now();
-					await dependencies.artifacts.upload(snapshot.journey.journeyId, artifact, upload, uploadSignal);
-					dependencies.uploaded?.(artifact.workId, artifact.byteLength, Math.round(performance.now() - started));
-				}
-			};
-		},
-		save,
-		applied: () => ({
-			...snapshot,
-			status: "applied"
-		}),
-		stale: async () => ({
-			...requireSend(await dependencies.storage.loadSend(address.journeyId, address.sendId)),
-			status: "stale"
-		})
-	}, signal);
+				step: (context, item, connection, stepSignal) => stepSessionWork(preparation.dependencies, snapshot.journey.journeyId, context, item, connection, stepSignal, (next) => {
+					const pending = saving.then(async () => {
+						const current = await active(item);
+						if (current.send.revision !== snapshot.send.revision || current.journey.revision !== snapshot.journey.revision) throw new ApplicationError("REVISION_CONFLICT");
+						stepSignal.throwIfAborted();
+						const result = await saveSend(dependencies, current, {
+							...current.send,
+							items: current.send.items.map((value) => value.workId === next.workId ? next : value)
+						});
+						if (result.status === "stale") throw new ApplicationError("REVISION_CONFLICT");
+						snapshot = requireSend(result);
+						const saved = snapshot.send.items.find((value) => value.workId === next.workId);
+						if (!saved) throw new ApplicationError("INVALID_STATE");
+						checkpoints.set(next.workId, saved);
+					});
+					saving = pending.catch(() => void 0);
+					return pending;
+				}).then((result) => {
+					fulfilled.add(item.workId);
+					return result;
+				})
+			} : {},
+			connect: chain?.connect ?? dependencies.auth.connect,
+			profile: (connection, profileSignal) => prepareProfile(dependencies, snapshot, connection, profileSignal),
+			context: (item) => {
+				const binding = snapshot.journey.works.find((value) => value.id === item.workId)?.binding;
+				return {
+					snapshot: true,
+					...chain ? { fresh: chain.fresh } : {},
+					active: async () => {
+						await active(item);
+					},
+					bindingId: binding?.subject === send.subject ? binding.bundleRecordId : void 0,
+					upload: async (artifact, upload, uploadSignal) => {
+						const started = performance.now();
+						await dependencies.artifacts.upload(snapshot.journey.journeyId, artifact, upload, uploadSignal);
+						dependencies.uploaded?.(artifact.workId, artifact.byteLength, Math.round(performance.now() - started));
+					}
+				};
+			},
+			save,
+			applied: () => ({
+				...snapshot,
+				status: "applied"
+			}),
+			stale: async () => ({
+				...requireSend(await dependencies.storage.loadSend(address.journeyId, address.sendId)),
+				status: "stale"
+			})
+		}, signal);
+	} catch (error) {
+		cleanup.failed(error);
+		throw error;
+	} finally {
+		await cleanup.run(() => preparation.close());
+	}
 }
 /** The first wait after a bare refusal of staged bytes, doubled per refusal up to the cap. */
 const busyBaseMs = 2e3;
@@ -15210,7 +15371,13 @@ async function createRuntime(options, callbacks = {}) {
 	let bundles;
 	if (import.meta.url.endsWith(".ts")) {
 		traceStartup("worker-build-start");
-		bundles = await (await import(new URL("../../../scripts/workers/build.ts", import.meta.url).href)).buildWorkerBundles();
+		const shared = process.env["SESS_PILOT_TEST_WORKER_BUNDLES"];
+		if (shared) bundles = {
+			directory: shared,
+			url: (name) => pathToFileURL(join(shared, `${name}.mjs`)),
+			dispose: async () => {}
+		};
+		else bundles = await (await import(new URL("../../../scripts/workers/build.ts", import.meta.url).href)).buildWorkerBundles();
 		traceStartup("worker-build-end");
 	}
 	try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitroll/tacitt-cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Private local session review and export for coding agents",
   "license": "UNLICENSED",
   "repository": {