gentle-pi 4.0.0 → 4.2.0

package/lib/orchestrator-presence.ts

@@ -2,6 +2,10 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { stripVTControlCharacters } from "node:util";
+import { validRecordedScope, type RecordedScope } from "./orchestrator-scope.ts";
+import { projectCatalog } from "./orchestrator-catalog.ts";
+import { decodePublishedState, type PublishedState } from "./orchestrator-state.ts";
+import { decodeTaskAliases, type TaskAliases } from "./orchestrator-alias.ts";
 
 // Same-profile OS-user trust boundary, not an authorization channel. POSIX modes
 // restrict newly created storage; Windows deployments must supply their own ACLs.
@@ -27,6 +31,19 @@ export interface Activity { tasks: { summary: ActivityInput["task"]; thread: {
 	version: number; dropped: number; items: ObjectValue[];
 } }[] }
 export interface Target { sessionHash: string; incarnation: string }
+export interface DiscoveryMetadata {
+	aliases?: TaskAliases;
+	state?: PublishedState;
+	scope?: RecordedScope;
+	activation: string;
+	workspace: string;
+	tasks: { id: string; label: string; status: string; workspace: string }[];
+	omitted: number;
+}
+export function sessionHash(sessionId: string) { return digest(sessionId); }
+export function activationHash(peer: { sessionId: string; endpoint: string; createdAt: number }) {
+	return digest(JSON.stringify([peer.sessionId, peer.endpoint, peer.createdAt]));
+}
 export interface Header extends Target {
 	schema: 1; label: string; heartbeat: number; generation: number;
 	counts: { running: number; queued: number; waiting: number; finished: number };
@@ -37,10 +54,11 @@ const object = (v: unknown): v is ObjectValue => !!v && typeof v === "object" &&
 const integer = (v: unknown) => Number.isSafeInteger(v) && (v as number) >= 0;
 const keys = (v: ObjectValue, names: string[]) => Object.keys(v).length === names.length && names.every((k) => Object.hasOwn(v, k));
 const digest = (data: string | Buffer) => createHash("sha256").update(data).digest("hex");
-function label(text: string) {
+export function sanitizeDisplayLabel(text: string) {
 	const clean = stripVTControlCharacters(text).replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").trim();
 	return Array.from(clean).slice(0, 120).join("").trimEnd();
 }
+const label = sanitizeDisplayLabel;
 const pick = (v: ObjectValue, names: string[]) => Object.fromEntries(names.map((k) => [k, v[k]]));
 const summaryTextKeys = ["id", "agent", "label", "status", "model"];
 const summaryKeys = [...summaryTextKeys, "createdAt", "startedAt", "endedAt", "lastActivityAt"];
@@ -78,6 +96,15 @@ function validTarget(value: Target) {
 	return object(value) && typeof value.sessionHash === "string" && HASH.test(value.sessionHash)
 		&& typeof value.incarnation === "string" && UUID.test(value.incarnation);
 }
+function validDiscovery(d: unknown): d is DiscoveryMetadata {
+	return object(d) && keys(d, ["activation", "workspace", "tasks", "omitted", ...["scope", "state", "aliases"].filter(k => Object.hasOwn(d, k))])
+		&& typeof d.activation === "string" && HASH.test(d.activation)
+		&& typeof d.workspace === "string" && d.workspace === label(d.workspace) && integer(d.omitted)
+		&& Array.isArray(d.tasks) && d.tasks.length <= 8 && d.tasks.every((t: unknown) => object(t)
+			&& keys(t, ["id", "label", "status", "workspace"])
+			&& ["id", "label", "workspace"].every(k => typeof t[k] === "string" && t[k] === label(t[k]))
+			&& STATUSES.includes(t.status));
+}
 function validHeader(h: unknown): h is Header {
 	if (!object(h) || !keys(h, ["schema", "sessionHash", "incarnation", "label", "heartbeat", "generation", "counts", "digest", "unavailable"])) return false;
 	return validTarget(h as Header) && h.schema === 1 && typeof h.label === "string" && h.label === label(h.label)
@@ -86,7 +113,7 @@ function validHeader(h: unknown): h is Header {
 		&& ((h.unavailable === null && typeof h.digest === "string" && HASH.test(h.digest))
 			|| (h.unavailable === "activity-too-large" && h.digest === null));
 }
-function filename(target: Target, kind: "header" | "activity") {
+function filename(target: Target, kind: "header" | "activity" | "discovery") {
 	if (!validTarget(target)) throw new Error("malformed");
 	return `${target.sessionHash}.${target.incarnation}.${kind}.json`;
 }
@@ -96,7 +123,7 @@ function directory(path: string, privateMode = false, owned = privateMode) {
 	if (!stat.isDirectory() || stat.isSymbolicLink() || (owned && process.platform !== "win32"
 		&& ((stat.mode & (privateMode ? 0o077 : 0o022)) !== 0 || stat.uid !== process.getuid?.()))) throw new Error("unsafe-directory");
 }
-function rootFor(profile: string, create = false) {
+export function rootFor(profile: string, create = false, catalog = false) {
 	const absolute = resolve(profile);
 	// Reject symlink ancestors too. The caller supplies an existing profile root.
 	for (let path = absolute;; path = dirname(path)) {
@@ -104,7 +131,7 @@ function rootFor(profile: string, create = false) {
 		if (dirname(path) === path) break;
 	}
 	const shared = join(absolute, "gentle-agents");
-	const root = join(shared, "presence");
+	const root = join(shared, catalog ? "catalog" : "presence");
 	// History may already own a 0755 shared root. Never change its permissions.
 	for (const path of [shared, root]) {
 		if (create) {
@@ -118,7 +145,7 @@ function rootFor(profile: string, create = false) {
 function regular(stat: fs.Stats) {
 	if (!stat.isFile() || stat.nlink !== 1 || (process.platform !== "win32" && stat.uid !== process.getuid?.())) throw new Error("unsafe-file");
 }
-function boundedRead(path: string, limit: number) {
+export function boundedRead(path: string, limit: number) {
 	const before = fs.lstatSync(path);
 	regular(before);
 	if (before.size > limit) throw new Error("oversized");
@@ -236,11 +263,29 @@ export function readActivity(profile: string, selection: Header): { activity?: A
 	} catch (error) { return { unavailable: reason(error) }; }
 }
 
+/** Optional derived sidecar; failures never invalidate the schema-1 header. */
+export function readDiscovery(profile: string, h: Header): DiscoveryMetadata | undefined {
+	try {
+		const value = JSON.parse(boundedRead(join(rootFor(profile), filename(h, "discovery")), HEADER_LIMIT).toString("utf8"));
+		if (!object(value) || !keys(value, ["schema", "sessionHash", "incarnation", "generation", "metadata"])
+			|| value.schema !== 1 || value.sessionHash !== h.sessionHash || value.incarnation !== h.incarnation
+			|| value.generation !== h.generation || !validDiscovery(value.metadata)) return undefined;
+		const { scope, state, aliases: rawAliases, ...legacy } = value.metadata;
+		const decoded = decodePublishedState(state);
+		const aliases = decodeTaskAliases(rawAliases);
+		return { ...legacy, ...(aliases ? { aliases } : {}), ...(validRecordedScope(scope) ? { scope } : {}), ...(decoded ? { state: decoded } : {}) };
+	} catch { return undefined; }
+}
+
 export class PresencePublisher {
 	readonly target: Readonly<Target>;
 	private readonly profile: string;
 	private readonly displayLabel: string;
+	private readonly labelSource?: () => string;
 	private header!: Header;
+	private discovery?: DiscoveryMetadata;
+	private catalog?: ReturnType<typeof projectCatalog>;
+	private catalogTokens: string[] = [];
 	private published = "";
 	private pending = "";
 	private timer?: ReturnType<typeof setTimeout>;
@@ -250,12 +295,13 @@ export class PresencePublisher {
 	/** Timer I/O failures stop publication; consumers still apply the recent TTL. */
 	error?: string;
 
-	private constructor(options: { profile: string; sessionId: string; label: string }) {
+	private constructor(options: { profile: string; sessionId: string; label: string; labelSource?: () => string }) {
 		this.profile = options.profile;
 		this.displayLabel = label(options.label);
+		this.labelSource = options.labelSource;
 		this.target = Object.freeze({ sessionHash: digest(options.sessionId), incarnation: randomUUID() });
 	}
-	static start(options: { profile: string; sessionId: string; label: string; activity: readonly ActivityInput[] }) {
+	static start(options: { profile: string; sessionId: string; label: string; labelSource?: () => string; activity: readonly ActivityInput[] }) {
 		const publisher = new PresencePublisher(options);
 		try {
 			rootFor(options.profile, true);
@@ -266,6 +312,50 @@ export class PresencePublisher {
 			return publisher;
 		} catch (error) { publisher.dispose(); throw error; }
 	}
+	/** Refresh through the existing publication path, without changing activity generation.
+	 * The source must be a cheap canonical-name getter; throw when its session is stale. */
+	refreshLabel() {
+		this.guarded(() => this.publishHeader());
+	}
+	/** Metadata-only projection; never reads task prompts, results, or threads.
+	 * Binding to the listener activation prevents reused session IDs from joining. */
+	updateDiscovery(peer: { sessionId: string; endpoint: string; createdAt: number }, input: {
+		workspace: string; tasks: readonly { id: string; label: string; status: string; cwd: string }[]; scope?: RecordedScope; registered?: readonly string[]; state?: PublishedState;
+	}) {
+		if (this.disposed) throw new Error("disposed");
+		if (sessionHash(peer.sessionId) !== this.target.sessionHash) throw new Error("malformed-discovery");
+		// A shortened path could denote a different workspace; do not advertise it.
+		const workspace = (path: string) => Array.from(path).length <= 120 && label(path) === path ? path : "";
+		const discovery: DiscoveryMetadata = { activation: activationHash(peer), workspace: workspace(input.workspace),
+			tasks: input.tasks.slice(0, 8).map(t => ({ id: label(t.id), label: label(t.label), status: t.status, workspace: workspace(t.cwd) })),
+			omitted: Math.max(0, input.tasks.length - 8) };
+		const state = decodePublishedState(input.state);
+		if (state?.sessionId === peer.sessionId) {
+			discovery.state = state;
+			if (state.aliases) discovery.aliases = structuredClone(state.aliases);
+		}
+		if (input.scope && validRecordedScope(input.scope)) {
+			discovery.scope = structuredClone(input.scope);
+			// Leave explicit gaps instead of publishing a sidecar readers cannot fit.
+			if (Buffer.byteLength(JSON.stringify(discovery)) > HEADER_LIMIT - 1024) {
+				const scope = discovery.scope;
+				discovery.scope = { ...scope, tasks: [], registered: [],
+					omittedTasks: scope.tasks.length + scope.omittedTasks,
+					omittedRegistered: scope.registered.length + scope.omittedRegistered, complete: false };
+			}
+		}
+		if (Buffer.byteLength(JSON.stringify(discovery)) > HEADER_LIMIT - 1024) delete discovery.state;
+		if (!validDiscovery(discovery)) throw new Error("malformed-discovery");
+		const catalog = projectCatalog(input.tasks, input.registered ?? []);
+		if (JSON.stringify(discovery) === JSON.stringify(this.discovery) && JSON.stringify(catalog) === JSON.stringify(this.catalog)) return;
+		// Only catalog or routing-activation changes rotate page tokens; private
+		// activity generations and unrelated legacy metadata do not invalidate them.
+		if (JSON.stringify(catalog) !== JSON.stringify(this.catalog) || discovery.activation !== this.discovery?.activation)
+			this.catalogTokens = Array.from({ length: 7 }, () => randomUUID());
+		this.catalog = catalog;
+		this.discovery = discovery;
+		this.writeDiscovery();
+	}
 	/** Eagerly projects/serializes each supplied snapshot to detach caller-owned data.
 	 * Only disk publication is coalesced; callers should avoid unrelated invalidations. */
 	update(input: readonly ActivityInput[]) {
@@ -285,18 +375,29 @@ export class PresencePublisher {
 		if (this.disposed) return;
 		try { action(); } catch (error) { this.error = reason(error); this.dispose(); }
 	}
-	private write(kind: "header" | "activity", bytes: string) {
-		const root = rootFor(this.profile);
-		const name = filename(this.target, kind);
+	private write(kind: "header" | "activity" | "discovery" | "catalog", bytes: string) {
+		const root = rootFor(this.profile, kind === "catalog", kind === "catalog");
+		const name = kind === "catalog" ? `${this.target.sessionHash}.${this.target.incarnation}.json` : filename(this.target, kind);
 		atomicWrite(root, name, bytes);
 		const { dev, ino } = fs.lstatSync(join(root, name));
-		this.owned.set(name, { dev, ino });
+		this.owned.set(join(root, name), { dev, ino });
+	}
+	private writeDiscovery() {
+		if (!this.discovery) return;
+		try {
+			if (this.catalog) this.write("catalog", JSON.stringify({ schema: 1, ...this.target,
+				generation: this.header.generation, activation: this.discovery.activation, tokens: this.catalogTokens, catalog: this.catalog }));
+		} catch { /* Optional catalog failure must not suppress other metadata. */ }
+		try {
+			this.write("discovery", JSON.stringify({ schema: 1, ...this.target, generation: this.header.generation, metadata: this.discovery }));
+		} catch { /* Metadata failure must not withdraw an existing activity peer. */ }
 	}
 	private publishHeader() {
-		const header = { ...this.header, heartbeat: Date.now() };
+		const header = { ...this.header, label: label(this.labelSource?.() ?? this.displayLabel), heartbeat: Date.now() };
 		if (!validHeader(header)) throw new Error("malformed-header");
 		this.write("header", JSON.stringify(header));
 		this.header = header;
+		this.writeDiscovery();
 	}
 	private flush() {
 		if (this.pending === this.published) return;
@@ -324,9 +425,9 @@ export class PresencePublisher {
 		clearTimeout(this.timer);
 		clearInterval(this.heartbeat);
 		this.pending = this.published = "";
-		for (const [name, identity] of this.owned) {
+		for (const [path, identity] of this.owned) {
 			try {
-				const path = join(rootFor(this.profile), name);
+				rootFor(this.profile, false, dirname(path) === join(resolve(this.profile), "gentle-agents", "catalog"));
 				const stat = fs.lstatSync(path);
 				regular(stat);
 				if (stat.dev === identity.dev && stat.ino === identity.ino) fs.unlinkSync(path);

package/lib/orchestrator-scope.ts

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { resolveSessionWorktree, type WorktreeResolver } from "./session-worktree-registry.ts";
+
+export interface RepositoryFact {
+	root: string | null;
+	cloneHash: string | null;
+	resolvedAt: number;
+	source: "recorded-workspace/git";
+}
+export interface RecordedScope {
+	host: RepositoryFact;
+	tasks: { id: string; repository: RepositoryFact }[];
+	registered: RepositoryFact[];
+	omittedTasks: number;
+	omittedRegistered: number;
+	complete: boolean;
+}
+// Recorded cwd/root is literal, not a user spelling. The shared resolver maps
+// these Unicode separators to ASCII space; reject them before resolving and on
+// output/readback rather than aliasing a distinct directory or truncating a root.
+const safeRoot = (root: string) => isAbsolute(root) && Buffer.byteLength(root) <= 256
+	&& !/[\p{Cc}\p{Cf}\u00a0\u2000-\u200a\u202f\u205f\u3000]/u.test(root);
+const object = (v: any) => v && typeof v === "object" && !Array.isArray(v);
+const keys = (v: object, names: string[]) => Object.keys(v).length === names.length && names.every(k => Object.hasOwn(v, k));
+const count = (v: unknown) => Number.isSafeInteger(v) && (v as number) >= 0;
+export function validRecordedScope(value: any): value is RecordedScope {
+	const fact = (v: any) => object(v) && keys(v, ["cloneHash", "resolvedAt", "root", "source"])
+		&& v.source === "recorded-workspace/git" && count(v.resolvedAt)
+		&& ((v.root === null && v.cloneHash === null) || (typeof v.root === "string" && safeRoot(v.root)
+			&& typeof v.cloneHash === "string" && /^[a-f0-9]{64}$/.test(v.cloneHash)));
+	return object(value) && keys(value, ["complete", "host", "omittedRegistered", "omittedTasks", "registered", "tasks"])
+		&& fact(value.host) && Array.isArray(value.tasks) && value.tasks.length <= 8
+		&& value.tasks.every((t: any) => object(t) && keys(t, ["id", "repository"])
+			&& typeof t.id === "string" && Buffer.byteLength(t.id) <= 512 && fact(t.repository))
+		&& Array.isArray(value.registered) && value.registered.length <= 8 && value.registered.every(fact)
+		&& count(value.omittedTasks) && count(value.omittedRegistered)
+		&& value.complete === (value.omittedTasks === 0 && value.omittedRegistered === 0);
+}
+
+/** One bounded derivative snapshot, not a registry or authority. The caller supplies
+ * only admitted, unfinished, non-restored owned children and durable registry roots.
+ * Membership/cwd changes invalidate even unknown facts; session replacement clears.
+ * No resolution runs on a stable heartbeat/token update. */
+export class OrchestratorScopeCache {
+	private key = "";
+	private snapshot?: RecordedScope;
+	private resolver: WorktreeResolver;
+	private now: () => number;
+	constructor(resolver = resolveSessionWorktree, now = Date.now) {
+		this.resolver = resolver;
+		this.now = now;
+	}
+	clear() {
+		this.key = "";
+		this.snapshot = undefined;
+	}
+	project(cwd: string, tasks: readonly { id: string; cwd: string }[], roots: readonly string[]): RecordedScope {
+		const registered = [...new Set(roots)];
+		const key = createHash("sha256").update(JSON.stringify([cwd, tasks.map(t => [t.id, t.cwd]), registered])).digest("hex");
+		if (key === this.key && this.snapshot) return this.snapshot;
+		const resolvedAt = this.now();
+		const facts = new Map<string, RepositoryFact>();
+		const fact = (path: string) => {
+			if (facts.has(path)) return facts.get(path)!;
+			const unknown: RepositoryFact = { root: null, cloneHash: null, resolvedAt, source: "recorded-workspace/git" };
+			let identity;
+			try { identity = safeRoot(path) ? this.resolver(path, path) : undefined; } catch { /* Unavailable is unknown. */ }
+			const result = identity && safeRoot(identity.root) ? { ...unknown, root: identity.root,
+				cloneHash: createHash("sha256").update(identity.commonDir).digest("hex") } : unknown;
+			facts.set(path, result);
+			return result;
+		};
+		this.snapshot = { host: fact(cwd), tasks: tasks.slice(0, 8).map(t => ({ id: t.id, repository: fact(t.cwd) })),
+			registered: registered.slice(0, 8).map(fact), omittedTasks: Math.max(0, tasks.length - 8),
+			omittedRegistered: Math.max(0, registered.length - 8), complete: tasks.length <= 8 && registered.length <= 8 };
+		this.key = key;
+		return this.snapshot;
+	}
+}

package/lib/orchestrator-state.ts

@@ -0,0 +1,107 @@
+import { isAbsolute } from "node:path";
+import { decodeTaskAliases, normalizeTaskSubject, type TaskAliases } from "./orchestrator-alias.ts";
+import { decodeWork, type PublishedWork } from "./orchestrator-work.ts";
+
+export const ORCHESTRATOR_STATE_ENTRY = "gentle-agents.published-state";
+const fields = ["objective", "progress", "decisions", "blockers"] as const;
+export type CuratedState = Partial<Record<typeof fields[number], string>> & { work?: PublishedWork };
+export interface PublishedState {
+	schema: 1 | 2; sessionId: string; recordedAt: number; cwd: string | null;
+	source: "owner-curated"; ownerReply: false; authority: "none"; state: CuratedState | null;
+	aliases?: TaskAliases;
+}
+const object = (v: unknown): v is Record<string, unknown> => !!v && typeof v === "object" && !Array.isArray(v);
+const safeText = (v: unknown): v is string => typeof v === "string" && !/[\p{Cc}\p{Cf}\p{Cs}]/u.test(v);
+const safeCwd = (v: unknown): v is string => safeText(v) && isAbsolute(v) && Buffer.byteLength(v) <= 1024
+	&& !/[\u00a0\u2000-\u200a\u202f\u205f\u3000]/u.test(v);
+/** Field whitelist, not secret redaction. Reject rather than truncate meaning. */
+export function decodeCuratedState(value: unknown): CuratedState | null {
+	if (value === null) return null;
+	if (!object(value) || Object.keys(value).some(k => k !== "work" && !fields.includes(k as typeof fields[number])))
+		throw new Error("invalid-published-state");
+	const state: CuratedState = {};
+	let bytes = 0;
+	for (const key of fields) {
+		if (!Object.hasOwn(value, key)) continue;
+		if (!safeText(value[key])) throw new Error("invalid-published-state");
+		state[key] = value[key];
+		bytes += Buffer.byteLength(value[key]);
+	}
+	if (Object.hasOwn(value, "work")) {
+		state.work = decodeWork(value.work);
+		bytes += Buffer.byteLength(JSON.stringify(state.work));
+	}
+	if (bytes > 2048) throw new Error("invalid-published-state");
+	return state;
+}
+export function decodePublishedState(value: unknown): PublishedState | undefined {
+	try {
+		const keys = ["schema", "sessionId", "recordedAt", "cwd", "source", "ownerReply", "authority", "state",
+			...(object(value) && Object.hasOwn(value, "aliases") ? ["aliases"] : [])];
+		if (!object(value) || Object.keys(value).length !== keys.length || !keys.every(k => Object.hasOwn(value, k))
+			|| (value.schema !== 1 && value.schema !== 2) || !safeText(value.sessionId) || !value.sessionId || Buffer.byteLength(value.sessionId) > 256
+			|| !Number.isSafeInteger(value.recordedAt) || (value.recordedAt as number) < 0
+			|| !(value.cwd === null || safeCwd(value.cwd))
+			|| value.source !== "owner-curated" || value.ownerReply !== false || value.authority !== "none"
+			|| Buffer.byteLength(JSON.stringify(value)) > 4096) return undefined;
+		const state = decodeCuratedState(value.state);
+		const aliases = decodeTaskAliases(value.aliases);
+		if ((value.schema === 2) !== !!state?.work || (Object.hasOwn(value, "aliases") && !aliases)) return undefined;
+		return { schema: value.schema, sessionId: value.sessionId, recordedAt: value.recordedAt as number,
+			cwd: safeText(value.cwd) ? value.cwd : null, source: "owner-curated", ownerReply: false, authority: "none", state,
+			...(aliases ? { aliases } : {}) };
+	} catch { return undefined; }
+}
+interface StateManager {
+	getSessionId(): string; getCwd(): string;
+	getBranch(): readonly { type: string; customType?: string; data?: unknown }[];
+}
+/** One branch-local cache. Never accesses message bodies, summaries, or results. */
+export class OrchestratorStateCache {
+	private manager?: StateManager;
+	private sessionId?: string;
+	private value?: PublishedState;
+	private epoch = 0;
+	clear() { this.epoch++; this.manager = undefined; this.sessionId = undefined; this.value = undefined; }
+	load(manager: StateManager) {
+		this.clear();
+		this.manager = manager;
+		this.sessionId = manager.getSessionId();
+		const branch = manager.getBranch();
+		for (let i = branch.length - 1; i >= 0; i--) {
+			const entry = branch[i];
+			if (entry.type !== "custom" || entry.customType !== ORCHESTRATOR_STATE_ENTRY) continue;
+			const decoded = decodePublishedState(entry.data);
+			// A malformed/foreign latest record suppresses older knowledge.
+			this.value = decoded?.sessionId === this.sessionId ? decoded : undefined;
+			break;
+		}
+	}
+	get(manager: StateManager): PublishedState | undefined {
+		return this.manager === manager && this.sessionId === manager.getSessionId() && this.value
+			? structuredClone(this.value) : undefined;
+	}
+	publish(manager: StateManager, input: unknown, append: (type: string, data: PublishedState) => void, now = Date.now(), subject?: unknown) {
+		const state = input === undefined ? this.value?.state ?? null : decodeCuratedState(input);
+		const declared = normalizeTaskSubject(subject);
+		if (this.manager !== manager || this.sessionId !== manager.getSessionId()) throw new Error("stale-published-state");
+		const epoch = this.epoch;
+		const previous = this.value?.aliases;
+		// Null/null marks a new publication with no declaration yet; legacy absence
+		// cannot establish historical first-task knowledge.
+		let aliases = previous;
+		if (declared) {
+			let initialAlias = previous?.initialAlias ?? null;
+			if (!this.value || previous?.currentAlias === null) initialAlias = declared;
+			aliases = { initialAlias, currentAlias: declared };
+		} else if (!this.value) aliases = { initialAlias: null, currentAlias: null };
+		const cwd = input === undefined && this.value ? this.value.cwd : manager.getCwd();
+		const record = decodePublishedState({ schema: state?.work ? 2 : 1, sessionId: manager.getSessionId(),
+			recordedAt: input === undefined && this.value ? this.value.recordedAt : now, cwd: safeCwd(cwd) ? cwd : null,
+			source: "owner-curated", ownerReply: false, authority: "none", state, ...(aliases ? { aliases } : {}) });
+		if (!record) throw new Error("invalid-published-state");
+		append(ORCHESTRATOR_STATE_ENTRY, structuredClone(record));
+		if (this.epoch !== epoch || this.manager !== manager || this.sessionId !== record.sessionId || manager.getSessionId() !== record.sessionId) throw new Error("stale-published-state");
+		this.value = record;
+	}
+}