primcli 1.36.0 → 1.37.0

package/dist/{listen-background-D6UhIbkO.js → listen-background-Bsofqq_6.js}

@@ -1,4 +1,4 @@
-import { _ as acquireListenLock, a as mailLockBusy, b as listenProcessIdentity, d as readMailJson, f as removeMailFile, g as ListenStateError, h as writeMailJson, i as mailId, l as privateMailDirectory, o as mailObject, s as mailString, v as compareListenProcessIdentity } from "./shared-mail-files-Cbwnf79a.js";
+import { _ as acquireListenLock, a as mailLockBusy, b as listenProcessIdentity, d as readMailJson, f as removeMailFile, g as ListenStateError, h as writeMailJson, i as mailId, l as privateMailDirectory, o as mailObject, s as mailString, v as compareListenProcessIdentity } from "./shared-mail-files-CZqI1kj6.js";
 import { lstatSync, realpathSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { join } from "node:path";
@@ -14,6 +14,7 @@ const STALE_AFTER_MS = 15e3;
 const RESTART_WINDOW_MS = 10 * 6e4;
 const HEALTHY_RESET_MS = 10 * 6e4;
 const MAX_FAILURES = 5;
+const RESTART_COOLDOWN_MS = 5 * 6e4;
 const phases = [
 	"starting",
 	"receiving",
@@ -26,11 +27,49 @@ const failureCodes = [
 	"notification-outcome-unknown",
 	"connection-changed",
 	"receiving-failed",
-	"restart-budget-exhausted"
+	"restart-budget-exhausted",
+	"disk-full",
+	"storage-unavailable",
+	"crashed",
+	"unrecognized"
+];
+const HOLDING_FAILURE_CODES = [
+	"notification-outcome-unknown",
+	"connection-changed",
+	"unrecognized"
 ];
 function knownFailureCode(value) {
 	return failureCodes.includes(value) ? value : null;
 }
+/** A newer CLI may record a code this version does not know; keep the record readable. */
+function savedFailureCode(value) {
+	if (value === null || value === void 0) return null;
+	return knownFailureCode(value) ?? "unrecognized";
+}
+const DISK_FULL_ERRORS = new Set(["ENOSPC", "EDQUOT"]);
+const STORAGE_ERRORS = new Set([
+	"EIO",
+	"EROFS",
+	"EMFILE",
+	"ENFILE",
+	"EAGAIN",
+	"EBUSY",
+	"ENOMEM"
+]);
+/** Classify local storage failures that a later retry can outlive. */
+function storageFailureCode(error) {
+	const errno = (value) => value && typeof value === "object" ? value.code : void 0;
+	const code = errno(error) ?? errno(error && typeof error === "object" ? error.cause : null);
+	if (typeof code !== "string") return null;
+	if (DISK_FULL_ERRORS.has(code)) return "disk-full";
+	if (STORAGE_ERRORS.has(code)) return "storage-unavailable";
+	return null;
+}
+/** Whether a stopped receiver may be restarted without an explicit owner action. */
+function backgroundListenRestartable(status) {
+	if (status.reason === "exited") return true;
+	return status.reason === "failed" && status.failureCode !== null && !HOLDING_FAILURE_CODES.includes(status.failureCode);
+}
 function failureGuidance(code) {
 	switch (code) {
 		case "native-session-unavailable": return "Open the same native session with local-session support and check its socket permissions before restarting the listener.";
@@ -38,6 +77,26 @@ function failureGuidance(code) {
 		case "connection-changed": return "The selected connection changed. Check the intended profile and API origin before starting the listener again.";
 		case "receiving-failed": return "Inspect listener status and run the same command without --background for details.";
 		case "restart-budget-exhausted": return "The listener repeatedly exited. Inspect listener status before starting it again.";
+		case "disk-full": return "The disk was full, so the receiver could not save its state. Free disk space; the receiver retries on its own.";
+		case "storage-unavailable": return "The receiver could not read or write its local state. Check the config directory's disk and permissions; the receiver retries on its own.";
+		case "crashed": return "The receiver exited without reporting a reason. It is restarted automatically; inspect status if this repeats.";
+		case "unrecognized": return "A newer Primitive CLI recorded this receiver's state. Inspect it with that version before restarting.";
+	}
+}
+/** One sentence an owner or agent can act on; never raw error text. */
+function statusDetail(status) {
+	if (status.healthy) return null;
+	const guidance = status.failureCode ? failureGuidance(status.failureCode) : "";
+	const withGuidance = (text) => guidance ? `${text} ${guidance}` : text;
+	switch (status.reason) {
+		case "exited": return "The receiver stopped unexpectedly and new mail is not reaching this session. Any primitive command run from this session restarts it, or start it again with the same listen command.";
+		case "restarting": return withGuidance("The receiver is restarting; new mail waits until it is back.");
+		case "failed": return withGuidance("The receiver stopped and new mail is not reaching this session.");
+		case "stale": return withGuidance("The receiver has not recorded a heartbeat recently. It may be unable to write local state.");
+		case "unverifiable": return "The receiver's process cannot be verified.";
+		case "stopped": return "The receiver was stopped.";
+		case "absent": return "No background receiver is recorded for this session.";
+		default: return guidance || null;
 	}
 }
 function backgroundListenToken(env = process.env) {
@@ -117,7 +176,7 @@ function readSupervisor(path) {
 		"running",
 		"stopped",
 		"failed"
-	].includes(String(row.phase)) || !Number.isSafeInteger(row.updatedAt) || Number(row.updatedAt) < 0 || row.failureCode !== null && knownFailureCode(row.failureCode) === null) throw new ListenStateError("Background supervisor state is invalid. Preserve it before retrying.");
+	].includes(String(row.phase)) || !Number.isSafeInteger(row.updatedAt) || Number(row.updatedAt) < 0 || row.failureCode !== null && typeof row.failureCode !== "string") throw new ListenStateError("Background supervisor state is invalid. Preserve it before retrying.");
 	return {
 		version: 1,
 		token: mailId(row.token),
@@ -125,7 +184,7 @@ function readSupervisor(path) {
 		identity: mailString(row.identity),
 		phase: row.phase,
 		updatedAt: Number(row.updatedAt),
-		failureCode: knownFailureCode(row.failureCode)
+		failureCode: savedFailureCode(row.failureCode)
 	};
 }
 function readState(path) {
@@ -142,7 +201,7 @@ function readState(path) {
 		...typeof value === "object" && Object.hasOwn(value, "failureCode") ? ["failureCode"] : [],
 		"updatedAt"
 	]);
-	if (row.version !== 1 || !Number.isSafeInteger(row.pid) || Number(row.pid) < 1 || !phases.includes(row.phase) || typeof row.detached !== "boolean" || row.configuration !== null && typeof row.configuration !== "string" || row.failureCode !== void 0 && row.failureCode !== null && knownFailureCode(row.failureCode) === null || !Number.isSafeInteger(row.updatedAt) || Number(row.updatedAt) < 0) throw new ListenStateError("Background listener state is invalid. Preserve it before retrying.");
+	if (row.version !== 1 || !Number.isSafeInteger(row.pid) || Number(row.pid) < 1 || !phases.includes(row.phase) || typeof row.detached !== "boolean" || row.configuration !== null && typeof row.configuration !== "string" || row.failureCode !== void 0 && row.failureCode !== null && typeof row.failureCode !== "string" || !Number.isSafeInteger(row.updatedAt) || Number(row.updatedAt) < 0) throw new ListenStateError("Background listener state is invalid. Preserve it before retrying.");
 	return {
 		version: 1,
 		token: mailId(row.token),
@@ -151,7 +210,7 @@ function readState(path) {
 		phase: row.phase,
 		detached: row.detached,
 		configuration: configurationFingerprint(row.configuration === null ? void 0 : String(row.configuration)),
-		failureCode: knownFailureCode(row.failureCode),
+		failureCode: savedFailureCode(row.failureCode),
 		updatedAt: Number(row.updatedAt)
 	};
 }
@@ -174,7 +233,12 @@ function status(state) {
 		healthy: false,
 		failureCode: null,
 		reason: "absent",
-		updatedAt: null
+		updatedAt: null,
+		detail: statusDetail({
+			healthy: false,
+			reason: "absent",
+			failureCode: null
+		})
 	};
 	const age = Date.now() - state.updatedAt;
 	const ownership = owner(state);
@@ -186,7 +250,12 @@ function status(state) {
 		healthy: reason === null,
 		failureCode: state.failureCode,
 		reason,
-		updatedAt: state.updatedAt
+		updatedAt: state.updatedAt,
+		detail: statusDetail({
+			healthy: reason === null,
+			reason,
+			failureCode: state.failureCode
+		})
 	};
 }
 /** Absence means no managed record, not proof that an older foreground listener is absent. */
@@ -200,16 +269,47 @@ function backgroundListenStatus(target) {
 	const fresh = age >= 0 && age < STALE_AFTER_MS;
 	const active = supervisor.phase === "starting" || supervisor.phase === "running";
 	const reason = supervisor.phase === "failed" ? "failed" : supervisor.phase === "stopped" ? "stopped" : ownership === "gone" ? "exited" : ownership === "unknown" ? "unverifiable" : !fresh ? "stale" : worker.healthy ? null : "restarting";
+	const healthy = active && reason === null;
+	const failureCode = healthy ? null : supervisor.failureCode ?? worker.failureCode;
 	return {
 		...worker,
 		phase: supervisor.phase === "failed" ? "failed" : reason === "restarting" ? "reconnecting" : worker.phase,
-		healthy: active && reason === null,
+		healthy,
 		reason,
-		failureCode: supervisor.failureCode ?? worker.failureCode,
+		failureCode,
 		supervisorPid: supervisor.pid,
-		supervisorUpdatedAt: supervisor.updatedAt
+		supervisorUpdatedAt: supervisor.updatedAt,
+		detail: statusDetail({
+			healthy,
+			reason,
+			failureCode
+		})
 	};
 }
+/**
+* Claim the shared restart slot for one receiver. False means another restart
+* was attempted recently, or the claim could not be recorded (for example on a
+* full disk), so the caller must not start one.
+*/
+function claimBackgroundListenRestart(target, now = Date.now()) {
+	let release;
+	try {
+		const paths = files(target, true);
+		release = acquireListenLock(paths.directory, "background-restart-claim");
+		const path = join(paths.directory, "restart.json");
+		const prior = readMailJson(path, 256);
+		const at = prior && typeof prior === "object" && !Array.isArray(prior) ? prior.at : void 0;
+		if (typeof at === "number" && at <= now && now - at < 6e4) return false;
+		writeMailJson(path, { at: now });
+		return true;
+	} catch {
+		return false;
+	} finally {
+		try {
+			release?.();
+		} catch {}
+	}
+}
 function stopToken(path) {
 	const value = readMailJson(path, 512);
 	if (value === null) return null;
@@ -284,14 +384,36 @@ async function runBackgroundListen(options) {
 		writeMailJson(paths.state, state);
 		started = true;
 	};
+	let relaunched = false;
+	let nextRelaunchCheck = 0;
+	const supervised = process.env[SUPERVISOR_WORKER_ENV] === token;
+	const watchSupervisor = () => {
+		if (!supervised || relaunched || controller.signal.aborted || Date.now() < nextRelaunchCheck) return;
+		const supervisor = readSupervisor(paths.supervisor);
+		if (!supervisor || supervisor.token !== token) return;
+		if (process.connected && Date.now() - supervisor.updatedAt < STALE_AFTER_MS) return;
+		if (!(supervisor.phase === "starting" || supervisor.phase === "running" || supervisor.phase === "failed" && supervisor.failureCode === "crashed") || owner(supervisor) !== "gone") return;
+		if (!claimBackgroundListenRestart(options)) {
+			nextRelaunchCheck = Date.now() + 5e3;
+			return;
+		}
+		relaunched = true;
+		(options.relaunchSupervisor ?? relaunchSupervisor)();
+	};
 	const tick = () => {
 		try {
 			if (stopToken(paths.stop) === token) cancel();
 			publish();
 		} catch (error) {
-			failure ??= { error };
-			cancel();
+			if (storageFailureCode(error) === null) {
+				failure ??= { error };
+				cancel();
+				return;
+			}
 		}
+		try {
+			watchSupervisor();
+		} catch {}
 	};
 	options.signal?.addEventListener("abort", cancel, { once: true });
 	process.on("SIGTERM", cancel);
@@ -332,7 +454,8 @@ async function runBackgroundListen(options) {
 	} catch (error) {
 		failure ??= { error };
 		try {
-			state.failureCode = knownFailureCode(options.failureCode?.(failure.error)) ?? "receiving-failed";
+			const reported = knownFailureCode(options.failureCode?.(failure.error)) ?? "receiving-failed";
+			state.failureCode = reported === "receiving-failed" ? storageFailureCode(failure.error) ?? reported : reported;
 		} catch {
 			state.failureCode = "receiving-failed";
 		}
@@ -358,8 +481,27 @@ async function runBackgroundListen(options) {
 	}
 	if (failure) throw failure.error;
 }
-/** Supervise one exact listener generation until a stop or the restart budget is exhausted. */
-async function runBackgroundListenSupervisor() {
+/** Relaunch this worker's own command detached, with --background restored. */
+function relaunchSupervisor() {
+	const env = { ...process.env };
+	delete env[BACKGROUND_LISTEN_TOKEN_ENV];
+	delete env[BACKGROUND_LISTEN_TARGET_ENV];
+	delete env[SUPERVISOR_WORKER_ENV];
+	const child = spawn(process.execPath, [
+		...process.execArgv,
+		...process.argv.slice(1),
+		"--background"
+	], {
+		env,
+		detached: true,
+		windowsHide: true,
+		stdio: "ignore"
+	});
+	child.on("error", () => {});
+	child.unref();
+}
+/** Supervise one exact listener generation until a stop or a holding failure. */
+async function runBackgroundListenSupervisor(options = {}) {
 	const token = mailId(process.env[BACKGROUND_LISTEN_TOKEN_ENV]);
 	const expected = mailObject(JSON.parse(process.env["PRIMITIVE_LISTEN_BACKGROUND_TARGET"] ?? ""), [
 		"scope",
@@ -376,6 +518,8 @@ async function runBackgroundListenSupervisor() {
 	const argvValue = JSON.parse(process.env[SUPERVISOR_ARGV_ENV] ?? "");
 	if (!Array.isArray(argvValue) || argvValue.length < 1 || argvValue.some((part) => typeof part !== "string" || part.length > 4096)) throw new ListenStateError("Background supervisor command is invalid.");
 	const argv = argvValue;
+	const restartDelayMs = options.restartDelayMs ?? 1e3;
+	const cooldownMs = options.cooldownMs ?? RESTART_COOLDOWN_MS;
 	const paths = files(target, true);
 	const release = acquireListenLock(paths.directory, "background-supervisor");
 	const identity = listenProcessIdentity(process.pid);
@@ -398,31 +542,59 @@ async function runBackgroundListenSupervisor() {
 		record.updatedAt = Date.now();
 		writeMailJson(paths.supervisor, record);
 	};
+	const tryPublish = () => {
+		try {
+			publish();
+		} catch (error) {
+			if (storageFailureCode(error) === null) throw error;
+		}
+	};
+	const stopRequested = () => {
+		try {
+			return stopToken(paths.stop) === token;
+		} catch (error) {
+			if (storageFailureCode(error) !== null) return false;
+			throw error;
+		}
+	};
 	let child;
 	let stopped = false;
 	const cancel = () => {
 		stopped = true;
-		writeMailJson(paths.stop, { token });
+		try {
+			writeMailJson(paths.stop, { token });
+		} catch {}
 		child?.kill("SIGTERM");
 	};
 	process.on("SIGTERM", cancel);
 	process.on("SIGINT", cancel);
+	const crashed = () => {
+		record.phase = "failed";
+		record.failureCode = "crashed";
+		try {
+			tryPublish();
+		} catch {}
+		child?.kill("SIGTERM");
+		process.exit(1);
+	};
+	process.on("uncaughtException", crashed);
+	process.on("unhandledRejection", crashed);
 	const heartbeat = setInterval(() => {
 		try {
-			if (stopToken(paths.stop) === token) {
+			if (stopRequested()) {
 				stopped = true;
 				child?.kill("SIGTERM");
 			}
-			publish();
+			tryPublish();
 		} catch {
 			cancel();
 		}
 	}, 1e3);
 	const failures = [];
 	try {
-		publish();
+		tryPublish();
 		while (!stopped) {
-			if (stopToken(paths.stop) === token) break;
+			if (stopRequested()) break;
 			const env = {
 				...process.env,
 				[SUPERVISOR_WORKER_ENV]: token
@@ -440,51 +612,66 @@ async function runBackgroundListenSupervisor() {
 				]
 			});
 			let readyAt = null;
+			let reported = null;
 			child.on("message", (message) => {
 				if (!message || typeof message !== "object") return;
 				const row = message;
 				if (row.type !== "primitive-listen-state" || row.token !== token) return;
-				if (row.phase === "receiving" && readyAt === null) readyAt = Date.now();
+				if (row.phase === "receiving") {
+					if (readyAt === null) readyAt = Date.now();
+					if (record.failureCode !== null) {
+						record.failureCode = null;
+						tryPublish();
+					}
+				}
+				if (row.phase === "failed") reported = knownFailureCode(row.failureCode) ?? "receiving-failed";
 				try {
 					if (process.connected) process.send?.(message, () => {});
 				} catch {}
 			});
 			record.phase = "running";
-			publish();
-			await new Promise((resolve) => {
-				child?.once("exit", () => resolve());
-				child?.once("error", () => resolve());
+			tryPublish();
+			const exit = await new Promise((resolve) => {
+				child?.once("exit", (code, signal) => resolve({
+					code,
+					signal
+				}));
+				child?.once("error", () => resolve({
+					code: null,
+					signal: null
+				}));
 			});
 			child = void 0;
-			if (stopped || stopToken(paths.stop) === token) break;
-			const worker = readState(paths.state);
-			if (worker?.token === token && worker.phase === "failed" && ["notification-outcome-unknown", "connection-changed"].includes(worker.failureCode ?? "")) {
+			if (stopped || stopRequested()) break;
+			let worker = null;
+			try {
+				worker = readState(paths.state);
+			} catch {}
+			const recorded = worker?.token === token && worker.phase === "failed" ? worker.failureCode : null;
+			const failureCode = reported ?? recorded ?? (exit.code === 0 && exit.signal === null ? "receiving-failed" : "crashed");
+			if (HOLDING_FAILURE_CODES.includes(failureCode)) {
 				record.phase = "failed";
-				record.failureCode = worker.failureCode;
-				publish();
+				record.failureCode = failureCode;
+				tryPublish();
 				return;
 			}
 			const now = Date.now();
 			if (readyAt !== null && now - readyAt >= HEALTHY_RESET_MS) failures.length = 0;
 			failures.push(now);
 			while (failures.length && (failures[0] ?? now) < now - RESTART_WINDOW_MS) failures.shift();
-			if (failures.length >= MAX_FAILURES) {
-				record.phase = "failed";
-				record.failureCode = "restart-budget-exhausted";
-				publish();
-				return;
-			}
+			const backoff = failures.length >= MAX_FAILURES ? cooldownMs : Math.min(restartDelayMs * 2 ** (failures.length - 1), 3e4);
 			record.phase = "starting";
-			publish();
-			const backoff = Math.min(1e3 * 2 ** (failures.length - 1), 3e4);
+			record.failureCode = failureCode;
+			tryPublish();
 			const end = Date.now() + backoff;
-			while (!stopped && Date.now() < end && stopToken(paths.stop) !== token) await setTimeout$1(Math.min(200, end - Date.now()));
+			while (!stopped && Date.now() < end && !stopRequested()) await setTimeout$1(Math.min(200, end - Date.now()));
 		}
 		record.phase = "stopped";
-		publish();
+		record.failureCode = null;
+		tryPublish();
 	} catch (error) {
 		record.phase = "failed";
-		record.failureCode = "receiving-failed";
+		record.failureCode = "crashed";
 		try {
 			publish();
 		} catch {}
@@ -493,9 +680,13 @@ async function runBackgroundListenSupervisor() {
 		clearInterval(heartbeat);
 		process.off("SIGTERM", cancel);
 		process.off("SIGINT", cancel);
+		process.off("uncaughtException", crashed);
+		process.off("unhandledRejection", crashed);
 		child?.kill("SIGTERM");
-		if (stopToken(paths.stop) === token) removeMailFile(paths.stop);
-		if (record.phase === "stopped" && readState(paths.state) === null) removeMailFile(paths.supervisor);
+		try {
+			if (stopToken(paths.stop) === token) removeMailFile(paths.stop);
+			if (record.phase === "stopped" && readState(paths.state) === null) removeMailFile(paths.supervisor);
+		} catch {}
 		release();
 	}
 }
@@ -542,11 +733,13 @@ async function startBackgroundListen(options) {
 			const current = status(prior);
 			if (!current.healthy) throw new ListenStateError("Existing listener ownership is stale or unverifiable; the worker was retained. Inspect status or request a stop before restarting.");
 			if (!prior.detached) throw new ListenStateError("An existing foreground listener owns this session. Stop it before restarting with --background.");
-			if (prior.configuration !== configuration) throw new ListenStateError("Stop the existing listener before changing receiving options.");
-			if (!priorSupervisor) return {
-				started: false,
-				status: current
-			};
+			if (!priorSupervisor) {
+				if (prior.configuration !== configuration) throw new ListenStateError("Stop the existing listener before changing receiving options.");
+				return {
+					started: false,
+					status: current
+				};
+			}
 			if (!await stopOrphanedWorker(paths, prior.token)) throw new ListenStateError("The existing background listener lost its supervisor and did not stop. Stop it, then start again.");
 		}
 		const token = randomUUID();
@@ -644,4 +837,4 @@ async function startBackgroundListen(options) {
 	}
 }
 //#endregion
-export { startBackgroundListen as a, runBackgroundListenSupervisor as i, backgroundListenToken as n, stopBackgroundListen as o, runBackgroundListen as r, verifyBackgroundListenTarget as s, backgroundListenStatus as t };
+export { claimBackgroundListenRestart as a, startBackgroundListen as c, backgroundListenToken as i, stopBackgroundListen as l, backgroundListenRestartable as n, runBackgroundListen as o, backgroundListenStatus as r, runBackgroundListenSupervisor as s, BACKGROUND_LISTEN_TOKEN_ENV as t, verifyBackgroundListenTarget as u };

package/dist/oclif/auto-signal-worker.js

@@ -0,0 +1,167 @@
+import { j as getSentEmail } from "../sdk.gen-CugwPoCf.js";
+import { _ as acquireListenLock } from "../shared-mail-files-CZqI1kj6.js";
+import { Mt as createAuthenticatedCliApiClient, t as sendSignal, z as readThreadContext } from "../signal-command-CKaEqXro.js";
+import { A as stopWorkingLease, b as readWorkingLease, d as autoSignalsDisabled, j as writeWorkingLease, p as clearWorkingSending, r as AUTO_SIGNAL_KIND_ENV, s as AUTO_WORKING_RENEW_MS, v as markWorkingSending, x as recordRenewer, y as readAutoClaim } from "../auto-signals-UPcJmV3j.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+//#region src/oclif/auto-signal-worker.ts
+function configDirectory(env) {
+	if (env.PRIMITIVE_CONFIG_DIR) return env.PRIMITIVE_CONFIG_DIR;
+	return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "primitive");
+}
+async function defaultContext(configDir, profile) {
+	const { apiClient, auth } = await createAuthenticatedCliApiClient({ configDir });
+	if (!auth.connectedAgent || auth.connectedAgent.profileName !== profile) throw new Error("The automatic signal profile is unavailable.");
+	return {
+		apiClient,
+		apiKey: auth.apiKey,
+		configDir,
+		identity: auth.connectedAgent
+	};
+}
+const INTERACTION_PART = "interaction.json";
+/**
+* Whether the agent has sent a plain answer in the lease's thread since
+* working started. Outbound signals and interactions (including this
+* worker's own renewals) are not answers. Unknown state reads as unanswered,
+* so the cap and local stops still bound renewal.
+*/
+async function defaultAnswered(context, lease, ownSignals) {
+	if (!lease.thread_id) return false;
+	const signal = AbortSignal.timeout(1e4);
+	const thread = await readThreadContext(context.apiClient.client, lease.thread_id, void 0, signal);
+	if (!thread) return false;
+	for (const message of thread.messages) {
+		if (message.direction !== "outbound" || ownSignals.has(message.id)) continue;
+		const at = Date.parse(message.timestamp ?? "");
+		if (!Number.isFinite(at) || at < lease.started_at - 5e3) continue;
+		const sent = await getSentEmail({
+			client: context.apiClient.client,
+			path: { id: message.id },
+			signal,
+			responseStyle: "fields"
+		});
+		const detail = sent.data?.data;
+		if (sent.error || !detail) continue;
+		if ((detail.attachments ?? []).some((part) => part.filename?.toLowerCase() === INTERACTION_PART)) {
+			ownSignals.add(message.id);
+			continue;
+		}
+		if (detail.to_address?.trim().toLowerCase() === lease.sender) return true;
+	}
+	return false;
+}
+/**
+* Detached worker entry. `read` sends one read signal; `working` holds the
+* per-email renewer lock and keeps working fresh until the agent answers, a
+* local reply or decline stops it, or the cap passes. Never throws.
+*/
+async function runAutoSignalWorker(env = process.env, deps = {}) {
+	const now = deps.now ?? Date.now;
+	const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const send = deps.send ?? sendSignal;
+	const answered = deps.answered ?? defaultAnswered;
+	try {
+		if (autoSignalsDisabled(env)) return;
+		const configDir = configDirectory(env);
+		const emailId = env["PRIMITIVE_AUTO_SIGNAL_EMAIL"] ?? "";
+		const kind = env[AUTO_SIGNAL_KIND_ENV];
+		const claim = readAutoClaim(configDir, emailId);
+		if (!claim || env.PRIMITIVE_AGENT_PROFILE !== claim.profile) return;
+		const context = await (deps.context ?? defaultContext)(configDir, claim.profile);
+		if (kind === "read") {
+			await send(context, {
+				id: claim.email_id,
+				kind: "read"
+			});
+			return;
+		}
+		if (kind !== "working") return;
+		const ownSignals = /* @__PURE__ */ new Set();
+		const renew = async () => {
+			for (;;) {
+				const lease = readWorkingLease(configDir, claim.email_id);
+				if (!lease || lease.stopped_at !== null) return;
+				for (const id of lease.signal_sent_ids) ownSignals.add(id);
+				recordRenewer(configDir, claim.email_id);
+				const elapsed = now() - lease.started_at;
+				if (elapsed >= 9e5) {
+					stopWorkingLease(configDir, claim.email_id, "cap", now);
+					return;
+				}
+				if (autoSignalsDisabled(env)) return;
+				let done = false;
+				try {
+					done = await answered(context, lease, ownSignals);
+				} catch {
+					done = false;
+				}
+				if (done) {
+					stopWorkingLease(configDir, claim.email_id, "answered", now);
+					return;
+				}
+				const active = () => {
+					const current = readWorkingLease(configDir, claim.email_id);
+					return Boolean(current && current.stopped_at === null);
+				};
+				const slot = Math.floor(elapsed / AUTO_WORKING_RENEW_MS);
+				markWorkingSending(configDir, claim.email_id);
+				let outcome;
+				let sentId = null;
+				try {
+					if (!active()) return;
+					const result = await send(context, {
+						id: claim.email_id,
+						kind: "working",
+						expiresIn: 55,
+						slot: `auto-working-${slot}`,
+						shouldSend: active
+					});
+					outcome = result.data.outcome;
+					sentId = typeof result.data.sent_id === "string" ? result.data.sent_id : null;
+				} catch {
+					outcome = "failed";
+				} finally {
+					clearWorkingSending(configDir, claim.email_id);
+				}
+				if (sentId) {
+					ownSignals.add(sentId);
+					const current = readWorkingLease(configDir, claim.email_id);
+					if (current && current.stopped_at === null && !current.signal_sent_ids.includes(sentId)) writeWorkingLease(configDir, {
+						...current,
+						signal_sent_ids: [...current.signal_sent_ids, sentId].slice(-200)
+					});
+				}
+				if (outcome === "not_sent") {
+					stopWorkingLease(configDir, claim.email_id, "not_sent", now);
+					return;
+				}
+				const next = lease.started_at + (slot + 1) * AUTO_WORKING_RENEW_MS;
+				while (now() < next) {
+					if (!active()) return;
+					await sleep(Math.min(1e3, next - now()));
+				}
+			}
+		};
+		for (let round = 0; round < 10; round++) {
+			let release;
+			try {
+				release = acquireListenLock(join(configDir, "auto-signals", claim.email_id), "auto-signal-working");
+			} catch {
+				return;
+			}
+			try {
+				await renew();
+			} finally {
+				release();
+			}
+			deps.released?.();
+			if (autoSignalsDisabled(env)) return;
+			const lease = readWorkingLease(configDir, claim.email_id);
+			if (!lease || lease.stopped_at !== null) return;
+			if (now() - lease.started_at >= 9e5) return;
+		}
+	} catch {}
+}
+//#endregion
+export { runAutoSignalWorker };

package/dist/oclif/auto-signals.js

@@ -0,0 +1,2 @@
+import { A as stopWorkingLease, C as releaseStopHold, D as resumeAutoWorking, E as restoreWorkingLease, O as spawnAutoSignalWorker, S as recordSentSignal, T as restoreAutoWorking, _ as isSentSignal, a as AUTO_WORKING_CAP_MS, b as readWorkingLease, c as activeWorkingLeases, d as autoSignalsDisabled, f as claimAutoRead, g as haltAutoWorking, h as dispatchAutoWorking, i as AUTO_SIGNAL_WORKER_ENV, j as writeWorkingLease, k as startWorkingLease, l as autoSignalEligible, m as dispatchAutoRead, n as AUTO_SIGNAL_EMAIL_ENV, o as AUTO_WORKING_EXPIRES_SECONDS, p as clearWorkingSending, r as AUTO_SIGNAL_KIND_ENV, s as AUTO_WORKING_RENEW_MS, t as AUTO_SIGNALS_OPT_OUT_ENV, u as autoSignalEntrypoint, v as markWorkingSending, w as renewerAlive, x as recordRenewer, y as readAutoClaim } from "../auto-signals-UPcJmV3j.js";
+export { AUTO_SIGNALS_OPT_OUT_ENV, AUTO_SIGNAL_EMAIL_ENV, AUTO_SIGNAL_KIND_ENV, AUTO_SIGNAL_WORKER_ENV, AUTO_WORKING_CAP_MS, AUTO_WORKING_EXPIRES_SECONDS, AUTO_WORKING_RENEW_MS, activeWorkingLeases, autoSignalEligible, autoSignalEntrypoint, autoSignalsDisabled, claimAutoRead, clearWorkingSending, dispatchAutoRead, dispatchAutoWorking, haltAutoWorking, isSentSignal, markWorkingSending, readAutoClaim, readWorkingLease, recordRenewer, recordSentSignal, releaseStopHold, renewerAlive, restoreAutoWorking, restoreWorkingLease, resumeAutoWorking, spawnAutoSignalWorker, startWorkingLease, stopWorkingLease, writeWorkingLease };