primcli 1.75.0 → 3.0.0-preview.10

package/dist/{machine-session-Cq_nD5eF.js → machine-session-CI8tnGzz.js}

@@ -1,18 +1,19 @@
-import { B as parseConnectedAgentProfile, F as agentProfileName, G as PrimitiveApiClient, H as profileAlreadyConnectedMessage, I as agentProfilesDirectory, L as connectedAgentIdentity, M as AGENT_PROFILE_ENV, N as AgentConnectionSetupError, P as agentProfileDirectory, R as connectedApiBaseUrl, V as parseOwnerMemberAddress, W as saveConnectedAgentProfile, x as loadCliCredentials, z as loadConnectedAgentProfile } from "./cli-config-B80p0pLk.js";
-import { $t as listDomains, At as getAgentContactPolicy, Dn as sendEmail, Ft as getEmail, Jt as listAgentContacts, Kn as __exportAll, Kt as inviteAgentConnection, Xt as listContacts, cn as listSentEmails, gn as putContact, hn as putAgentContactPolicy, jt as getContact, mn as putAgentContact, qt as listAgentConnections, vt as deleteAgentContact, wn as searchEmails, yt as deleteContact } from "./repeats-Dj_o6c-X-LyCkKYjp.js";
-import { Pt as refreshStoredCliCredentials, gt as defaultConnectionName, mt as cliInvocation, xt as detectAgentRuntime } from "./api-command-rlS3eTlZ.js";
+import { B as parseOwnerMemberAddress, F as agentProfilesDirectory, I as connectedAgentIdentity, L as connectedApiBaseUrl, M as AgentConnectionSetupError, N as agentProfileDirectory, P as agentProfileName, R as loadConnectedAgentProfile, U as saveConnectedAgentProfile, V as profileAlreadyConnectedMessage, W as PrimitiveApiClient, b as loadCliCredentials, j as AGENT_PROFILE_ENV, z as parseConnectedAgentProfile } from "./cli-config-Ms_0vNjq.js";
+import { Dn as listSentEmails, Fn as putContact, Gn as searchEmails, Ht as getEmail, Jn as sendEmail, Lt as getAgentContactPolicy, Nn as putAgentContact, Pn as putAgentContactPolicy, Rt as getContact, Tt as deleteContact, fn as listDomains, hr as __exportAll, ln as listContacts, on as listAgentConnections, rn as inviteAgentConnection, sn as listAgentContacts, wt as deleteAgentContact } from "./repeats-Dj_o6c-X-CDaE-kdZ.js";
+import { At as cliInvocation, Lt as detectAgentRuntime, Mt as defaultConnectionName, nn as refreshStoredCliCredentials, rn as refuseOrgSelectionForProfile } from "./api-command-D0KHkqhA.js";
 import { _ as acquireListenLock, b as listenLockHeld, c as mailTime, d as readMailJson, f as removeMailFile, g as ListenStateError, h as writeMailJson, i as mailId, l as privateMailDirectory, o as mailObject, p as syncMailDirectory, r as mailAddress, s as mailString } from "./shared-mail-files-BAQSGxxz.js";
-import { _ as installConnectSkill, a as NotificationRetryError, b as readBundledConnectSkill, d as defaultSessionSocket, f as NativeSessionDisconnectedError, l as SESSION_UUID, t as notificationScope, u as connectNativeSession } from "./notify-session-CbY4FYUt.js";
-import { l as stopBackgroundListen, r as backgroundListenStatus } from "./listen-background-C0F9gNDD.js";
+import { S as readBundledConnectSkill, a as NotificationRetryError, d as SESSION_UUID, f as connectNativeSession, m as NativeSessionDisconnectedError, p as defaultSessionSocket, t as notificationScope, y as installConnectSkill } from "./notify-session-DN8tSfAi.js";
+import { a as backgroundListenStatus, d as stopBackgroundListen } from "./listen-background-DyBYca28.js";
 import { t as readSharedMailOwner } from "./shared-mail-watch-BAPMsFNv.js";
-import { o as scopedChatSenderTrust } from "./scoped-chat-B0thCwME.js";
+import { withoutOrgSelection } from "./oclif/global-org-flag.js";
+import { o as scopedChatSenderTrust } from "./scoped-chat-C4TDfZND.js";
 import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { execFile, execFileSync, spawn } from "node:child_process";
-import { homedir } from "node:os";
 import { promisify } from "node:util";
+import { homedir } from "node:os";
 import { createConnection } from "node:net";
 // src/oclif/owner-member-address.ts
 const REFRESH_TIMEOUT_MS = 5e3;
@@ -3009,6 +3010,7 @@ async function revoke(profile, fetcher) {
 /** Revoke one selected connected credential; never alter OAuth login or mail evidence. */
 async function disconnectAgent(params) {
 	const profileName = agentProfileName(params.profileName);
+	refuseOrgSelectionForProfile(profileName);
 	if (!loadConnectedAgentProfile(params.configDir, profileName)) throw new AgentDisconnectError("This agent profile is not configured. Nothing was changed.");
 	const directory = agentProfileDirectory(params.configDir, profileName);
 	let releaseSetup;
@@ -3448,6 +3450,11 @@ var ContactPolicyReadRetryError = class extends NotificationRetryError {
 		super("Contact notification policy is temporarily unavailable. Mail remains pending while permissions are refreshed.");
 	}
 };
+/** A network decision is trusted only when every field agrees with the others. */
+function consistentNetworkAdmission(decision) {
+	const relation = decision.sender_relation;
+	return typeof decision.allowed === "boolean" && typeof decision.pending === "boolean" && typeof decision.member_policy_required === "boolean" && (relation === void 0 || decision.member_policy_required && (relation === "owner" || relation === "member")) && !(decision.member_policy_required && decision.allowed && !relation) && !(decision.pending && (decision.allowed || decision.allowed_since !== null)) && (decision.allowed ? typeof decision.allowed_since === "string" : decision.allowed_since === null);
+}
 const unavailable = () => new ListenStateError("Contact notification preferences are unavailable or invalid. No contact notification was submitted; restart after access is restored.");
 const changed = () => new NotificationRetryError("Contact notification permission changed or expired before dispatch.");
 /** Read one connected address's policy. Partial pages never authorize delivery. */
@@ -3561,10 +3568,8 @@ function createNotificationContactPolicy(options) {
 		if (!emailId) throw unavailable();
 		const network = await networkReader(emailId, sender, signal);
 		signal.throwIfAborted();
-		if (typeof network.member_policy_required !== "boolean") throw unavailable();
-		if (network.sender_relation !== void 0 && (!network.member_policy_required || !["owner", "member"].includes(network.sender_relation))) throw unavailable();
+		if (!consistentNetworkAdmission(network)) throw unavailable();
 		if (network.member_policy_required) {
-			if (network.allowed && !network.sender_relation) throw unavailable();
 			if (network.pending) throw new NetworkAdmissionPendingError();
 			if (!network.allowed) return null;
 			if (decision.kind === "silent" && decision.source !== "default") return null;
@@ -4192,11 +4197,11 @@ function defaults$1() {
 				"--contacts",
 				...contactRequests ? ["--contact-requests"] : []
 			], {
-				env: {
+				env: withoutOrgSelection({
 					...process.env,
 					[AGENT_PROFILE_ENV]: profile,
 					PRIMITIVE_CONFIG_DIR: configDir
-				},
+				}),
 				timeout: 35e3,
 				maxBuffer: 65536
 			});
@@ -5058,11 +5063,18 @@ function assertNativeSessionIdentity(session, env) {
 	if (env.CODEX_THREAD_ID && env.CODEX_THREAD_ID !== session) throw refuse("The requested session differs from this Codex thread. No address was created.");
 	if (!env.CODEX_THREAD_ID && env.CODEX_SESSION_ID && env.CODEX_SESSION_ID !== session) throw refuse("The requested session differs from this Codex session. No address was created.");
 }
+/**
+* Preflight for enrollment: the managed domains an address could land on.
+* Null when the member's grant may not list domains; creating a connection
+* needs only agent_connections:manage, and the server picks the address and
+* refuses with connection_domain_unavailable when none is usable.
+*/
 async function managedDomains(client, apiBaseUrl) {
 	const response = await listDomains({
 		client: client.client,
 		responseStyle: "fields"
 	});
+	if (response.response?.status === 403) return null;
 	const rows = response.data?.data;
 	if (response.error || !Array.isArray(rows)) throw refuse("Could not list the owner's managed domains. No address was created.");
 	const suffix = apiBaseUrl === "https://api.primitive-staging-1.com/v1" ? ".primitive-staging.email" : ".primitive.email";
@@ -5579,11 +5591,12 @@ async function enrollAgent(params) {
 		if (state?.continueAttempted) throw refuse(stuckEnrollmentStep(resolvedEnrollment(state).address));
 		if (!state) {
 			if (params.continueSetup) throw refuse("There is no saved enrollment to continue. Start enrollment normally first.");
-			if (!(await managedDomains(new PrimitiveApiClient({
+			const domains = await managedDomains(new PrimitiveApiClient({
 				apiKey: credentials.access_token,
 				apiBaseUrl,
 				fetch: params.fetch
-			}), apiBaseUrl)).length) throw refuse("No managed domain is available for enrollment.");
+			}), apiBaseUrl);
+			if (domains && !domains.length) throw refuse("No managed domain is available for enrollment.");
 			state = {
 				version: 2,
 				session: params.session,

package/dist/{notify-session-CbY4FYUt.js → notify-session-DN8tSfAi.js}

@@ -1,13 +1,17 @@
-import { Et as downloadEmailAttachmentPart, J as parseWebhookEvent, K as isEmailReceivedEvent, c as classifySignalContent, q as isTrustedSender } from "./repeats-Dj_o6c-X-LyCkKYjp.js";
-import { B as wakeInteractionSentence, T as wakeReadCommand, w as skillFirstLine } from "./api-command-rlS3eTlZ.js";
+import { Mt as downloadEmailAttachmentPart, Q as parseWebhookEvent, X as isEmailReceivedEvent, Z as isTrustedSender, c as classifySignalContent } from "./repeats-Dj_o6c-X-CDaE-kdZ.js";
+import { B as skillFirstLine, V as wakeReadCommand, nt as wakeInteractionSentence } from "./api-command-D0KHkqhA.js";
 import { _ as acquireListenLock, g as ListenStateError, y as listenIdentity } from "./shared-mail-files-BAQSGxxz.js";
 import { closeSync, copyFileSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, opendirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID, scryptSync } from "node:crypto";
 import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { isDeepStrictEqual } from "node:util";
 import { homedir } from "node:os";
 import { lstat, realpath } from "node:fs/promises";
-import { isDeepStrictEqual } from "node:util";
 import WebSocket from "ws";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
+import { performance } from "node:perf_hooks";
 // src/oclif/connect-skill.ts
 const CONNECT_SKILL_NAME = "primitive-connect";
 function connectSkillTarget(options) {
@@ -564,6 +568,331 @@ async function connectNativeSession(options) {
 		}
 	};
 }
+// src/oclif/listen-handlers.ts
+const HANDLER_TIMEOUT_MS = 3e4;
+const MAX_RESPONSE_BYTES = 1048576;
+const FORWARDED_HEADERS = /* @__PURE__ */ new Set([
+	"content-type",
+	"user-agent",
+	"primitive-signature",
+	"mymx-signature",
+	"x-webhook-event",
+	"x-webhook-id",
+	"x-primitive-webhook-delivery-id",
+	"x-primitive-email-id",
+	"x-primitive-endpoint-id"
+]);
+function normalizeForwardTarget(target) {
+	if (/^\d+$/.test(target)) return `http://localhost:${target}`;
+	if (/^(localhost|127\.0\.0\.1|\[::1\])(?::|\/|$)/.test(target)) return `http://${target}`;
+	return target;
+}
+function validateListenHandlerOptions(options) {
+	if (options.exec !== void 0 && process.platform === "win32") throw new Error("--exec requires a POSIX shell and process groups. On Windows, use --forward-to with a local HTTP handler.");
+	if (options.exec !== void 0 && options.forwardTo !== void 0) throw new Error("Choose either --exec or --forward-to.");
+	if (options.exec !== void 0 && (!options.exec.trim() || options.exec.includes("\0"))) throw new Error("--exec requires a nonempty shell command.");
+	if (options.forwardTo !== void 0) {
+		let url;
+		try {
+			url = new URL(normalizeForwardTarget(options.forwardTo));
+		} catch {
+			throw new Error("--forward-to requires an HTTP or HTTPS URL.");
+		}
+		if (!["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password || url.hash) throw new Error("--forward-to requires HTTP or HTTPS without userinfo or a fragment.");
+	}
+}
+/** User hooks retain their configuration, but not the CLI's API credentials. */
+function hookEnvironment(delivery) {
+	const env = { ...process.env };
+	for (const name of Object.keys(env)) if (/^PRIMITIVE_(?:(?:API_|OAUTH_|AUTH_)?(?:KEY|TOKEN|ACCESS_TOKEN|REFRESH_TOKEN)|API_HEADERS|LEASE_TOKEN)$/i.test(name)) delete env[name];
+	return {
+		...env,
+		PRIMITIVE_EVENT_ID: delivery.event_id,
+		PRIMITIVE_DELIVERY_ID: delivery.delivery_id,
+		PRIMITIVE_EVENT_TYPE: delivery.event_type
+	};
+}
+async function writeChunk(output, chunk, signal) {
+	signal.throwIfAborted();
+	let onError = () => {};
+	let onAbort = () => {};
+	let onDrain = () => {};
+	let onClose = () => {};
+	try {
+		await new Promise((resolve, reject) => {
+			let callbackDone = false;
+			let returned = false;
+			let accepted = false;
+			let drained = false;
+			const finish = () => {
+				if (returned && callbackDone && (accepted || drained)) resolve();
+			};
+			onError = reject;
+			onAbort = () => reject(signal.reason);
+			onClose = () => reject(/* @__PURE__ */ new Error("Output closed before accepting the event."));
+			onDrain = () => {
+				drained = true;
+				finish();
+			};
+			output.on("error", onError);
+			output.on("close", onClose);
+			output.on("drain", onDrain);
+			signal.addEventListener("abort", onAbort, { once: true });
+			accepted = output.write(chunk, (error) => {
+				if (error) reject(error);
+				else {
+					callbackDone = true;
+					finish();
+				}
+			});
+			returned = true;
+			finish();
+		});
+	} finally {
+		output.off("error", onError);
+		output.off("close", onClose);
+		output.off("drain", onDrain);
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function stopProcessGroup(child) {
+	if (!child.pid) return;
+	try {
+		process.kill(-child.pid, "SIGKILL");
+	} catch {}
+}
+var ChildCleanupError = class extends Error {};
+async function reapChild(child, closed) {
+	stopProcessGroup(child);
+	child.stdin?.destroy();
+	child.stdout?.destroy();
+	child.stderr?.destroy();
+	let timer;
+	try {
+		await Promise.race([closed, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(new ChildCleanupError("The hook did not close after termination. Its delivery remains uncompleted.")), 1e3);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function execute(command, delivery, stderr, signal) {
+	signal.throwIfAborted();
+	const child = spawn(command, {
+		shell: true,
+		detached: true,
+		env: hookEnvironment(delivery),
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	const closed = new Promise((resolve) => child.once("close", () => resolve()));
+	const stop = () => stopProcessGroup(child);
+	signal.addEventListener("abort", stop, { once: true });
+	const consume = async (stream) => {
+		for await (const chunk of stream) await writeChunk(stderr, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk), signal);
+	};
+	child.once("exit", stop);
+	try {
+		const exited = new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("close", (code) => resolve(code));
+		});
+		const stdin = writeChunk(child.stdin, Buffer.from(delivery.body, "utf8"), signal).then(() => child.stdin.end());
+		const [code] = await Promise.all([
+			exited,
+			stdin,
+			consume(child.stdout),
+			consume(child.stderr)
+		]);
+		signal.throwIfAborted();
+		return code;
+	} finally {
+		try {
+			await reapChild(child, closed);
+		} finally {
+			signal.removeEventListener("abort", stop);
+		}
+	}
+}
+function structuredErrorCode(body) {
+	try {
+		const value = JSON.parse(body);
+		if (typeof value !== "object" || value === null) return void 0;
+		const object = value;
+		const nested = typeof object.error === "object" && object.error !== null ? object.error.code : void 0;
+		const code = typeof nested === "string" ? nested : object.code;
+		return typeof code === "string" && /^[a-z][a-z0-9_]{0,63}$/.test(code) ? code : void 0;
+	} catch {
+		return;
+	}
+}
+var ForwardFailure = class extends Error {
+	statusCode;
+	transportError;
+	constructor(statusCode, transportError) {
+		super("Webhook transport did not complete.");
+		this.statusCode = statusCode;
+		this.transportError = transportError;
+	}
+};
+async function forward(target, delivery, signal) {
+	signal.throwIfAborted();
+	const url = new URL(normalizeForwardTarget(target));
+	const body = Buffer.from(delivery.body, "utf8");
+	const headers = {};
+	for (const [name, value] of Object.entries(delivery.headers)) if (FORWARDED_HEADERS.has(name.toLowerCase())) headers[name.toLowerCase()] = value;
+	headers["content-length"] = String(body.length);
+	return new Promise((resolve, reject) => {
+		let observedStatus = null;
+		let settled = false;
+		const fail = (kind = observedStatus === null ? "network" : "io") => {
+			if (settled) return;
+			settled = true;
+			reject(new ForwardFailure(observedStatus, kind));
+		};
+		const request$2 = (url.protocol === "https:" ? request$1 : request)(url, {
+			method: "POST",
+			headers,
+			signal,
+			rejectUnauthorized: true
+		}, (response) => {
+			observedStatus = response.statusCode ?? null;
+			const chunks = [];
+			let size = 0;
+			response.on("error", () => fail());
+			response.on("aborted", () => fail());
+			response.on("data", (chunk) => {
+				size += chunk.length;
+				if (size > MAX_RESPONSE_BYTES) {
+					fail("response_too_large");
+					request$2.destroy();
+				} else chunks.push(chunk);
+			});
+			response.on("end", () => {
+				if (settled) return;
+				if (!response.complete || size > MAX_RESPONSE_BYTES) {
+					fail(size > MAX_RESPONSE_BYTES ? "response_too_large" : "io");
+					return;
+				}
+				settled = true;
+				const status = response.statusCode ?? 0;
+				const succeeded = status >= 200 && status < 300;
+				resolve({
+					status,
+					confirmed: succeeded && (response.headers["x-primitive-confirmed"] === "true" || response.headers["x-mymx-confirmed"] === "true"),
+					errorCode: succeeded ? void 0 : status >= 300 && status < 400 ? "handler_redirect" : structuredErrorCode(Buffer.concat(chunks).toString("utf8")) ?? (status >= 400 && status < 500 ? "handler_4xx" : status >= 500 ? "handler_5xx" : "unknown_error")
+				});
+			});
+		});
+		request$2.on("error", () => fail());
+		request$2.end(body);
+	});
+}
+function jsonLine(body) {
+	try {
+		return JSON.stringify(JSON.parse(body));
+	} catch {
+		throw new Error("Webhook body is not valid JSON.");
+	}
+}
+/**
+* The API withholds an event's body from a credential that cannot read the
+* mail it carries. Such an event is never handed on as if it were the event:
+* listening stops with an explanation and the delivery stays uncompleted.
+*/
+function readableDelivery(delivery) {
+	if (delivery.body === null) throw new ListenStateError("The API withheld this event's content from the listening credential; the delivery remains uncompleted. Listen with a credential that can read this mail.");
+	return {
+		...delivery,
+		body: delivery.body
+	};
+}
+function createListenHandler(options = {}) {
+	validateListenHandlerOptions(options);
+	return async (received, signal) => {
+		signal.throwIfAborted();
+		const delivery = readableDelivery(received);
+		const start = performance.now();
+		const work = new AbortController();
+		let timedOut = false;
+		const cancel = () => work.abort(signal.reason);
+		signal.addEventListener("abort", cancel, { once: true });
+		const timer = setTimeout(() => {
+			timedOut = true;
+			work.abort(/* @__PURE__ */ new Error("Event handler timed out."));
+		}, HANDLER_TIMEOUT_MS);
+		const duration = () => Math.min(HANDLER_TIMEOUT_MS, Math.max(0, Math.round(performance.now() - start)));
+		try {
+			if (options.exec !== void 0) {
+				const code = await execute(options.exec, delivery, options.stderr ?? process.stderr, work.signal);
+				signal.throwIfAborted();
+				return {
+					succeeded: code === 0,
+					outcome: {
+						mode: "exec",
+						exit_code: code,
+						duration_ms: duration()
+					}
+				};
+			}
+			if (options.forwardTo !== void 0) {
+				const response = await forward(options.forwardTo, delivery, work.signal);
+				signal.throwIfAborted();
+				return {
+					succeeded: response.status >= 200 && response.status < 300,
+					outcome: {
+						mode: "http",
+						status_code: response.status,
+						confirmed: response.confirmed,
+						duration_ms: duration(),
+						...response.errorCode ? { error_code: response.errorCode } : {}
+					}
+				};
+			}
+			await writeChunk(options.stdout ?? process.stdout, Buffer.from(`${jsonLine(delivery.body)}\n`, "utf8"), work.signal);
+			signal.throwIfAborted();
+			return {
+				succeeded: true,
+				outcome: {
+					mode: "stdout",
+					write_succeeded: true,
+					duration_ms: duration()
+				}
+			};
+		} catch (error) {
+			signal.throwIfAborted();
+			if (error instanceof ChildCleanupError) throw error;
+			if (options.exec !== void 0) return {
+				succeeded: false,
+				outcome: {
+					mode: "exec",
+					exit_code: null,
+					transport_error: timedOut ? "timeout" : "io",
+					duration_ms: duration()
+				}
+			};
+			if (options.forwardTo !== void 0) return {
+				succeeded: false,
+				outcome: {
+					mode: "http",
+					status_code: error instanceof ForwardFailure ? error.statusCode : null,
+					confirmed: false,
+					transport_error: timedOut ? "timeout" : error instanceof ForwardFailure ? error.transportError : "network",
+					duration_ms: duration()
+				}
+			};
+			throw error;
+		} finally {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", cancel);
+			work.abort();
+		}
+	};
+}
 // src/oclif/notify-session-content.ts
 var NotificationRetryError = class extends ListenStateError {};
 function notificationPartReader(client) {
@@ -951,9 +1280,10 @@ async function openSessionNotifications(options) {
 			}
 		});
 		if (delivery.event_type !== "email.received") throw new ListenStateError("Notification mode received an unrelated event. It remains uncompleted; use an email.received-only subscription.");
+		const { body } = readableDelivery(delivery);
 		let event;
 		try {
-			event = parseWebhookEvent(JSON.parse(delivery.body), delivery.event_type);
+			event = parseWebhookEvent(JSON.parse(body), delivery.event_type);
 		} catch {
 			throw new ListenStateError("Invalid email event; the delivery remains uncompleted.");
 		}
@@ -1114,4 +1444,4 @@ async function openSessionNotifications(options) {
 }
 var ContactNoticeSuppressed = class extends Error {};
 var ContactNoticeDeferred = class extends Error {};
-export { installConnectSkill as _, NotificationRetryError as a, readBundledConnectSkill as b, readConversationStatusContent as c, defaultSessionSocket as d, NativeSessionDisconnectedError as f, connectSkillTarget as g, NotificationOutcomeUnknownError as h, notificationReceiptPage as i, SESSION_UUID as l, NativeSessionNotLoadedError as m, notificationSenders as n, isRoutineNotificationContent as o, NativeSessionError as p, openSessionNotifications as r, notificationPartReader as s, notificationScope as t, connectNativeSession as u, installedConnectSkillFile as v, installedVersion as y };
+export { readBundledConnectSkill as S, NotificationOutcomeUnknownError as _, NotificationRetryError as a, installedConnectSkillFile as b, readConversationStatusContent as c, SESSION_UUID as d, connectNativeSession as f, NativeSessionNotLoadedError as g, NativeSessionError as h, notificationReceiptPage as i, createListenHandler as l, NativeSessionDisconnectedError as m, notificationSenders as n, isRoutineNotificationContent as o, defaultSessionSocket as p, openSessionNotifications as r, notificationPartReader as s, notificationScope as t, readableDelivery as u, connectSkillTarget as v, installedVersion as x, installConnectSkill as y };

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

@@ -1,8 +1,8 @@
-import { Ut as getSentEmail } from "../repeats-Dj_o6c-X-LyCkKYjp.js";
-import { Mt as createAuthenticatedCliApiClient, b as readThreadContext } from "../api-command-rlS3eTlZ.js";
+import { en as getSentEmail } from "../repeats-Dj_o6c-X-CDaE-kdZ.js";
+import { I as readThreadContext, en as createAuthenticatedCliApiClient } from "../api-command-D0KHkqhA.js";
 import { AUTO_SIGNAL_KIND_ENV, AUTO_WORKING_RENEW_MS, autoSignalsDisabled, clearWorkingSending, markWorkingSending, readAutoClaim, readWorkingLease, recordRenewer, stopWorkingLease, writeWorkingLease } from "./auto-signals.js";
 import { _ as acquireListenLock } from "../shared-mail-files-BAQSGxxz.js";
-import { t as sendSignal } from "../signal-command-DCPsJBdz.js";
+import { t as sendSignal } from "../signal-command-f5QeK45s.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 // src/oclif/auto-signal-worker.ts

package/dist/oclif/auto-signals.js

@@ -1,4 +1,4 @@
-import { n as isPlainChatReply, o as scopedChatSenderTrust } from "../scoped-chat-B0thCwME.js";
+import { n as isPlainChatReply, o as scopedChatSenderTrust } from "../scoped-chat-C4TDfZND.js";
 import { d as readMailJson, h as writeMailJson, i as mailId, l as privateMailDirectory, r as mailAddress } from "../shared-mail-files-BAQSGxxz.js";
 import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
@@ -63,7 +63,7 @@ function autoSignalEligible(detail, identity, admission) {
 		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;
+		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;

package/dist/oclif/command-not-found.js

@@ -0,0 +1,62 @@
+import { r as jsonOutputRequested } from "../json-output-ch756TXV.js";
+// src/oclif/command-not-found.ts
+/**
+* What to say for an id no command has. oclif joins every word before the
+* first flag into the id while no command along the way takes arguments, so
+* `emails list foo` arrives as `emails:list:foo`: when a leading part is a
+* real command, the rest was an argument it does not take.
+*/
+function commandNotFoundMessage(id, lookup) {
+	const parts = id.split(":");
+	const typed = `primitive ${parts.join(" ")}`;
+	for (let end = parts.length - 1; end > 0; end -= 1) {
+		const known = parts.slice(0, end).join(":");
+		const command = lookup.find(known);
+		const topic = lookup.hasSubcommands(known);
+		if (!command && !topic) continue;
+		const shown = `primitive ${parts.slice(0, end).join(" ")}`;
+		const rest = parts.slice(end).join(" ");
+		if (topic || !command) return {
+			code: "command_not_found",
+			message: `Unknown command "${typed}". Run "${shown} --help" to see the commands under it.`
+		};
+		if (command.takesArguments) return {
+			code: "command_not_found",
+			message: `Unknown command "${parts.join(":")}". To pass "${rest}" to "${shown}", run "${shown} ${rest}".`
+		};
+		return {
+			code: "unexpected_argument",
+			message: `Unexpected argument "${rest}" for "${shown}", which takes no arguments. Run "${shown} --help" to see the flags it takes.`
+		};
+	}
+	return {
+		code: "command_not_found",
+		message: `Unknown command "${typed}". Run "primitive --help" to see the commands.`
+	};
+}
+/**
+* Say what went wrong in plain words, and under --json as one JSON document
+* on stdout like every other failure, instead of oclif's "command <id> not
+* found" naming a command nobody typed.
+*/
+const hook = async (options) => {
+	const { config } = options;
+	const { code, message } = commandNotFoundMessage(options.id, {
+		find: (id) => {
+			const command = config.findCommand(id);
+			return command ? { takesArguments: Object.keys(command.args ?? {}).length > 0 } : void 0;
+		},
+		hasSubcommands: (id) => config.commandIDs.some((other) => other.startsWith(`${id}:`))
+	});
+	if (jsonOutputRequested([...process.argv.slice(2), ...options.argv ?? []])) process.stdout.write(`${JSON.stringify({
+		error: {
+			code,
+			message
+		},
+		exit_code: 2
+	}, null, 2)}\n`);
+	else process.stderr.write(` ›   Error: ${message}\n`);
+	process.exitCode = 2;
+	return message;
+};
+export { commandNotFoundMessage, hook as default };

package/dist/oclif/global-org-flag.js

@@ -0,0 +1,76 @@
+// src/oclif/global-org-flag.ts
+/**
+* The global `--org <org>` flag. bin/run.js takes it out of argv before oclif
+* parses the command, so every command accepts it, and passes it on as
+* PRIMITIVE_CLI_ORG. Only a saved `primitive login` made as yourself can switch
+* organizations; every other credential refuses a different organization.
+*
+* No oclif import here: this runs before oclif loads.
+*/
+/** Selects the organization for one command. */
+const ORG_SELECTION_ENV = "PRIMITIVE_CLI_ORG";
+/** Split `--org <value>` and `--org=<value>` out of argv, before any `--`. */
+function extractGlobalOrgFlag(argv) {
+	const separator = argv.indexOf("--");
+	const head = separator === -1 ? [...argv] : argv.slice(0, separator);
+	const tail = separator === -1 ? [] : argv.slice(separator);
+	const command = head[0] ?? "";
+	if (command === "memories" || command.startsWith("memories:")) return {
+		ok: true,
+		argv: [...argv],
+		org: null
+	};
+	const kept = [];
+	let org = null;
+	for (let index = 0; index < head.length; index += 1) {
+		const arg = head[index];
+		if (arg === "--org") {
+			const value = head[index + 1];
+			if (value === void 0 || value.startsWith("-") || !value.trim()) return {
+				ok: false,
+				message: "--org needs an organization id or name, for example `--org acme`."
+			};
+			org = value.trim();
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--org=")) {
+			const value = arg.slice(6).trim();
+			if (!value) return {
+				ok: false,
+				message: "--org needs an organization id or name, for example `--org=acme`."
+			};
+			org = value;
+			continue;
+		}
+		kept.push(arg);
+	}
+	return {
+		ok: true,
+		argv: [...kept, ...tail],
+		org
+	};
+}
+/**
+* Apply the flag to this process: strip it from `process.argv` and set
+* PRIMITIVE_CLI_ORG. Returns an error message for a malformed flag.
+*/
+function applyGlobalOrgFlag(processArgv = process.argv, env = process.env) {
+	const parsed = extractGlobalOrgFlag(processArgv.slice(2));
+	if (!parsed.ok) return parsed.message;
+	if (parsed.org !== null) {
+		processArgv.splice(2, processArgv.length - 2, ...parsed.argv);
+		env[ORG_SELECTION_ENV] = parsed.org;
+	}
+	return null;
+}
+/**
+* `env` without an organization selection, for a child that acts as a
+* connected agent profile: the profile acts in its own organization.
+*/
+function withoutOrgSelection(env) {
+	const next = { ...env };
+	delete next[ORG_SELECTION_ENV];
+	return next;
+}
+export { ORG_SELECTION_ENV, applyGlobalOrgFlag, extractGlobalOrgFlag, withoutOrgSelection };