primcli 1.36.0 → 1.37.0

package/dist/auto-signals-UPcJmV3j.js

@@ -0,0 +1,702 @@
+import { _ as isTrustedSender, c as classifySignalContent } from "./repeats-CQmyvUGQ-CMnOmWgL.js";
+import { d as readMailJson, h as writeMailJson, i as mailId, l as privateMailDirectory, r as mailAddress } from "./shared-mail-files-CZqI1kj6.js";
+import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region src/oclif/presence-provenance.ts
+function readPresenceProjection(detail) {
+	if (!detail || typeof detail !== "object") return null;
+	const value = detail.presence_control;
+	if (value === void 0 || value === null) return null;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {
+		status: "pending",
+		valid_for_ms: 0
+	};
+	const row = value;
+	if (![
+		"verified",
+		"pending",
+		"rejected"
+	].includes(String(row.status)) || typeof row.valid_for_ms !== "number" || !Number.isSafeInteger(row.valid_for_ms) || row.valid_for_ms < 0 || row.valid_for_ms > 6e5) return {
+		status: "pending",
+		valid_for_ms: 0
+	};
+	return row;
+}
+/** Only the authenticated detail projection identifies control mail. */
+function presenceDisposition(detail) {
+	const proof = readPresenceProjection(detail);
+	return !proof || proof.status === "rejected" ? "ordinary" : proof.status === "verified" ? "quiet" : "pending";
+}
+//#endregion
+//#region src/oclif/scoped-chat.ts
+function isConnectedChatCredential(apiKey) {
+	return apiKey?.startsWith("pconn_") ?? false;
+}
+async function readBeforeDeadline(deadline, read) {
+	if (deadline == null) return read(void 0);
+	if (Date.now() >= deadline) return null;
+	const controller = new AbortController();
+	let timer;
+	const arm = () => {
+		const remaining = Math.max(0, deadline - Date.now());
+		const maximumDelay = 2 ** 31 - 1;
+		timer = setTimeout(remaining > maximumDelay ? arm : () => controller.abort(), Math.min(remaining, maximumDelay));
+	};
+	arm();
+	try {
+		const result = await read(controller.signal);
+		return controller.signal.aborted || Date.now() >= deadline ? null : result;
+	} catch (error) {
+		if (controller.signal.aborted) return null;
+		throw error;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function address(value) {
+	return value.trim().toLowerCase();
+}
+function isScopedChatReply(detail, params) {
+	if (presenceDisposition(detail) !== "ordinary") return false;
+	if (!["accepted", "completed"].includes(detail.status) || params.sentId !== void 0 && detail.reply_to_sent_email_id !== params.sentId || address(detail.recipient) !== address(params.from) || address(detail.to_email) !== address(params.from)) return false;
+	return scopedChatSenderTrust(detail, params.recipient).trusted;
+}
+function scopedChatSenderTrust(detail, peer) {
+	const sender = address(peer);
+	return isTrustedSender({ email: {
+		auth: detail.auth,
+		headers: { from: detail.from_header }
+	} }, {
+		sender,
+		domain: sender.slice(sender.lastIndexOf("@") + 1)
+	});
+}
+function isPlainChatReply(detail) {
+	if (presenceDisposition(detail) !== "ordinary") return false;
+	if (detail.parsed?.status !== "complete" || !Array.isArray(detail.parsed.attachments)) return false;
+	return classifySignalContent({
+		inventory: {
+			status: "complete",
+			parts: detail.parsed.attachments.map((part) => ({
+				filename: part.filename ?? null,
+				contentType: part.content_type ?? null
+			}))
+		},
+		bodies: {
+			status: "complete",
+			text: detail.body_text ?? null,
+			html: detail.body_html ?? null
+		},
+		canonicalPartBytes: null
+	}).classification === "plain";
+}
+//#endregion
+//#region src/oclif/auto-signals.ts
+/**
+* Automatic communication signals. When mail from the verified owner or a
+* verified same-organization peer is surfaced to an agent session, the CLI
+* reports `read` once; when the session opens it with `emails get --brief`, the
+* CLI reports `working` and renews it until the agent answers. Every step is
+* best effort: nothing here may block, delay or fail the wake or the read.
+*/
+const AUTO_SIGNALS_OPT_OUT_ENV = "PRIMITIVE_NO_AUTO_SIGNALS";
+const AUTO_SIGNAL_WORKER_ENV = "PRIMITIVE_AUTO_SIGNAL_WORKER";
+const AUTO_SIGNAL_EMAIL_ENV = "PRIMITIVE_AUTO_SIGNAL_EMAIL";
+const AUTO_SIGNAL_KIND_ENV = "PRIMITIVE_AUTO_SIGNAL_KIND";
+/**
+* Receivers accept a working signal only when it expires at most 60 seconds
+* after the server accepted it. A little under 60 tolerates clock skew.
+*/
+const AUTO_WORKING_EXPIRES_SECONDS = 55;
+/** Renew well before expiry so the indicator does not flicker off. */
+const AUTO_WORKING_RENEW_MS = 4e4;
+/** Stop renewing after this long even if no answer was seen. */
+const AUTO_WORKING_CAP_MS = 15 * 6e4;
+/**
+* A renewal in flight is never older than this: the signal send and its
+* reconciliation each abort after 5 seconds. Past it the marker is stale.
+*/
+const SENDING_STALE_MS = 15e3;
+function autoSignalsDisabled(env = process.env) {
+	const value = env[AUTO_SIGNALS_OPT_OUT_ENV]?.trim().toLowerCase();
+	return value !== void 0 && value !== "" && value !== "0" && value !== "false" && value !== "no";
+}
+const profilePattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,62}$/;
+const lower = (value) => typeof value === "string" ? value.trim().toLowerCase() : "";
+/**
+* Whether one admitted email may carry automatic signals. The sender must be
+* authenticated (aligned DMARC) and either be this agent's pinned owner or
+* have been admitted by the organization network policy (an active member or
+* a same-organization agent). The email must be a fully parsed plain email
+* addressed only to this agent, which did not send it. Signals, fyi
+* acknowledgements, interactions, presence checks, contact requests and
+* unverified or external senders never qualify.
+*/
+function autoSignalEligible(detail, identity, admission) {
+	try {
+		if (!admission || admission.kind === "request") return false;
+		const agent = lower(identity.agentAddress);
+		const owner = lower(identity.ownerAddress);
+		const sender = lower(detail.from_email);
+		if (!agent || !sender || sender === agent) return false;
+		if (admission.source !== "network" && !(owner && sender === owner)) return false;
+		if (!scopedChatSenderTrust(detail, sender).trusted) return false;
+		if (lower(detail.recipient) !== agent || lower(detail.to_email) !== agent) return false;
+		if (!["accepted", "completed"].includes(detail.status)) return false;
+		if (!detail.message_id) return false;
+		const parsed = detail.parsed;
+		const to = parsed?.to_addresses;
+		if (!Array.isArray(to) || to.length !== 1 || lower(to[0]?.address) !== agent || (parsed.cc?.length ?? 0) > 0 || (parsed.bcc?.length ?? 0) > 0) return false;
+		return isPlainChatReply(detail);
+	} catch {
+		return false;
+	}
+}
+function sentSignalPath(configDir, sentId) {
+	return join(configDir, "signals", "sent-ids", mailId(sentId));
+}
+/**
+* Remember a signal this profile sent. An automated responder that answers
+* a signal with plain mail must not trigger another automatic signal, or the
+* two would acknowledge each other forever. Never throws.
+*/
+function recordSentSignal(configDir, sentId) {
+	try {
+		const path = sentSignalPath(configDir, sentId);
+		privateMailDirectory(join(configDir, "signals", "sent-ids"), true);
+		writeFileSync(path, "", {
+			flag: "w",
+			mode: 384
+		});
+	} catch {}
+}
+function isSentSignal(configDir, sentId) {
+	try {
+		return Boolean(sentId) && existsSync(sentSignalPath(configDir, sentId ?? ""));
+	} catch {
+		return false;
+	}
+}
+function root(configDir) {
+	return join(configDir, "auto-signals");
+}
+function emailDirectory(configDir, emailId) {
+	return join(root(configDir), mailId(emailId));
+}
+function parseClaim(value) {
+	const row = value;
+	if (!row || row.version !== 1 || typeof row.profile !== "string" || !profilePattern.test(row.profile) || row.thread_id !== null && typeof row.thread_id !== "string") return null;
+	try {
+		return {
+			version: 1,
+			email_id: mailId(row.email_id),
+			profile: row.profile,
+			sender: mailAddress(row.sender),
+			thread_id: row.thread_id === null ? null : mailId(row.thread_id),
+			claimed_at: String(row.claimed_at)
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Record, once per email, that a session surfaced it and it qualified for
+* automatic signals. Returns true only for the first caller, so repeated wakes,
+* redeliveries and concurrent receivers dispatch at most one `read`.
+*/
+function claimAutoRead(configDir, claim, now = Date.now) {
+	if (!profilePattern.test(claim.profileName)) return false;
+	const directory = emailDirectory(configDir, claim.emailId);
+	privateMailDirectory(directory, true);
+	const value = {
+		version: 1,
+		email_id: mailId(claim.emailId),
+		profile: claim.profileName,
+		sender: mailAddress(claim.sender),
+		thread_id: claim.threadId ? mailId(claim.threadId) : null,
+		claimed_at: new Date(now()).toISOString()
+	};
+	try {
+		writeFileSync(join(directory, "read.json"), `${JSON.stringify(value)}\n`, {
+			flag: "wx",
+			mode: 384
+		});
+		return true;
+	} catch (error) {
+		if (error.code === "EEXIST") return false;
+		throw error;
+	}
+}
+function readAutoClaim(configDir, emailId) {
+	try {
+		const claim = parseClaim(readMailJson(join(emailDirectory(configDir, emailId), "read.json")));
+		return claim && claim.email_id === mailId(emailId) ? claim : null;
+	} catch {
+		return null;
+	}
+}
+function leasePath(configDir, emailId) {
+	return join(emailDirectory(configDir, emailId), "working.json");
+}
+/**
+* The stop lives in its own exclusively created file, so a renewer that
+* rewrites working.json with new signal IDs can never undo it.
+*/
+function stopPath(configDir, emailId) {
+	return join(emailDirectory(configDir, emailId), "stopped.json");
+}
+/**
+* Index of active leases, so the startup backstop and peer matching read only
+* live leases instead of every email that was ever acknowledged.
+*/
+function activeIndex(configDir) {
+	return join(root(configDir), "active");
+}
+function markActive(configDir, emailId) {
+	privateMailDirectory(activeIndex(configDir), true);
+	writeFileSync(join(activeIndex(configDir), mailId(emailId)), "", { mode: 384 });
+}
+function unmarkActive(configDir, emailId) {
+	try {
+		unlinkSync(join(activeIndex(configDir), mailId(emailId)));
+	} catch {}
+}
+function readStop(configDir, emailId) {
+	try {
+		const row = readMailJson(stopPath(configDir, emailId), 4096);
+		if (!row || typeof row.at !== "number") return null;
+		return {
+			at: row.at,
+			reason: typeof row.reason === "string" ? row.reason : "stopped",
+			token: typeof row.token === "string" ? row.token : ""
+		};
+	} catch {
+		return null;
+	}
+}
+function readWorkingLease(configDir, emailId) {
+	try {
+		const row = readMailJson(leasePath(configDir, emailId), 64 * 1024);
+		if (!row || row.version !== 1 || typeof row.profile !== "string" || !profilePattern.test(row.profile) || typeof row.started_at !== "number" || !Number.isFinite(row.started_at) || row.stopped_at !== null && typeof row.stopped_at !== "number" || !Array.isArray(row.signal_sent_ids)) return null;
+		const stop = readStop(configDir, emailId);
+		return {
+			version: 1,
+			email_id: mailId(row.email_id),
+			profile: row.profile,
+			sender: mailAddress(row.sender),
+			thread_id: row.thread_id ? mailId(row.thread_id) : null,
+			started_at: row.started_at,
+			stopped_at: stop?.at ?? row.stopped_at,
+			stop_reason: stop?.reason ?? (typeof row.stop_reason === "string" ? row.stop_reason : null),
+			signal_sent_ids: row.signal_sent_ids.slice(-200).map(mailId)
+		};
+	} catch {
+		return null;
+	}
+}
+function writeWorkingLease(configDir, lease) {
+	writeMailJson(leasePath(configDir, lease.email_id), {
+		...lease,
+		stopped_at: null,
+		stop_reason: null
+	});
+}
+/**
+* Start the working lease for an email that already qualified for automatic
+* signals. Only the first caller succeeds, so working is started once per
+* email however many times the session reads it.
+*/
+function startWorkingLease(configDir, emailId, now = Date.now) {
+	const claim = readAutoClaim(configDir, emailId);
+	if (!claim) return null;
+	const lease = {
+		version: 1,
+		email_id: claim.email_id,
+		profile: claim.profile,
+		sender: claim.sender,
+		thread_id: claim.thread_id,
+		started_at: now(),
+		stopped_at: null,
+		stop_reason: null,
+		signal_sent_ids: []
+	};
+	try {
+		writeFileSync(leasePath(configDir, emailId), `${JSON.stringify(lease)}\n`, {
+			flag: "wx",
+			mode: 384
+		});
+	} catch {
+		return null;
+	}
+	try {
+		markActive(configDir, emailId);
+	} catch {}
+	return lease;
+}
+/**
+* Answers that rely on a stop someone else created. While any exist, the
+* creator of that stop may not undo it, even if its own answer was refused.
+*/
+function holdsDirectory(configDir, emailId) {
+	return join(emailDirectory(configDir, emailId), "stop-holds");
+}
+function stopHeld(configDir, emailId) {
+	try {
+		return readdirSync(holdsDirectory(configDir, emailId)).length > 0;
+	} catch {
+		return false;
+	}
+}
+/** Stop a lease, or hold an existing stop. Null when there is no lease. */
+function stopWorkingLease(configDir, emailId, reason, now = Date.now) {
+	if (!readWorkingLease(configDir, emailId)) return null;
+	const token = randomUUID();
+	const hold = join(holdsDirectory(configDir, emailId), token);
+	privateMailDirectory(holdsDirectory(configDir, emailId), true);
+	writeFileSync(hold, "", { mode: 384 });
+	try {
+		writeFileSync(stopPath(configDir, emailId), `${JSON.stringify({
+			at: now(),
+			reason,
+			token
+		})}\n`, {
+			flag: "wx",
+			mode: 384
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") return {
+			token,
+			owner: false
+		};
+		throw error;
+	}
+	try {
+		unlinkSync(hold);
+	} catch {}
+	return {
+		token,
+		owner: true
+	};
+}
+function pendingPath(configDir, emailId) {
+	return join(emailDirectory(configDir, emailId), "restore-pending.json");
+}
+/**
+* Undo a stop this process made, for an answer known not to have been sent.
+* A stop made by anyone else (cap, answered, another reply) is left alone.
+* While a later answer holds the stop it stays in place, and the restore is
+* left pending: the last holder to release finishes it if its answer was
+* refused too (see releaseStopHold).
+*/
+function restoreWorkingLease(configDir, emailId, token) {
+	try {
+		const stop = readStop(configDir, emailId);
+		if (!stop || stop.token !== token) return false;
+		writeFileSync(pendingPath(configDir, emailId), JSON.stringify({ token }), { mode: 384 });
+		if (stopHeld(configDir, emailId)) return false;
+		markActive(configDir, emailId);
+		unlinkSync(stopPath(configDir, emailId));
+		if (stopHeld(configDir, emailId)) {
+			try {
+				writeFileSync(stopPath(configDir, emailId), `${JSON.stringify(stop)}\n`, {
+					flag: "wx",
+					mode: 384
+				});
+			} catch {}
+			return false;
+		}
+		try {
+			unlinkSync(pendingPath(configDir, emailId));
+		} catch {}
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Release a hold for an answer known not to have been sent. If the stop's
+* owner was refused too and is waiting on holds, the last release restores
+* the lease. Returns true when it restored it.
+*/
+function releaseStopHold(configDir, emailId, token) {
+	try {
+		try {
+			unlinkSync(join(holdsDirectory(configDir, emailId), token));
+		} catch {
+			return false;
+		}
+		if (stopHeld(configDir, emailId)) return false;
+		let pending = null;
+		try {
+			const row = JSON.parse(readFileSync(pendingPath(configDir, emailId), "utf8"));
+			pending = typeof row.token === "string" ? row.token : null;
+		} catch {
+			return false;
+		}
+		return pending !== null && restoreWorkingLease(configDir, emailId, pending);
+	} catch {
+		return false;
+	}
+}
+function sendingPath(configDir, emailId) {
+	return join(emailDirectory(configDir, emailId), "sending");
+}
+/** Mark a renewal in flight so a reply can wait for it to settle. */
+function markWorkingSending(configDir, emailId) {
+	writeFileSync(sendingPath(configDir, emailId), JSON.stringify({
+		pid: process.pid,
+		at: Date.now()
+	}), { mode: 384 });
+}
+function clearWorkingSending(configDir, emailId) {
+	try {
+		unlinkSync(sendingPath(configDir, emailId));
+	} catch {}
+}
+function sendingInFlight(configDir, emailId) {
+	try {
+		const value = JSON.parse(readFileSync(sendingPath(configDir, emailId), "utf8"));
+		if (typeof value.at !== "number" || Date.now() - value.at > SENDING_STALE_MS) return false;
+		if (typeof value.pid === "number") process.kill(value.pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* A stopped lease stays indexed this long, so a later answer to the same
+* sender can still find it and hold its stop against a refused earlier one.
+*/
+const STOPPED_INDEX_MS = 10 * 6e4;
+function indexedLeases(configDir, now) {
+	let entries;
+	try {
+		entries = readdirSync(activeIndex(configDir));
+	} catch {
+		return [];
+	}
+	return entries.flatMap((entry) => {
+		if (!/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(entry)) return [];
+		const lease = readWorkingLease(configDir, entry);
+		if (!lease || lease.stopped_at !== null && now() - lease.stopped_at >= STOPPED_INDEX_MS || now() - lease.started_at >= 9e5 * 2) {
+			unmarkActive(configDir, entry);
+			return [];
+		}
+		return [lease];
+	});
+}
+/**
+* Active, unstopped leases in this config directory, read from the lease
+* index rather than every email ever acknowledged. Old entries are pruned.
+*/
+function activeWorkingLeases(configDir, now = Date.now) {
+	return indexedLeases(configDir, now).filter((lease) => lease.stopped_at === null);
+}
+/**
+* Stop automatic working for the emails an outgoing message answers, before
+* that message is sent, then wait for any renewal already in flight to land
+* first. A renewal that reached receivers after the answer would show the
+* agent as working again. The wait ends when the renewal settles, which is
+* normally immediate and is bounded by the send timeouts. Never throws.
+*/
+async function haltAutoWorking(configDir, match, reason, options = {}) {
+	const halted = {
+		configDir,
+		stops: []
+	};
+	try {
+		const ids = /* @__PURE__ */ new Set();
+		for (const id of match.emailIds ?? []) try {
+			ids.add(mailId(id));
+		} catch {}
+		const peers = new Set((match.peers ?? []).map(lower).filter(Boolean));
+		const candidates = /* @__PURE__ */ new Map();
+		for (const lease of indexedLeases(configDir, Date.now)) candidates.set(lease.email_id, lease);
+		for (const id of ids) {
+			const lease = readWorkingLease(configDir, id);
+			if (lease) candidates.set(id, lease);
+		}
+		const stopped = [];
+		for (const lease of candidates.values()) {
+			const byPeer = peers.has(lease.sender) && match.profileName !== void 0 && match.profileName === lease.profile;
+			if (!ids.has(lease.email_id) && !byPeer) continue;
+			try {
+				const stop = stopWorkingLease(configDir, lease.email_id, reason);
+				if (stop) halted.stops.push({
+					emailId: lease.email_id,
+					...stop
+				});
+				stopped.push(lease.email_id);
+			} catch {}
+		}
+		const deadline = Date.now() + (options.settleMs ?? SENDING_STALE_MS);
+		while (stopped.some((id) => sendingInFlight(configDir, id)) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 50));
+	} catch {}
+	return halted;
+}
+/**
+* The answer was definitively refused, so nothing reached the sender: put
+* back the working indication this answer stopped. Never throws.
+*/
+function restoreAutoWorking(halted, options = {}) {
+	try {
+		let restored = 0;
+		for (const stop of halted.stops) {
+			if (!(stop.owner ? restoreWorkingLease(halted.configDir, stop.emailId, stop.token) : releaseStopHold(halted.configDir, stop.emailId, stop.token))) continue;
+			restored++;
+			const lease = readWorkingLease(halted.configDir, stop.emailId);
+			if (lease) spawnAutoSignalWorker({
+				configDir: halted.configDir,
+				emailId: lease.email_id,
+				kind: "working",
+				profileName: lease.profile,
+				env: options.env ?? process.env,
+				spawnImpl: options.spawnImpl
+			});
+		}
+		return restored;
+	} catch {
+		return 0;
+	}
+}
+/** The CLI entrypoint that runs a detached signal worker. */
+function autoSignalEntrypoint() {
+	const candidates = ["../../bin/run.js", "../bin/run.js"].map((path) => fileURLToPath(new URL(path, import.meta.url)));
+	return candidates.find((path) => existsSync(path)) ?? candidates[0] ?? "";
+}
+/**
+* Run one automatic signal in a detached process with no inherited stdio, so
+* the calling command's output, exit status and timing are unchanged.
+*/
+function spawnAutoSignalWorker(options) {
+	try {
+		const env = { ...options.env ?? process.env };
+		if (autoSignalsDisabled(env)) return false;
+		if (!profilePattern.test(options.profileName)) return false;
+		const entry = options.entry ?? autoSignalEntrypoint();
+		if (!options.spawnImpl && !existsSync(entry)) return false;
+		delete env.PRIMITIVE_API_KEY;
+		delete env.PRIMITIVE_KEY;
+		const child = (options.spawnImpl ?? spawn)(process.execPath, [entry], {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true,
+			env: {
+				...env,
+				PRIMITIVE_CONFIG_DIR: options.configDir,
+				PRIMITIVE_AGENT_PROFILE: options.profileName,
+				PRIMITIVE_SKIP_NEW_VERSION_CHECK: "true",
+				[AUTO_SIGNAL_WORKER_ENV]: "1",
+				[AUTO_SIGNAL_EMAIL_ENV]: mailId(options.emailId),
+				[AUTO_SIGNAL_KIND_ENV]: options.kind
+			}
+		});
+		child.on("error", () => void 0);
+		child.unref();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Called when a receiver surfaces mail to a session: claim the email once and
+* send `read` in the background. Never throws and never writes output.
+*/
+function dispatchAutoRead(options) {
+	try {
+		const env = options.env ?? process.env;
+		if (autoSignalsDisabled(env) || !options.profileName) return false;
+		if (isSentSignal(options.configDir, options.replyToSentEmailId)) return false;
+		if (!claimAutoRead(options.configDir, {
+			emailId: options.emailId,
+			profileName: options.profileName,
+			sender: options.sender,
+			threadId: options.threadId
+		})) return false;
+		return spawnAutoSignalWorker({
+			configDir: options.configDir,
+			emailId: options.emailId,
+			kind: "read",
+			profileName: options.profileName,
+			env,
+			spawnImpl: options.spawnImpl
+		});
+	} catch {
+		return false;
+	}
+}
+/**
+* Called after the session reads an email with `emails get --brief`: start
+* working once for mail that already qualified for automatic signals.
+*/
+function dispatchAutoWorking(options) {
+	try {
+		const env = options.env ?? process.env;
+		if (autoSignalsDisabled(env)) return false;
+		const lease = startWorkingLease(options.configDir, options.emailId);
+		if (!lease) return false;
+		return spawnAutoSignalWorker({
+			configDir: options.configDir,
+			emailId: lease.email_id,
+			kind: "working",
+			profileName: lease.profile,
+			env,
+			spawnImpl: options.spawnImpl
+		});
+	} catch {
+		return false;
+	}
+}
+function renewerPath(configDir, emailId) {
+	return join(emailDirectory(configDir, emailId), "renewer.json");
+}
+function recordRenewer(configDir, emailId) {
+	writeFileSync(renewerPath(configDir, emailId), JSON.stringify({
+		pid: process.pid,
+		at: Date.now()
+	}), { mode: 384 });
+}
+function renewerAlive(configDir, emailId) {
+	try {
+		const value = JSON.parse(readFileSync(renewerPath(configDir, emailId), "utf8"));
+		if (typeof value.pid !== "number" || typeof value.at !== "number") return false;
+		if (Date.now() - value.at > 4e4 * 2) return false;
+		process.kill(value.pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Backstop for runtimes that end background processes between tool calls:
+* any CLI invocation restarts a renewer for an active lease whose renewer is
+* gone. Cheap when there are no leases. Never throws.
+*/
+function resumeAutoWorking(configDir, options = {}) {
+	try {
+		const env = options.env ?? process.env;
+		if (autoSignalsDisabled(env) || env["PRIMITIVE_AUTO_SIGNAL_WORKER"] === "1") return 0;
+		const now = (options.now ?? Date.now)();
+		let started = 0;
+		for (const lease of activeWorkingLeases(configDir, () => now)) {
+			if (now - lease.started_at >= 9e5) continue;
+			if (renewerAlive(configDir, lease.email_id)) continue;
+			if (spawnAutoSignalWorker({
+				configDir,
+				emailId: lease.email_id,
+				kind: "working",
+				profileName: lease.profile,
+				env,
+				spawnImpl: options.spawnImpl
+			})) started++;
+		}
+		return started;
+	} catch {
+		return 0;
+	}
+}
+//#endregion
+export { stopWorkingLease as A, releaseStopHold as C, resumeAutoWorking as D, restoreWorkingLease as E, readBeforeDeadline as F, scopedChatSenderTrust as I, presenceDisposition as L, isConnectedChatCredential as M, isPlainChatReply as N, spawnAutoSignalWorker as O, isScopedChatReply as P, readPresenceProjection as R, recordSentSignal as S, restoreAutoWorking as T, isSentSignal as _, AUTO_WORKING_CAP_MS as a, readWorkingLease as b, activeWorkingLeases as c, autoSignalsDisabled as d, claimAutoRead as f, haltAutoWorking as g, dispatchAutoWorking as h, AUTO_SIGNAL_WORKER_ENV as i, writeWorkingLease as j, startWorkingLease as k, autoSignalEligible as l, dispatchAutoRead as m, AUTO_SIGNAL_EMAIL_ENV as n, AUTO_WORKING_EXPIRES_SECONDS as o, clearWorkingSending as p, AUTO_SIGNAL_KIND_ENV as r, AUTO_WORKING_RENEW_MS as s, AUTO_SIGNALS_OPT_OUT_ENV as t, autoSignalEntrypoint as u, markWorkingSending as v, renewerAlive as w, recordRenewer as x, readAutoClaim as y };