@junghanacs/entwurf 0.41.2 → 0.50.0

package/pi/pi-durable/carrier/sessions.js

@@ -4,6 +4,55 @@ import { mkdir, readdir, realpath, stat } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import lockfile from "proper-lockfile";
 import { getAgentDir } from "entwurf-pi-dist:config.js";
+import { isSessionName } from "./session-name.js";
+
+/**
+ * An owner's end as the opener observed it (#157 B3): the storage outcome of the first actual close, and the
+ * lease outcome of its release.
+ */
+                           
+	                                                                   
+	                                                                 
+	                               
+	                        
+ 
+
+/** One admitted owner of a session directory, from before its native lease through its end. */
+                              
+	                                                                                                         
+	                              
+	                                     
+	                        
+	                                                           
+	                               
+	                                     
+	                                          
+	                                                                                       
+	                             
+ 
+
+/** What an owned open hands the fence once its directory is chosen, before its native lease. */
+                                 
+	                                                                           
+	                           
+	                                                    
+	                           
+	                                                     
+	                          
+	   
+	                                                                                                                
+	                                                                    
+	   
+	                         
+ 
+
+/**
+ * The owner fence every owned open takes before its native lease (#157 B3). Supplied by the host, never imported
+ * here; it admits this opener or refuses, and a refusal opens nothing.
+ */
+                               
+	                                                     
+ 
 
 /** One session directory holding `session.sqlite`, locked by this process. */
                                   
@@ -13,6 +62,8 @@ import { getAgentDir } from "entwurf-pi-dist:config.js";
 	            
 	                 
 	                         
+	                                                                      
+	                    
  
 
 /** One session of a directory as its files show it (#143): nothing in it is opened. */
@@ -27,8 +78,6 @@ import { getAgentDir } from "entwurf-pi-dist:config.js";
 	                       
  
 
-const SESSION_NAME = /^\d{13}-[0-9a-f-]{36}$/u;
-
 /** A path's stat, or undefined when nothing is there; any other failure is thrown, never read as absence. */
 async function statIfPresent(path        )                             {
 	try {
@@ -39,15 +88,17 @@ async function statIfPresent(path        )                             {
 	}
 }
 
-async function sessionRoot(cwdInput        )                                         {
+async function sessionRoot(cwdInput        )                                                          {
 	const cwd = await realpath(resolve(cwdInput));
+	// Read once: the root is joined from this value, and the fence is handed this same value as it came (#157 B3).
+	const agentDir = getAgentDir();
 	const root = join(
-		getAgentDir(),
+		agentDir,
 		"experimental",
 		"durable-sessions",
 		createHash("sha256").update(cwd).digest("hex").slice(0, 24),
 	);
-	return { cwd, root };
+	return { cwd, root, profile: agentDir };
 }
 
 /** The sessions of `cwd`, most recently written first. Reads names, file times and locks; creates nothing. */
@@ -62,7 +113,7 @@ export async function listSessions(cwdInput        )                          {
 	}
 	const sessions                 = [];
 	for (const entry of entries) {
-		if (!entry.isDirectory() || !SESSION_NAME.test(entry.name)) continue;
+		if (!entry.isDirectory() || !isSessionName(entry.name)) continue;
 		const directory = join(root, entry.name);
 		let lastWriteAt                    ;
 		for (const file of ["session.sqlite", "session.sqlite-wal"]) {
@@ -80,19 +131,23 @@ export async function listSessions(cwdInput        )                          {
 	return sessions.sort((a, b) => (b.lastWriteAt ?? b.createdAt) - (a.lastWriteAt ?? a.createdAt));
 }
 
-/** A new session for `cwd`, its newest one with `continueSession`, or the existing one named by `sessionId`. */
+/**
+ * A new session for `cwd`, its newest one with `continueSession`, or the existing one named by `sessionId`, admitted
+ * by `fence` before its native lease is taken.
+ */
 export async function selectSession(
+	fence              ,
 	cwdInput        ,
 	continueSession         ,
 	sessionId         ,
 )                           {
-	const { cwd, root } = await sessionRoot(cwdInput);
+	const { cwd, root, profile } = await sessionRoot(cwdInput);
 	await mkdir(root, { recursive: true });
 
 	let directory        ;
 	let created = false;
 	if (sessionId !== undefined) {
-		const chosen = SESSION_NAME.test(sessionId) ? join(root, sessionId) : undefined;
+		const chosen = isSessionName(sessionId) ? join(root, sessionId) : undefined;
 		if (chosen === undefined || !(await statIfPresent(chosen))?.isDirectory()) {
 			throw new Error(`No durable session ${sessionId} exists for ${cwd}`);
 		}
@@ -100,7 +155,7 @@ export async function selectSession(
 	} else if (continueSession) {
 		const entries = await readdir(root, { withFileTypes: true });
 		const newest = entries
-			.filter((entry) => entry.isDirectory() && SESSION_NAME.test(entry.name))
+			.filter((entry) => entry.isDirectory() && isSessionName(entry.name))
 			.map((entry) => entry.name)
 			.sort()
 			.at(-1);
@@ -112,15 +167,36 @@ export async function selectSession(
 		created = true;
 	}
 
-	let release                     ;
-	try {
-		// A lock left by a crashed process goes stale after 10 s; wait that long before giving up.
-		release = await lockfile.lock(directory, {
-			realpath: false,
-			retries: { retries: 12, minTimeout: 1000, maxTimeout: 1000 },
+	// The owner fence admits this opener BEFORE the native lease, or refuses with nothing taken (#157 B3).
+	const ticket = await fence.admit({ directory, selectedN: basename(directory), created, profile });
+	// A lock left by a crashed process goes stale after 10 s; wait that long before giving up.
+	const lease = lockfile.lock(directory, {
+		realpath: false,
+		retries: { retries: 12, minTimeout: 1000, maxTimeout: 1000 },
+	});
+	const release = await lease.catch(async (error) => {
+		const refused = new Error(`Session is already open in another process: ${directory}`, { cause: error });
+		// No acquisition was observed: this owner ends with nothing opened and no lease held.
+		await ticket.endUnleased().catch((fenceError) => {
+			throw new AggregateError([refused, fenceError], `${refused.message}; its owner end was not recorded`);
 		});
-	} catch (error) {
-		throw new Error(`Session is already open in another process: ${directory}`, { cause: error });
-	}
-	return { id: basename(directory), directory, database: join(directory, "session.sqlite"), cwd, created, release };
+		throw refused;
+	});
+	// Apart from the lease's own failure: the lease IS held here, so a failed checkpoint is never recorded as an
+	// acquire failure. The open fails and releases the lease; the claim stays fenced under this live owner.
+	await ticket.leased().catch(async (error) => {
+		await release().catch((releaseError) => {
+			throw new AggregateError([error, releaseError], `lease checkpoint and release both failed: ${directory}`);
+		});
+		throw error;
+	});
+	return {
+		id: basename(directory),
+		directory,
+		database: join(directory, "session.sqlite"),
+		cwd,
+		created,
+		release,
+		ticket,
+	};
 }

package/pi/pi-durable/overlay/upstream-pin.json

@@ -55,7 +55,7 @@
 		}
 	},
 	"carrier": {
-		"comment": "files: the six app files bootstrap.mjs needs (main.ts is replaced by the bootstrap), each emitted from its owned `source`. distTargets: every pi-coding-agent internal the stripped files import, as paths under the published dist/; the emitter refuses a set that differs and the resolver answers no other.",
+		"comment": "files: the six app files bootstrap.mjs needs (main.ts is replaced by the bootstrap) and the import-free session-name grammar Entwurf owns beside them (#157 G3 B-L1, no upstream origin), each emitted from its owned `source`. distTargets: every pi-coding-agent internal the stripped files import, as paths under the published dist/; the emitter refuses a set that differs and the resolver answers no other.",
 		"emitter": {
 			"tool": "node:module.stripTypeScriptTypes",
 			"mode": "strip",
@@ -70,8 +70,8 @@
 			{
 				"name": "runtime.js",
 				"source": "pi/pi-durable/src/experimental/durable/runtime.ts",
-				"blob": "75d7bf2b4fdc36aa775f73f9d7f3de8659f19187",
-				"sha256": "725757156580ad2a2d170c790440763371bb8035052a0c6caae6af5159d4718f"
+				"blob": "bb5715ab143945e9f2c067ff71d890fe29875d09",
+				"sha256": "437834997b9870ab0383aea7d86ff7880ef7e2ebbbfe4c6360f67d8d36f777ec"
 			},
 			{
 				"name": "tui.js",
@@ -94,14 +94,20 @@
 			{
 				"name": "sessions.js",
 				"source": "pi/pi-durable/src/experimental/durable/sessions.ts",
-				"blob": "eed4b3ca51c6f5a3bab8106adaf0062f3f7d5b56",
-				"sha256": "668373feadabcf13bd4dd7431e5429b7d7376c47c367e4b15353c57cb8711892"
+				"blob": "f107238fefb63c95b29add5aa76fcbd9153c94db",
+				"sha256": "0ac7c919f2bf8a3b0e5dbd307045108a803b161f87298cd9fe440f239784c7ac"
 			},
 			{
 				"name": "subagent.js",
 				"source": "pi/pi-durable/src/experimental/durable/subagent.ts",
 				"blob": "3fa9aebbe93e82cfff436e7b9d4c9877e0ed0e27",
 				"sha256": "1cb2390b673a0d914117bc07708c39b004fb10e48b31436bf9d9d2b953a64220"
+			},
+			{
+				"name": "session-name.js",
+				"source": "pi/pi-durable/src/experimental/durable/session-name.ts",
+				"blob": "c57c760ca3c14363f195ac9d9c2add984e4118d5",
+				"sha256": "9eadecfe9a48bba0d221370f4a236286e0d6f10d663b15ff4cb5975adee67018"
 			}
 		],
 		"distTargets": [

package/pi-extensions/lib/agent-guidance.ts

@@ -0,0 +1,341 @@
+/**
+ * Product-owned natural-language logic, authored only in root ENTWURF.json (#154).
+ * One module-relative file, read once. The compiled layout carries an exact copy at
+ * dist/ENTWURF.json; no cwd/HOME search, override, old-text fallback or hot reload.
+ * Existing operator engraving and user-configuration contracts are unrelated.
+ */
+import { readFileSync } from "node:fs";
+
+const TOOL_SPEC = {
+	entwurf_v2: { durable: true, parameters: ["target", "intent", "message", "mode", "wants_reply"] },
+	entwurf_self: { durable: true, parameters: [] },
+	entwurf_peers: { durable: true, parameters: [] },
+	entwurf_inbox_read: { durable: true, parameters: ["gardenId"] },
+	entwurf_register_native: { durable: false, parameters: ["backend", "nativeSessionId", "cwd"] },
+	entwurf_fresh_call: {
+		durable: true,
+		parameters: ["backend", "model", "task", "cwd", "placement.tmuxSession", "placement"],
+	},
+	entwurf_resume_call: { durable: true, parameters: ["target"] },
+	entwurf_retire_call: { durable: true, parameters: ["target"] },
+	entwurf_callback: { durable: true, parameters: [] },
+} as const;
+
+/** Frozen entwurf_v2 reject wire ids whose static next-step hint text lives in the root file. */
+const REJECT_HINT_REASONS = [
+	"dormant-fire-forget-unsupported",
+	"indeterminate-no-spawn",
+	"native-push-target-dead",
+	"native-push-probe-indeterminate",
+	"native-push-paused",
+] as const;
+
+export type RejectHintReason = (typeof REJECT_HINT_REASONS)[number];
+
+/** Frozen entwurf_resume_call record/liveness reject wire ids whose static hint text lives in the root file. */
+const RESUME_REJECT_HINT_REASONS = [
+	"target-invalid",
+	"target-backend-unsupported",
+	"target-locked",
+	"target-live",
+	"target-indeterminate",
+	"target-receiver-absent",
+	"target-receiver-corrupt",
+	"target-receiver-mismatch",
+	"target-receiver-unbound",
+	"target-address-conflict",
+	"launch-refused",
+] as const;
+
+export type ResumeRejectHintReason = (typeof RESUME_REJECT_HINT_REASONS)[number];
+
+/** Frozen entwurf_fresh_call tmux launch-stage reject wire ids whose static hint text lives in the root file. */
+const FRESH_LAUNCH_REJECT_HINT_REASONS = [
+	"no-tmux-context",
+	"anchor-malformed",
+	"anchor-unresolved",
+	"anchor-mismatch",
+	"caller-identity-unavailable",
+	"cwd-not-absolute",
+	"cwd-format-token",
+	"cwd-missing",
+	"cwd-not-directory",
+	"tmux-session-name-invalid",
+	"tmux-session-missing",
+	"model-empty",
+	"task-empty",
+	"runtime-unresolved",
+	"runtime-not-absolute",
+	"runtime-path-whitespace",
+	"runtime-missing",
+	"runtime-not-regular-file",
+	"runtime-not-executable",
+] as const;
+
+export type FreshLaunchRejectHintReason = (typeof FRESH_LAUNCH_REJECT_HINT_REASONS)[number];
+
+/** Frozen entwurf_resume_call tmux launch-stage reject wire ids whose static hint text lives in the root file. */
+const RESUME_LAUNCH_REJECT_HINT_REASONS = [
+	"no-tmux-context",
+	"anchor-malformed",
+	"anchor-unresolved",
+	"anchor-mismatch",
+	"cwd-not-absolute",
+	"cwd-format-token",
+	"cwd-missing",
+	"cwd-not-directory",
+	"herdr-resume-unsupported",
+	"runtime-unresolved",
+	"runtime-not-absolute",
+	"runtime-path-whitespace",
+	"runtime-missing",
+	"runtime-not-regular-file",
+	"runtime-not-executable",
+] as const;
+
+export type ResumeLaunchRejectHintReason = (typeof RESUME_LAUNCH_REJECT_HINT_REASONS)[number];
+
+/** Frozen keys of the static delivery-result clauses whose text lives in the root file; the
+ * receipts around them (syntax, branch conditions, slots, punctuation) stay code-owned. */
+const DELIVERY_RESULT_CLAUSE_KEYS = [
+	"finalized-rejected",
+	"dirty-lock",
+	"remote-accepted",
+	"remote-reported-error",
+	"remote-indeterminate",
+] as const;
+
+export type DeliveryResultClauseKey = (typeof DELIVERY_RESULT_CLAUSE_KEYS)[number];
+
+/** Frozen wire ids of the reject hints whose authored text sits on either side of ONE code-owned
+ * slot, and each one's exact segment keys. The slot value, the reason branch and the
+ * concatenation stay code-owned; the root file holds only the text around the slot. */
+const SLOTTED_REJECT_HINT_SEGMENTS = {
+	"record-less-socket": ["beforeFreshCutPrescription", "afterFreshCutPrescription"],
+} as const;
+
+export type SlottedRejectHintReason = keyof typeof SLOTTED_REJECT_HINT_SEGMENTS;
+type SlottedRejectHints = {
+	readonly [R in SlottedRejectHintReason]: Readonly<Record<(typeof SLOTTED_REJECT_HINT_SEGMENTS)[R][number], string>>;
+};
+
+type ToolName = keyof typeof TOOL_SPEC;
+type ToolGuidance<K extends ToolName> = {
+	readonly descriptions: (typeof TOOL_SPEC)[K]["durable"] extends true
+		? { readonly mcp: string; readonly durable: string }
+		: { readonly mcp: string };
+	readonly parameters: Readonly<Record<(typeof TOOL_SPEC)[K]["parameters"][number], string>>;
+};
+
+export interface EntwurfGuidance {
+	readonly _about: Readonly<Record<"purpose" | "ownership" | "scope" | "editing", string>>;
+	readonly schemaVersion: 6;
+	readonly revision: number;
+	readonly history: readonly {
+		readonly revision: number;
+		readonly source: string;
+		readonly issue: string;
+		readonly change: string;
+	}[];
+	readonly tools: { readonly [K in ToolName]: ToolGuidance<K> };
+	readonly rejectHints: Readonly<Record<RejectHintReason, string>>;
+	readonly resumeRejectHints: Readonly<Record<ResumeRejectHintReason, string>>;
+	readonly freshLaunchRejectHints: Readonly<Record<FreshLaunchRejectHintReason, string>>;
+	readonly resumeLaunchRejectHints: Readonly<Record<ResumeLaunchRejectHintReason, string>>;
+	readonly deliveryResultClauses: Readonly<Record<DeliveryResultClauseKey, string>>;
+	readonly slottedRejectHints: SlottedRejectHints;
+}
+
+function record(value: unknown, at: string): asserts value is Record<string, unknown> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error(`ENTWURF.json ${at}: expected an object`);
+	}
+}
+
+function keys(value: Record<string, unknown>, expected: readonly string[], at: string): void {
+	const actual = Object.keys(value).sort();
+	const wanted = [...expected].sort();
+	if (actual.length !== wanted.length || actual.some((key, i) => key !== wanted[i])) {
+		throw new Error(`ENTWURF.json ${at}: keys must be exactly ${wanted.join(", ")}`);
+	}
+}
+
+function text(value: unknown, at: string): void {
+	if (typeof value !== "string" || value.length === 0) {
+		throw new Error(`ENTWURF.json ${at}: expected a non-empty string`);
+	}
+}
+
+/**
+ * JSON.parse owns strict grammar, but its last-key-wins value is never enough.
+ * Walk the ORIGINAL, already grammar-checked tokens and reject duplicate DECODED
+ * object keys before returning data. Object scopes are independent; strings that
+ * are values (including punctuation and escaped quotes) are never key tokens.
+ */
+function rejectDuplicateKeys(source: string): void {
+	let pos = 0;
+	const space = (): void => {
+		while (pos < source.length && /[\x20\t\r\n]/.test(source[pos])) pos++;
+	};
+	const string = (): string => {
+		const start = pos++;
+		while (pos < source.length) {
+			if (source[pos] === "\\") pos += 2;
+			else if (source[pos++] === '"') return JSON.parse(source.slice(start, pos)) as string;
+		}
+		throw new Error("ENTWURF.json: unterminated string");
+	};
+	const value = (): void => {
+		space();
+		if (source[pos] === "{") {
+			pos++;
+			space();
+			const seen = new Set<string>();
+			if (source[pos] !== "}") {
+				for (;;) {
+					space();
+					const key = string();
+					if (seen.has(key)) throw new Error(`ENTWURF.json: duplicate object key ${JSON.stringify(key)}`);
+					seen.add(key);
+					space();
+					pos++; // colon; JSON.parse already certified the grammar
+					value();
+					space();
+					if (source[pos] !== ",") break;
+					pos++;
+				}
+			}
+			pos++;
+		} else if (source[pos] === "[") {
+			pos++;
+			space();
+			if (source[pos] !== "]") {
+				for (;;) {
+					value();
+					space();
+					if (source[pos] !== ",") break;
+					pos++;
+				}
+			}
+			pos++;
+		} else if (source[pos] === '"') {
+			string();
+		} else {
+			while (pos < source.length && !/[\x20\t\r\n,}\]]/.test(source[pos])) pos++;
+		}
+	};
+	value();
+}
+
+function freeze(value: unknown): void {
+	if (value === null || typeof value !== "object") return;
+	for (const child of Object.values(value)) freeze(child);
+	Object.freeze(value);
+}
+
+/** Pure data-validation seam; production always reads the one fixed module URL below. */
+export function parseEntwurfGuidance(source: string): EntwurfGuidance {
+	const data: unknown = JSON.parse(source);
+	rejectDuplicateKeys(source);
+	record(data, "root");
+	if (data.schemaVersion !== 6) throw new Error("ENTWURF.json: unsupported schemaVersion");
+	keys(
+		data,
+		[
+			"_about",
+			"schemaVersion",
+			"revision",
+			"history",
+			"tools",
+			"rejectHints",
+			"resumeRejectHints",
+			"freshLaunchRejectHints",
+			"resumeLaunchRejectHints",
+			"deliveryResultClauses",
+			"slottedRejectHints",
+		],
+		"root",
+	);
+	if (!Number.isSafeInteger(data.revision) || (data.revision as number) < 1) {
+		throw new Error("ENTWURF.json: revision must be a positive safe integer");
+	}
+	record(data._about, "_about");
+	keys(data._about, ["purpose", "ownership", "scope", "editing"], "_about");
+	for (const [key, value] of Object.entries(data._about)) text(value, `_about.${key}`);
+	if (!Array.isArray(data.history) || data.history.length === 0) {
+		throw new Error("ENTWURF.json: history must be a non-empty array");
+	}
+	for (const entry of data.history) {
+		record(entry, "history entry");
+		keys(entry, ["revision", "source", "issue", "change"], "history entry");
+		if (
+			!Number.isSafeInteger(entry.revision) ||
+			(entry.revision as number) < 1 ||
+			(entry.revision as number) > (data.revision as number)
+		) {
+			throw new Error("ENTWURF.json: history revision must name an existing payload revision");
+		}
+		for (const key of ["source", "issue", "change"] as const) text(entry[key], `history.${key}`);
+	}
+	record(data.tools, "tools");
+	keys(data.tools, Object.keys(TOOL_SPEC), "tools");
+	for (const name of Object.keys(TOOL_SPEC) as ToolName[]) {
+		const tool = data.tools[name];
+		record(tool, name);
+		keys(tool, ["descriptions", "parameters"], name);
+		record(tool.descriptions, `${name}.descriptions`);
+		keys(tool.descriptions, TOOL_SPEC[name].durable ? ["mcp", "durable"] : ["mcp"], `${name}.descriptions`);
+		for (const [rail, value] of Object.entries(tool.descriptions)) text(value, `${name}.descriptions.${rail}`);
+		record(tool.parameters, `${name}.parameters`);
+		keys(tool.parameters, TOOL_SPEC[name].parameters, `${name}.parameters`);
+		for (const [field, value] of Object.entries(tool.parameters)) text(value, `${name}.parameters.${field}`);
+	}
+	record(data.rejectHints, "rejectHints");
+	keys(data.rejectHints, REJECT_HINT_REASONS, "rejectHints");
+	for (const [reason, value] of Object.entries(data.rejectHints)) text(value, `rejectHints.${reason}`);
+	record(data.resumeRejectHints, "resumeRejectHints");
+	keys(data.resumeRejectHints, RESUME_REJECT_HINT_REASONS, "resumeRejectHints");
+	for (const [reason, value] of Object.entries(data.resumeRejectHints)) text(value, `resumeRejectHints.${reason}`);
+	record(data.freshLaunchRejectHints, "freshLaunchRejectHints");
+	keys(data.freshLaunchRejectHints, FRESH_LAUNCH_REJECT_HINT_REASONS, "freshLaunchRejectHints");
+	for (const [reason, value] of Object.entries(data.freshLaunchRejectHints))
+		text(value, `freshLaunchRejectHints.${reason}`);
+	record(data.resumeLaunchRejectHints, "resumeLaunchRejectHints");
+	keys(data.resumeLaunchRejectHints, RESUME_LAUNCH_REJECT_HINT_REASONS, "resumeLaunchRejectHints");
+	for (const [reason, value] of Object.entries(data.resumeLaunchRejectHints))
+		text(value, `resumeLaunchRejectHints.${reason}`);
+	record(data.deliveryResultClauses, "deliveryResultClauses");
+	keys(data.deliveryResultClauses, DELIVERY_RESULT_CLAUSE_KEYS, "deliveryResultClauses");
+	for (const [key, value] of Object.entries(data.deliveryResultClauses)) text(value, `deliveryResultClauses.${key}`);
+	record(data.slottedRejectHints, "slottedRejectHints");
+	keys(data.slottedRejectHints, Object.keys(SLOTTED_REJECT_HINT_SEGMENTS), "slottedRejectHints");
+	for (const reason of Object.keys(SLOTTED_REJECT_HINT_SEGMENTS) as SlottedRejectHintReason[]) {
+		const segments = data.slottedRejectHints[reason];
+		record(segments, `slottedRejectHints.${reason}`);
+		keys(segments, SLOTTED_REJECT_HINT_SEGMENTS[reason], `slottedRejectHints.${reason}`);
+		for (const [key, value] of Object.entries(segments)) text(value, `slottedRejectHints.${reason}.${key}`);
+	}
+	freeze(data);
+	return data as unknown as EntwurfGuidance;
+}
+
+const guidance = parseEntwurfGuidance(readFileSync(new URL("../../ENTWURF.json", import.meta.url), "utf8"));
+
+/** Only these exact payload strings enter tool schemas; _about/history never do. */
+export const ENTWURF_TOOL_GUIDANCE = guidance.tools;
+/** Static next-step text appended to these entwurf_v2 rejections; the decider and wire ids stay code-owned. */
+export const ENTWURF_REJECT_HINTS = guidance.rejectHints;
+/** Static next-step text in these entwurf_resume_call record/liveness rejections; the verb and the shared ACP model hint stay code-owned. */
+export const ENTWURF_RESUME_REJECT_HINTS = guidance.resumeRejectHints;
+/** Static tmux launch-stage hints of entwurf_fresh_call; slot-bearing, ACP and preflight-leaf hints stay code-owned. */
+export const ENTWURF_FRESH_LAUNCH_REJECT_HINTS = guidance.freshLaunchRejectHints;
+/** Static tmux launch-stage hints of entwurf_resume_call, kept apart from the fresh verb even where the text matches. */
+export const ENTWURF_RESUME_LAUNCH_REJECT_HINTS = guidance.resumeLaunchRejectHints;
+/** Static delivery-result clauses of the entwurf_v2 dirty-lock and remote-pair receipts; the receipt syntax around them stays code-owned. */
+export const ENTWURF_DELIVERY_RESULT_CLAUSES = guidance.deliveryResultClauses;
+/** Text on either side of one code-owned slot per reject reason; the slot value and the concatenation stay with the consumer. */
+export const ENTWURF_SLOTTED_REJECT_HINTS = guidance.slottedRejectHints;
+export const ENTWURF_GUIDANCE_VERSION = Object.freeze({
+	schemaVersion: guidance.schemaVersion,
+	revision: guidance.revision,
+});