@bremmdev/arca-env 0.0.0-stage → 0.1.1

package/dist/main-Cy_OrS0c.mjs

@@ -0,0 +1,2783 @@
+import { n as createMaskedWriter, r as needlesFor, t as Redactor } from "./redact-D4Txfinc.mjs";
+import { parseArgs } from "node:util";
+import { appendFileSync, chmodSync, closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { constants, homedir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { createCipheriv, createDecipheriv, createHash, hkdfSync, randomBytes, randomInt, scryptSync } from "node:crypto";
+import { execFileSync } from "node:child_process";
+//#region src/io.ts
+function stream(s) {
+	return {
+		write: (chunk) => {
+			s.write(chunk);
+		},
+		get isTTY() {
+			return Boolean(s.isTTY);
+		},
+		get columns() {
+			return s.columns;
+		},
+		get rows() {
+			return s.rows;
+		},
+		get colorDepth() {
+			return s.isTTY && typeof s.getColorDepth === "function" ? s.getColorDepth() : void 0;
+		}
+	};
+}
+function processIO() {
+	return {
+		env: process.env,
+		cwd: process.cwd(),
+		platform: process.platform,
+		stdout: stream(process.stdout),
+		stderr: stream(process.stderr),
+		stdinIsTTY: Boolean(process.stdin.isTTY),
+		readStdin: async () => {
+			const chunks = [];
+			for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+			return Buffer.concat(chunks).toString("utf8");
+		},
+		prompts: clackPrompts(),
+		childStdin: "inherit",
+		handleSignals: true
+	};
+}
+function clackPrompts() {
+	const load = () => import("@clack/prompts");
+	const output = process.stderr;
+	return {
+		async password(message) {
+			const p = await load();
+			const r = await p.password({
+				message,
+				output
+			});
+			return p.isCancel(r) ? null : r;
+		},
+		async text(message, opts = {}) {
+			const p = await load();
+			const r = await p.text({
+				message,
+				output,
+				placeholder: opts.placeholder,
+				initialValue: opts.initial
+			});
+			return p.isCancel(r) ? null : r;
+		},
+		async confirm(message, initial = true) {
+			const p = await load();
+			const r = await p.confirm({
+				message,
+				output,
+				initialValue: initial
+			});
+			return p.isCancel(r) ? null : r;
+		},
+		async multiselect(message, options, initial) {
+			const p = await load();
+			const r = await p.multiselect({
+				message,
+				output,
+				options,
+				initialValues: initial,
+				required: false
+			});
+			return p.isCancel(r) ? null : r;
+		}
+	};
+}
+//#endregion
+//#region src/context.ts
+/**
+* Env vars that agent tools set in the commands they run. Order matters: the first hit names
+* the agent. Only markers specific to agent-launched processes belong here, not ones an IDE
+* sets in every terminal (those would lock humans out). To verify per tool in spike S3.
+*/
+const AGENT_MARKERS = [
+	{
+		env: "ARCA_AGENT",
+		name: "agent"
+	},
+	{
+		env: "AI_AGENT",
+		name: "agent"
+	},
+	{
+		env: "CLAUDECODE",
+		name: "claude-code"
+	},
+	{
+		env: "CLAUDE_CODE_ENTRYPOINT",
+		name: "claude-code"
+	},
+	{
+		env: "CURSOR_AGENT",
+		name: "cursor"
+	},
+	{
+		env: "CODEX_SANDBOX",
+		name: "codex"
+	},
+	{
+		env: "CODEX_THREAD_ID",
+		name: "codex"
+	},
+	{
+		env: "GEMINI_CLI",
+		name: "gemini-cli"
+	},
+	{
+		env: "OPENCODE",
+		name: "opencode"
+	},
+	{
+		env: "AUGMENT_AGENT",
+		name: "augment"
+	},
+	{
+		env: "CLINE_ACTIVE",
+		name: "cline"
+	},
+	{
+		env: "GOOSE_TERMINAL",
+		name: "goose"
+	},
+	{
+		env: "REPL_ID",
+		name: "replit"
+	}
+];
+const FALSY = /* @__PURE__ */ new Set([
+	"",
+	"0",
+	"false",
+	"no",
+	"off"
+]);
+function detectAgent(env, extraMarkers = []) {
+	const markers = [...AGENT_MARKERS, ...extraMarkers.map((e) => ({
+		env: e,
+		name: "agent"
+	}))];
+	for (const m of markers) {
+		const v = env[m.env];
+		if (v === void 0 || FALSY.has(v.trim().toLowerCase())) continue;
+		let name = m.name;
+		if ((m.env === "AI_AGENT" || m.env === "ARCA_AGENT") && v !== "1" && v.toLowerCase() !== "true") name = v.split(/[_\s]/)[0] || m.name;
+		return {
+			detected: true,
+			name,
+			via: m.env
+		};
+	}
+	return { detected: false };
+}
+const CI_VARS = [
+	"CI",
+	"CONTINUOUS_INTEGRATION",
+	"BUILD_NUMBER",
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"VERCEL",
+	"NETLIFY",
+	"BUILDKITE",
+	"CIRCLECI",
+	"TF_BUILD",
+	"CODEBUILD_BUILD_ID",
+	"BITBUCKET_BUILD_NUMBER",
+	"CF_PAGES",
+	"RENDER",
+	"RAILWAY_ENVIRONMENT"
+];
+function detectCI(env) {
+	return CI_VARS.some((k) => env[k] !== void 0 && !FALSY.has(env[k].trim().toLowerCase()));
+}
+function buildContext(io, extraMarkers = []) {
+	return {
+		agent: detectAgent(io.env, extraMarkers),
+		interactiveOutput: io.stdout.isTTY && io.stderr.isTTY,
+		stdinIsTTY: io.stdinIsTTY,
+		ci: detectCI(io.env),
+		activeProject: io.env.ARCA_ACTIVE || null
+	};
+}
+/**
+* Checks that this `arca run` was started by a package.json script: the package manager's
+* lifecycle vars must match the script in package.json, the script must contain `arca run`,
+* and the command arca was asked to run must be the one written in the script (extra
+* arguments appended by `npm run x -- …` are allowed).
+*/
+function verifyScript(io, command) {
+	const name = io.env.npm_lifecycle_event;
+	const script = io.env.npm_lifecycle_script;
+	if (!name || script === void 0) return { kind: "adhoc" };
+	const pkgPath = findPackageJson(io);
+	if (!pkgPath) return {
+		kind: "script",
+		name,
+		verified: false,
+		reason: "no package.json found"
+	};
+	let scripts = {};
+	try {
+		scripts = JSON.parse(readFileSync(pkgPath, "utf8")).scripts ?? {};
+	} catch {
+		return {
+			kind: "script",
+			name,
+			verified: false,
+			reason: "package.json is not valid JSON"
+		};
+	}
+	if (!Object.hasOwn(scripts, name)) return { kind: "adhoc" };
+	if (scripts[name] !== script) return {
+		kind: "script",
+		name,
+		verified: false,
+		reason: `the "${name}" script in package.json doesn't match what the package manager ran`
+	};
+	const declared = arcaRunCommands(script);
+	if (declared.length === 0) return {
+		kind: "script",
+		name,
+		verified: false,
+		reason: `the "${name}" script doesn't use \`arca run\``
+	};
+	if (!declared.some((cmd) => cmd.length > 0 && cmd.length <= command.length && cmd.every((t, i) => sameToken(t, command[i])))) return {
+		kind: "script",
+		name,
+		verified: false,
+		reason: `the command doesn't match the "${name}" script`
+	};
+	return {
+		kind: "script",
+		name,
+		verified: true
+	};
+}
+function sameToken(a, b) {
+	return a === b;
+}
+function findPackageJson(io) {
+	const fromEnv = io.env.npm_package_json;
+	if (fromEnv && existsSync(fromEnv)) return fromEnv;
+	let dir = resolve(io.cwd);
+	for (;;) {
+		const p = join(dir, "package.json");
+		if (existsSync(p)) return p;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/** The commands after `arca run [opts] --` in a script, one per `arca run` occurrence. */
+function arcaRunCommands(script) {
+	const out = [];
+	for (const segment of splitShell(script)) {
+		const tokens = tokenize(segment);
+		for (let i = 0; i < tokens.length - 1; i++) {
+			if (!(/(^|[\\/])arca(\.cmd|\.js|\.mjs)?$/.test(tokens[i]) && tokens[i + 1] === "run")) continue;
+			out.push(commandAfterRunOptions(tokens.slice(i + 2)));
+		}
+	}
+	return out;
+}
+/** Skips arca's own options and returns the command (matches the CLI's parsing). */
+function commandAfterRunOptions(tokens) {
+	let i = 0;
+	while (i < tokens.length) {
+		const t = tokens[i];
+		if (t === "--") return tokens.slice(i + 1);
+		if (!t.startsWith("-")) return tokens.slice(i);
+		i += RUN_OPTIONS_WITH_VALUE.has(t) ? 2 : 1;
+	}
+	return [];
+}
+const RUN_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+	"--only",
+	"--project-dir",
+	"--profile",
+	"-p"
+]);
+/** Splits a script on && || ; | (outside quotes). */
+function splitShell(script) {
+	const parts = [];
+	let cur = "";
+	let quote = null;
+	for (let i = 0; i < script.length; i++) {
+		const c = script[i];
+		if (quote) {
+			if (c === quote) quote = null;
+			cur += c;
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			quote = c;
+			cur += c;
+			continue;
+		}
+		if (c === ";" || c === "|" || c === "&") {
+			parts.push(cur);
+			cur = "";
+			if (script[i + 1] === c) i++;
+			continue;
+		}
+		cur += c;
+	}
+	parts.push(cur);
+	return parts;
+}
+function tokenize(s) {
+	const tokens = [];
+	let cur = "";
+	let has = false;
+	let quote = null;
+	for (const c of s) {
+		if (quote) {
+			if (c === quote) quote = null;
+			else cur += c;
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			quote = c;
+			has = true;
+			continue;
+		}
+		if (/\s/.test(c)) {
+			if (has || cur) tokens.push(cur);
+			cur = "";
+			has = false;
+			continue;
+		}
+		cur += c;
+	}
+	if (has || cur) tokens.push(cur);
+	return tokens;
+}
+//#endregion
+//#region src/errors.ts
+/** An expected failure: printed without a stack trace, exits with `code`. */
+var ArcaError = class extends Error {
+	code;
+	constructor(message, code = 1) {
+		super(message);
+		this.code = code;
+		this.name = "ArcaError";
+	}
+};
+//#endregion
+//#region src/config.ts
+const CONFIG_FILE = "arca.json";
+const SCHEMA_REF = "./node_modules/@bremmdev/arca-env/schema.json";
+/** Profiles aren't implemented yet. Everything uses this single set internally. */
+const DEFAULT_PROFILE = "default";
+const VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isSensitive(decl) {
+	return decl?.sensitive !== false;
+}
+function newProjectId() {
+	const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+	const bytes = randomBytes(16);
+	let id = "arc_";
+	for (const b of bytes) id += alphabet[b % 32];
+	return id;
+}
+/** Walks up from `cwd` to the nearest arca.json. */
+function findConfigFile(cwd) {
+	let dir = resolve(cwd);
+	for (;;) {
+		const file = join(dir, CONFIG_FILE);
+		if (existsSync(file)) return file;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function loadProject(cwd) {
+	const file = findConfigFile(cwd);
+	if (!file) return null;
+	return parseProject(readFileSync(file, "utf8"), file);
+}
+function parseProject(text, file) {
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (e) {
+		throw new ArcaError(`arca: ${file} is not valid JSON (${e.message}).`);
+	}
+	const warnings = [];
+	const fail = (msg) => {
+		throw new ArcaError(`arca: invalid ${CONFIG_FILE}: ${msg}\n  in ${file}`);
+	};
+	if (!isObject(raw)) fail("expected an object");
+	const o = raw;
+	if (typeof o.id !== "string" || !/^arc_[a-z2-7]{8,}$/.test(o.id)) fail("\"id\" must be an arca project ID like \"arc_7k2m9q4x8w1z3p5n\". Run `npx arca init` to create one.");
+	const name = o.name === void 0 ? dirnameName(file) : o.name;
+	if (typeof name !== "string") fail("\"name\" must be a string");
+	const envFiles = o.envFiles ?? [];
+	if (!Array.isArray(envFiles) || envFiles.some((f) => typeof f !== "string")) fail("\"envFiles\" must be an array of file names");
+	const lg = o.leakGuard ?? {};
+	if (!isObject(lg)) fail("\"leakGuard\" must be an object");
+	const ignore = lg.ignore ?? [];
+	if (!Array.isArray(ignore) || ignore.some((k) => typeof k !== "string")) fail("\"leakGuard.ignore\" must be an array of variable names");
+	const vars = {};
+	const rawVars = o.vars ?? {};
+	if (!isObject(rawVars)) fail("\"vars\" must be an object");
+	for (const [key, value] of Object.entries(rawVars)) {
+		if (!VAR_NAME.test(key)) fail(`"${key}" is not a valid environment variable name`);
+		if (!isObject(value)) fail(`vars.${key} must be an object (use {} for no options)`);
+		vars[key] = parseDecl(key, value, fail);
+	}
+	for (const key of ["profiles", "defaultProfile"]) if (key in o) warnings.push(`"${key}" in ${CONFIG_FILE} is ignored: profiles aren't available in this version yet.`);
+	const known = /* @__PURE__ */ new Set([
+		"$schema",
+		"id",
+		"name",
+		"envFiles",
+		"leakGuard",
+		"vars",
+		"profiles",
+		"defaultProfile"
+	]);
+	for (const key of Object.keys(o)) if (!known.has(key)) warnings.push(`Unknown field "${key}" in ${CONFIG_FILE} is ignored.`);
+	return {
+		root: dirname(file),
+		file,
+		config: {
+			id: o.id,
+			name,
+			envFiles,
+			leakGuard: { ignore },
+			vars
+		},
+		warnings
+	};
+}
+function parseDecl(key, v, fail) {
+	const d = {};
+	for (const field of [
+		"description",
+		"example",
+		"docs"
+	]) if (v[field] !== void 0) {
+		if (typeof v[field] !== "string") fail(`vars.${key}.${field} must be a string`);
+		d[field] = v[field];
+	}
+	for (const field of ["required", "sensitive"]) if (v[field] !== void 0) {
+		if (typeof v[field] !== "boolean") fail(`vars.${key}.${field} must be true or false`);
+		d[field] = v[field];
+	}
+	if ("default" in v || "value" in v) fail(`vars.${key} has a value. ${CONFIG_FILE} holds names only: put secrets in arca (\`npx arca set ${key}\`) and config in .env.`);
+	if (v.generate !== void 0) {
+		const g = v.generate;
+		if (!isObject(g)) fail(`vars.${key}.generate must be an object like { "bytes": 32 }`);
+		const gen = g;
+		const bytes = gen.bytes ?? 32;
+		const encoding = gen.encoding ?? "base64url";
+		if (typeof bytes !== "number" || !Number.isInteger(bytes) || bytes < 8 || bytes > 1024) fail(`vars.${key}.generate.bytes must be an integer from 8 to 1024`);
+		if (encoding !== "base64url" && encoding !== "base64" && encoding !== "hex") fail(`vars.${key}.generate.encoding must be "base64url", "base64" or "hex"`);
+		d.generate = {
+			bytes,
+			encoding
+		};
+	}
+	return d;
+}
+function isObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function dirnameName(file) {
+	return dirname(file).split(/[\\/]/).pop() ?? "project";
+}
+/**
+* Edits arca.json as raw JSON, so fields arca doesn't know about (and their order) survive.
+* Comments aren't supported because the file is plain JSON.
+*/
+function updateConfigFile(file, mutate) {
+	const raw = JSON.parse(readFileSync(file, "utf8"));
+	mutate(raw);
+	writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+}
+function declareVars(file, decls) {
+	updateConfigFile(file, (raw) => {
+		const vars = isObject(raw.vars) ? raw.vars : {};
+		for (const [name, decl] of Object.entries(decls)) if (!(name in vars)) vars[name] = decl;
+		raw.vars = vars;
+	});
+}
+function newConfig(name) {
+	return {
+		$schema: SCHEMA_REF,
+		id: newProjectId(),
+		name,
+		vars: {}
+	};
+}
+//#endregion
+//#region src/envfiles.ts
+const LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_.-]*)\s*[=:]\s?(.*)$/;
+function parseEnvEntries(text) {
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	const entries = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const m = LINE.exec(line);
+		if (!m) continue;
+		const key = m[1];
+		let rest = m[2].trimStart();
+		const start = i;
+		let value;
+		const quote = rest[0];
+		if (quote === "\"" || quote === "'" || quote === "`") {
+			let body = rest.slice(1);
+			let close = findClose(body, quote);
+			while (close === -1 && i + 1 < lines.length) {
+				i++;
+				body += "\n" + lines[i];
+				close = findClose(body, quote);
+			}
+			if (close === -1) {
+				i = start;
+				value = stripInlineComment(rest);
+			} else {
+				value = body.slice(0, close);
+				if (quote === "\"") value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\"/g, "\"");
+			}
+		} else value = stripInlineComment(rest);
+		entries.push({
+			key,
+			value,
+			startLine: start,
+			endLine: i
+		});
+	}
+	return entries;
+}
+function findClose(body, quote) {
+	for (let i = 0; i < body.length; i++) {
+		if (body[i] === "\\" && quote === "\"") {
+			i++;
+			continue;
+		}
+		if (body[i] === quote) return i;
+	}
+	return -1;
+}
+/** Like dotenv (used by Next.js and Vite): an unquoted value ends at the first `#`. */
+function stripInlineComment(raw) {
+	const hash = raw.indexOf("#");
+	return (hash === -1 ? raw : raw.slice(0, hash)).trim();
+}
+function parseEnv(text) {
+	const out = {};
+	for (const e of parseEnvEntries(text)) out[e.key] = e.value;
+	return out;
+}
+function readEnvFile(path, name = path) {
+	if (!existsSync(path)) return null;
+	try {
+		if (!statSync(path).isFile()) return null;
+		return {
+			path,
+			name,
+			entries: parseEnvEntries(readFileSync(path, "utf8"))
+		};
+	} catch {
+		return null;
+	}
+}
+const DOTENV_NAME = /^\.env(\..+)?$/;
+/** Every `.env*` file in the given directories (`.env`, `.env.local`, `.env.example`, …). */
+function findEnvFiles(dirs) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const dir of dirs) {
+		let names;
+		try {
+			names = readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const n of names.sort()) {
+			if (!DOTENV_NAME.test(n)) continue;
+			const path = resolve(dir, n);
+			if (seen.has(path)) continue;
+			seen.add(path);
+			const f = readEnvFile(path, n);
+			if (f) out.push(f);
+		}
+	}
+	return out;
+}
+/** Files a framework loads in development, lowest precedence first. */
+const DEV_FILES = [
+	".env",
+	".env.development",
+	".env.local",
+	".env.development.local"
+];
+/** Files that hold examples, not real values. Import skips them. */
+function isTemplateFile(name) {
+	return /\.(example|sample|template|dist|defaults)$/i.test(name);
+}
+/** Merged values of the given files (later files win). */
+function loadEnvFiles(root, files) {
+	const out = {};
+	for (const f of files) {
+		const file = readEnvFile(join(root, f), f);
+		if (!file) continue;
+		for (const e of file.entries) out[e.key] = e.value;
+	}
+	return out;
+}
+/**
+* Removes the entries for `keys` from a dotenv file. Comments and other lines stay.
+* Deletes the file only if nothing but whitespace is left. Returns what happened.
+*/
+function removeEntries(path, keys) {
+	const text = readFileSync(path, "utf8");
+	const eol = text.includes("\r\n") ? "\r\n" : "\n";
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	const drop = /* @__PURE__ */ new Set();
+	for (const e of parseEnvEntries(text)) {
+		if (!keys.has(e.key)) continue;
+		for (let i = e.startLine; i <= e.endLine; i++) drop.add(i);
+	}
+	if (drop.size === 0) return "unchanged";
+	const out = lines.filter((_, i) => !drop.has(i)).join(eol);
+	if (out.trim() === "") {
+		rmSync(path);
+		return "deleted";
+	}
+	writeFileSync(path, out);
+	return "edited";
+}
+//#endregion
+//#region src/leakguard.ts
+const PUBLIC_PREFIXES = [
+	"NEXT_PUBLIC_",
+	"VITE_",
+	"PUBLIC_",
+	"NUXT_PUBLIC_",
+	"EXPO_PUBLIC_",
+	"REACT_APP_",
+	"GATSBY_",
+	"STORYBOOK_"
+];
+const SECRET_NAME = /(SECRET|TOKEN|PASSWORD|PASSWD|PASSPHRASE|PRIVATE|API_?KEY|_KEY$|^KEY$|CREDENTIAL|DSN|AUTH|SALT|SIGNING|WEBHOOK)/i;
+const KNOWN_PREFIXES = /^(sk_live_|sk_test_|rk_live_|rk_test_|whsec_|ghp_|gho_|ghs_|github_pat_|glpat-|xox[abpr]-|AKIA[0-9A-Z]{12}|ASIA[0-9A-Z]{12}|AIza[0-9A-Za-z_-]{20}|sk-[A-Za-z0-9_-]{20}|sk-ant-|re_[A-Za-z0-9]{16}|SG\.|npm_[A-Za-z0-9]{20}|-----BEGIN)/;
+const CREDENTIAL_URL = /^[a-z][a-z0-9+.-]*:\/\/[^:@/\s]*:[^@/\s]+@/i;
+const JWT = /^eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}$/;
+function isPublicName(key) {
+	return PUBLIC_PREFIXES.some((p) => key.startsWith(p));
+}
+function shannonEntropy(s) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const c of s) counts.set(c, (counts.get(c) ?? 0) + 1);
+	let h = 0;
+	for (const n of counts.values()) {
+		const p = n / s.length;
+		h -= p * Math.log2(p);
+	}
+	return h;
+}
+/** Heuristic: does this .env entry look like a secret? Returns the reason, or null. */
+function secretReason(key, value) {
+	const v = value.trim();
+	if (v === "") return null;
+	if (CREDENTIAL_URL.test(v)) return "a URL with a password";
+	if (KNOWN_PREFIXES.test(v)) return "a known secret format";
+	if (JWT.test(v)) return "a token (JWT)";
+	if (v.length >= 24 && !/\s/.test(v) && !/^https?:\/\//i.test(v) && shannonEntropy(v) > 4) return "a long random-looking value";
+	if (!isPublicName(key) && SECRET_NAME.test(key) && plausibleSecretValue(v)) return "a secret-like name";
+	return null;
+}
+function plausibleSecretValue(v) {
+	if (v.length < 8) return false;
+	if (/^(true|false|yes|no|on|off|null|undefined)$/i.test(v)) return false;
+	if (/^-?\d+(\.\d+)?$/.test(v)) return false;
+	if (/^[a-z][a-z0-9+.-]*:\/\//i.test(v) && !CREDENTIAL_URL.test(v)) return false;
+	if (/^(your|change|replace|xxx|todo|<)/i.test(v)) return false;
+	return true;
+}
+function scanEnvFiles(project, files, secrets) {
+	const ignore = new Set(project.config.leakGuard.ignore);
+	const needles = secrets.flatMap((s) => needlesFor(s).map((n) => ({
+		...n,
+		name: s.name
+	})));
+	const findings = [];
+	for (const file of files) {
+		const name = relative(project.root, file.path) || file.name;
+		for (const entry of file.entries) {
+			if (entry.value.trim() === "") continue;
+			const hit = needles.find((n) => entry.value.includes(n.text));
+			if (hit) {
+				const detail = hit.name === entry.key ? `${entry.key} is stored in arca but also in plaintext in ${name}` : `${entry.key} in ${name} contains the value of ${hit.name}, which is stored in arca`;
+				findings.push({
+					file: name,
+					key: entry.key,
+					rule: "stored",
+					detail,
+					tracked: false
+				});
+				continue;
+			}
+			if (ignore.has(entry.key)) continue;
+			const decl = project.config.vars[entry.key];
+			if (decl && isSensitive(decl)) {
+				findings.push({
+					file: name,
+					key: entry.key,
+					rule: "declared",
+					detail: `${entry.key} is declared sensitive in arca.json but set in ${name}`,
+					tracked: false
+				});
+				continue;
+			}
+			if (!decl) {
+				const reason = secretReason(entry.key, entry.value);
+				if (reason) findings.push({
+					file: name,
+					key: entry.key,
+					rule: "heuristic",
+					detail: `${entry.key} in ${name} looks like a secret (${reason})`,
+					tracked: false
+				});
+			}
+		}
+	}
+	markTracked(project.root, findings);
+	return findings;
+}
+/** Escalates findings in files tracked by git. One git call, only when there are findings. */
+function markTracked(root, findings) {
+	if (findings.length === 0) return;
+	const files = [...new Set(findings.map((f) => f.file))];
+	try {
+		const out = execFileSync("git", [
+			"ls-files",
+			"--",
+			...files
+		], {
+			cwd: root,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 3e3
+		});
+		const tracked = new Set(out.split(/\r?\n/).filter(Boolean).map((f) => f.replace(/\//g, "\\")));
+		for (const f of findings) if (tracked.has(f.file) || tracked.has(f.file.replace(/\\/g, "/")) || tracked.has(f.file.replace(/\//g, "\\"))) f.tracked = true;
+	} catch {}
+}
+function summarizeFindings(findings) {
+	const files = [...new Set(findings.map((f) => f.file))];
+	const tracked = findings.some((f) => f.tracked);
+	return `arca: ${findings.length === 1 ? "1 possible secret" : `${findings.length} possible secrets`} in ${files.join(", ")}${tracked ? " (committed to git!)" : ""}. Run \`npx arca doctor\` for details.`;
+}
+//#endregion
+//#region src/messages.ts
+function detected(agent) {
+	return `detected: ${agent.name} via ${agent.via}`;
+}
+function agentRevealMessage(agent) {
+	return [
+		`arca: secret values cannot be shown to AI agents (${detected(agent)}).`,
+		"You don't need the values. Secrets are injected automatically when you run package",
+		"scripts, for example `npm run dev` or `npm test`. Their output is masked as [arca:NAME].",
+		"  • See which variables exist:   npx arca list",
+		"  • Check that they are set:     npx arca check",
+		"  • A value is missing or wrong: ask the user to run `npx arca set NAME`",
+		"  • Need a new random secret:    ask the user to run `npx arca set NAME --generate`"
+	].join("\n");
+}
+function agentWriteMessage(agent, command) {
+	return [
+		`arca: only a human can change secret values (${detected(agent)}).`,
+		"Ask the user to run this in their own terminal:",
+		`    ${command}`,
+		"If this is a new variable, you can declare it in arca.json under \"vars\" first,",
+		"so `npx arca check` and `npx arca setup` know about it."
+	].join("\n");
+}
+function agentAdhocMessage(agent, command, invocation) {
+	const why = invocation.kind === "script" && !invocation.verified && invocation.reason ? `\n(Not accepted as a package script: ${invocation.reason}.)` : "";
+	return [
+		`arca: AI agents can only use secrets through package.json scripts (${detected(agent)}).${why}`,
+		`Refused: arca run -- ${command}`,
+		"Run the command through a package.json script that uses `arca run`, e.g. `npm run dev`.",
+		"If no script exists for what you need, ask the user to add one."
+	].join("\n");
+}
+function agentDeniedMessage(agent) {
+	return [`arca: the user has turned off secrets for AI agents in this project (${detected(agent)}).`, "Ask the user to run the command themselves."].join("\n");
+}
+function notInteractiveMessage(command) {
+	return ["arca: this needs a person at an interactive terminal (stdin and stdout must be a terminal).", `Run it yourself in a terminal:  ${command}`].join("\n");
+}
+function agentsSnippet() {
+	return `## Secrets (arca)
+
+Secrets are stored outside the repo with arca and injected when commands run.
+\`.env\` files in this project contain only non-sensitive config, which you may read and edit.
+
+- Run the app, tests and tools through package scripts (\`npm run dev\`, \`npm test\`, …),
+  which wrap commands in \`arca run\`. Ad-hoc \`arca run -- <cmd>\` is refused for agents.
+  Output is always masked: secrets appear as \`[arca:NAME]\`.
+- \`npx arca list\` shows which variables exist. \`npx arca check\` verifies required ones are set.
+- Do not try to read secret values (\`npx arca reveal\`, printing \`process.env\`, reading the
+  arca store).
+- Only the user can set or change values. If a value is missing or wrong, ask the user
+  to run \`npx arca set NAME\` (or \`npx arca set NAME --generate\` for a random secret).
+- To add a secret: declare it in \`arca.json\` under \`vars\`, then ask the user to set it.
+  To add non-sensitive config: put it in \`.env\` and declare it with \`"sensitive": false\`.
+- Never put secrets (keys, tokens, passwords, connection strings with credentials) in
+  \`.env\` files. Don't change URLs that receive credentials. Those are declared sensitive
+  and live in arca.
+- Don't work around arca: don't unset or change agent environment variables (such as
+  \`CLAUDECODE\` or \`AI_AGENT\`), don't add scripts that print \`process.env\`, and don't read
+  the arca store or the OS keychain. If arca blocks you, ask the user.
+`;
+}
+//#endregion
+//#region src/policy.ts
+function decideRun(ctx, invocation, policy, displayCommand) {
+	if (!ctx.agent.detected) return { allow: true };
+	if (policy === "deny") return {
+		allow: false,
+		message: agentDeniedMessage(ctx.agent)
+	};
+	if (invocation.kind === "script" && invocation.verified) return { allow: true };
+	return {
+		allow: false,
+		message: agentAdhocMessage(ctx.agent, displayCommand, invocation)
+	};
+}
+/**
+* The human gate, required before any value is shown or changed:
+* no agent marker, and a real terminal. If an agent marker is present but the session is
+* fully interactive (a human in an IDE terminal with leaked markers), a typed challenge
+* lets the human through.
+*/
+async function humanGate(io, ctx, opts) {
+	const stdinOk = ctx.stdinIsTTY || Boolean(opts.allowPipedStdin);
+	const interactive = ctx.interactiveOutput && stdinOk;
+	if (ctx.agent.detected) {
+		if (interactive && ctx.stdinIsTTY) {
+			await challenge(io, ctx);
+			return;
+		}
+		throw new ArcaError(opts.kind === "reveal" ? agentRevealMessage(ctx.agent) : agentWriteMessage(ctx.agent, opts.command));
+	}
+	if (!interactive) throw new ArcaError(notInteractiveMessage(opts.command));
+}
+async function challenge(io, ctx) {
+	const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+	let code = "";
+	for (let i = 0; i < 4; i++) code += alphabet[randomInt(32)];
+	io.stderr.write(`arca: this terminal looks like it's driven by an AI agent (${ctx.agent.name} via ${ctx.agent.via}).\nThis confirmation must be completed by a human. AI agents must not answer this prompt.
+Type this code to continue: ${code}\n`);
+	const answer = await io.prompts.text("Code");
+	if (answer === null || answer.trim().toUpperCase() !== code) throw new ArcaError("arca: the code did not match. Nothing was changed.");
+}
+//#endregion
+//#region src/runner.ts
+async function runCommand(s, opts) {
+	const { io, ctx } = s;
+	const command = opts.command;
+	if (command.length === 0) throw new ArcaError("arca: nothing to run. Usage: arca run -- <command> [args…]", 2);
+	const project = s.project;
+	if (!project) {
+		if (!ctx.ci) s.note(s.err("dim", "arca: no arca.json found, running without secrets. Set up arca with `npx arca init`."));
+		return spawnChild(s, command, io.env, null);
+	}
+	s.warnConfig();
+	if (ctx.activeProject === project.config.id) return spawnChild(s, command, io.env, null);
+	const display = command.join(" ");
+	if (ctx.agent.detected) {
+		const decision = decideRun(ctx, verifyScript(io, command), (await s.policy()).agentRun, display);
+		if (!decision.allow) throw new ArcaError(decision.message);
+	}
+	const envFileValues = loadEnvFiles(project.root, project.config.envFiles);
+	if (!s.hasVault()) {
+		const env = {
+			...envFileValues,
+			...io.env
+		};
+		const missing = missingRequired(s, project, env);
+		if (ctx.ci || opts.passthrough) {
+			if (missing.length) throw new ArcaError(missingMessage(project, missing, true));
+			return spawnChild(s, command, env, null);
+		}
+		if (missing.filter((n) => isSensitive(project.config.vars[n])).length) throw new ArcaError(missingMessage(project, missing, false));
+		s.note(s.err("dim", `arca: no secrets stored for ${project.config.name} on this machine yet. Running without them.`));
+		return spawnChild(s, command, env, null);
+	}
+	const vault = await s.readVault();
+	const only = opts.only ? new Set(opts.only) : null;
+	const vaultValues = {};
+	for (const [name, v] of Object.entries(vault.vars)) if (!only || only.has(name)) vaultValues[name] = v.value;
+	if (only) {
+		const unknown = [...only].filter((n) => !(n in vault.vars));
+		if (unknown.length) s.note(s.err("yellow", `arca: --only names not stored in arca: ${unknown.join(", ")}`));
+	}
+	const overridden = Object.keys(vaultValues).filter((k) => io.env[k] !== void 0 && io.env[k] !== vaultValues[k]);
+	const env = opts.noOverride ? {
+		...envFileValues,
+		...vaultValues,
+		...io.env
+	} : {
+		...envFileValues,
+		...io.env,
+		...vaultValues
+	};
+	if (overridden.length && !opts.noOverride && !s.quiet) {
+		const names = overridden.join(", ");
+		const verb = overridden.length === 1 ? "overrides a different value" : "override different values";
+		s.note(s.err("dim", `arca: ${names} from arca ${verb} inherited from your shell (use --no-override to keep the shell's).`));
+	}
+	const missing = missingRequired(s, project, env);
+	if (missing.length) throw new ArcaError(missingMessage(project, missing, false));
+	const secrets = s.secrets(vault);
+	if (!s.quiet) {
+		const findings = scanEnvFiles(project, s.envFilesForGuard(), secrets);
+		if (findings.length) s.note(s.err("yellow", summarizeFindings(findings)));
+	}
+	env.ARCA_ACTIVE = project.config.id;
+	env.ARCA_PROJECT = project.config.name;
+	delete env.ARCA_PASSPHRASE;
+	addConsoleGuard(env, secrets.map((x) => x.name));
+	return spawnChild(s, command, env, secrets.flatMap(needlesFor));
+}
+/**
+* Preloads the console guard into every Node process the command starts, so values are
+* masked before in-process console wrappers (e.g. dev tools that forward server logs to the
+* browser) can see them. Only names are passed; the guard reads values from its own env.
+*/
+function addConsoleGuard(env, names, guardFile = defaultGuardFile()) {
+	if (names.length === 0 || !guardFile) return;
+	env.ARCA_MASK = names.join(",");
+	const flag = `--import=${pathToFileURL(guardFile).href}`;
+	const current = env.NODE_OPTIONS ?? "";
+	if (!current.includes(flag)) env.NODE_OPTIONS = current ? `${current} ${flag}` : flag;
+}
+function defaultGuardFile() {
+	const file = fileURLToPath(new URL("./guard.mjs", import.meta.url));
+	return existsSync(file) ? file : null;
+}
+/** Required declared vars that are neither in the env nor in a .env file the framework will load. */
+function missingRequired(s, project, env) {
+	const required = Object.entries(project.config.vars).filter(([, d]) => d.required).map(([n]) => n);
+	if (required.length === 0) return [];
+	let fileKeys = null;
+	return required.filter((name) => {
+		if (env[name] !== void 0 && env[name] !== "") return false;
+		fileKeys ??= new Set(s.envFilesForGuard().filter((f) => !isTemplateFile(f.name)).flatMap((f) => f.entries.filter((e) => e.value !== "").map((e) => e.key)));
+		return !fileKeys.has(name);
+	});
+}
+function missingMessage(project, missing, ci) {
+	const n = missing.length;
+	const head = `arca: ${n} required variable${n === 1 ? " is" : "s are"} not set for ${project.config.name}:\n  ${missing.join(", ")}`;
+	if (ci) return `${head}\nAdd ${n === 1 ? "it" : "them"} to your CI or hosting platform's environment variables.`;
+	return `${head}\nRun \`npx arca setup\` to set them. Takes about a minute. (AI agents: ask the user to run it.)`;
+}
+/** Spawns the command. With needles, stdout and stderr are piped through the masker. */
+function spawnChild(s, command, env, needles) {
+	const { io } = s;
+	const masked = needles !== null;
+	if (masked) forwardTerminalHints(s, env);
+	const [file, ...args] = command;
+	const plain = io.childStdin === "inherit" ? "inherit" : "pipe";
+	const child = spawn(file, args, {
+		env,
+		cwd: io.cwd,
+		shell: false,
+		stdio: masked ? [
+			io.childStdin,
+			"pipe",
+			"pipe"
+		] : [
+			io.childStdin,
+			plain,
+			plain
+		]
+	});
+	return new Promise((resolvePromise, reject) => {
+		const writers = [];
+		if (masked) {
+			const out = createMaskedWriter(new Redactor(needles), (t) => io.stdout.write(t));
+			const err = createMaskedWriter(new Redactor(needles), (t) => io.stderr.write(t));
+			child.stdout.on("data", (c) => out.write(c));
+			child.stderr.on("data", (c) => err.write(c));
+			writers.push(out, err);
+		} else if (io.childStdin === "ignore") {
+			child.stdout?.on("data", (c) => io.stdout.write(c.toString("utf8")));
+			child.stderr?.on("data", (c) => io.stderr.write(c.toString("utf8")));
+		}
+		const cleanups = io.handleSignals ? forwardSignals(child, io) : [];
+		child.on("error", (e) => {
+			cleanups.forEach((c) => c());
+			if (e.code === "ENOENT") reject(new ArcaError(`arca: command not found: ${file}`, 127));
+			else reject(e);
+		});
+		child.on("close", (code, signal) => {
+			cleanups.forEach((c) => c());
+			for (const w of writers) w.end();
+			if (code !== null) resolvePromise(code);
+			else resolvePromise(128 + (signal && constants.signals[signal] || 1));
+		});
+	});
+}
+/** The child's output is a pipe, so tell it about colours and the terminal size. */
+function forwardTerminalHints(s, env) {
+	const { stdout } = s.io;
+	if (stdout.isTTY) {
+		if (env.FORCE_COLOR === void 0 && !env.NO_COLOR) {
+			const depth = stdout.colorDepth ?? 4;
+			env.FORCE_COLOR = depth >= 24 ? "3" : depth >= 8 ? "2" : depth >= 4 ? "1" : "0";
+		}
+		if (stdout.columns && env.COLUMNS === void 0) env.COLUMNS = String(stdout.columns);
+		if (stdout.rows && env.LINES === void 0) env.LINES = String(stdout.rows);
+	}
+}
+function forwardSignals(child, io) {
+	const signals = [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	];
+	if (process.platform === "win32") signals.push("SIGBREAK");
+	const cleanups = [];
+	for (const sig of signals) {
+		const handler = () => {
+			if (sig === "SIGINT" && (io.stdinIsTTY || process.platform === "win32")) return;
+			if (process.platform === "win32" && sig !== "SIGTERM") return;
+			try {
+				child.kill(sig);
+			} catch {}
+		};
+		process.on(sig, handler);
+		cleanups.push(() => process.off(sig, handler));
+	}
+	return cleanups;
+}
+function newMasterKey() {
+	return randomBytes(32);
+}
+function vaultKey(master, projectId, profile) {
+	return Buffer.from(hkdfSync("sha256", master, projectId, `arca/vault/v1/${profile}`, 32));
+}
+function policyKey(master, projectId) {
+	return Buffer.from(hkdfSync("sha256", master, projectId, "arca/policy/v1", 32));
+}
+function seal(key, plaintext, aad) {
+	const iv = randomBytes(12);
+	const cipher = createCipheriv("aes-256-gcm", key, iv);
+	cipher.setAAD(Buffer.from(aad, "utf8"));
+	const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+	return {
+		iv: iv.toString("base64"),
+		tag: cipher.getAuthTag().toString("base64"),
+		ct: ct.toString("base64")
+	};
+}
+function open(key, sealed, aad) {
+	try {
+		const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(sealed.iv, "base64"));
+		decipher.setAAD(Buffer.from(aad, "utf8"));
+		decipher.setAuthTag(Buffer.from(sealed.tag, "base64"));
+		return Buffer.concat([decipher.update(Buffer.from(sealed.ct, "base64")), decipher.final()]).toString("utf8");
+	} catch {
+		throw new ArcaError("arca: could not decrypt the vault. The master key in your keychain does not match this store, or the file was modified.");
+	}
+}
+const SCRYPT = {
+	N: 2 ** 17,
+	r: 8,
+	p: 1
+};
+function scryptKey(passphrase, salt, params) {
+	return scryptSync(passphrase.normalize("NFC"), salt, 32, {
+		...params,
+		maxmem: 256 * 1024 * 1024
+	});
+}
+function wrapMasterKey(master, passphrase, params = SCRYPT) {
+	const salt = randomBytes(16);
+	const sealed = seal(scryptKey(passphrase, salt, params), master.toString("base64"), "arca-master-key:v1");
+	return {
+		format: "arca-master-key",
+		v: 1,
+		kdf: "scrypt",
+		salt: salt.toString("base64"),
+		...params,
+		...sealed
+	};
+}
+function unwrapMasterKey(wrapped, passphrase) {
+	const key = scryptKey(passphrase, Buffer.from(wrapped.salt, "base64"), wrapped);
+	try {
+		return Buffer.from(open(key, wrapped, "arca-master-key:v1"), "base64");
+	} catch {
+		throw new ArcaError("arca: wrong passphrase.");
+	}
+}
+function generateSecret(bytes, encoding) {
+	return randomBytes(bytes).toString(encoding);
+}
+//#endregion
+//#region src/store.ts
+var Store = class {
+	root;
+	constructor(root) {
+		this.root = root;
+	}
+	projectDir(id) {
+		return join(this.root, "projects", id);
+	}
+	vaultFile(id, profile) {
+		return join(this.projectDir(id), `${profile}.vault`);
+	}
+	hasVault(id, profile) {
+		return existsSync(this.vaultFile(id, profile));
+	}
+	/** True when any vault exists, used to refuse creating a new master key over old data. */
+	hasAnyVault() {
+		const dir = join(this.root, "projects");
+		if (!existsSync(dir)) return false;
+		for (const id of readdirSync(dir)) {
+			const pdir = join(dir, id);
+			try {
+				if (readdirSync(pdir).some((f) => f.endsWith(".vault"))) return true;
+			} catch {}
+		}
+		return false;
+	}
+	projectIds() {
+		const dir = join(this.root, "projects");
+		return existsSync(dir) ? readdirSync(dir).filter((d) => d.startsWith("arc_")) : [];
+	}
+	readVault(master, id, profile) {
+		const file = this.vaultFile(id, profile);
+		if (!existsSync(file)) return emptyVault();
+		const env = readEnvelope(file, "arca-vault");
+		if (env.projectId !== id || env.profile !== profile) throw new ArcaError(`arca: ${file} belongs to a different project or profile.`);
+		const data = JSON.parse(open(vaultKey(master, id, profile), env, vaultAad(id, profile)));
+		return {
+			vars: data.vars ?? {},
+			removed: data.removed ?? {},
+			meta: data.meta ?? { createdAt: (/* @__PURE__ */ new Date()).toISOString() }
+		};
+	}
+	writeVault(master, id, profile, data) {
+		const envelope = {
+			format: "arca-vault",
+			v: 1,
+			projectId: id,
+			profile,
+			kdf: "hkdf-sha256",
+			alg: "aes-256-gcm",
+			...seal(vaultKey(master, id, profile), JSON.stringify(data), vaultAad(id, profile))
+		};
+		this.withLock(id, () => {
+			const file = this.vaultFile(id, profile);
+			if (existsSync(file)) copyFileSync(file, `${file}.bak`);
+			atomicWrite(file, JSON.stringify(envelope, null, 2) + "\n");
+		});
+	}
+	policyFile(id) {
+		return join(this.projectDir(id), "policy.vault");
+	}
+	readPolicy(master, id) {
+		const file = this.policyFile(id);
+		if (!existsSync(file) || !master) return { agentRun: "scripts" };
+		const env = readEnvelope(file, "arca-policy");
+		return { agentRun: JSON.parse(open(policyKey(master, id), env, `arca-policy:v1:${id}`)).agentRun === "deny" ? "deny" : "scripts" };
+	}
+	hasPolicy(id) {
+		return existsSync(this.policyFile(id));
+	}
+	writePolicy(master, id, data) {
+		const envelope = {
+			format: "arca-policy",
+			v: 1,
+			projectId: id,
+			kdf: "hkdf-sha256",
+			alg: "aes-256-gcm",
+			...seal(policyKey(master, id), JSON.stringify(data), `arca-policy:v1:${id}`)
+		};
+		this.withLock(id, () => atomicWrite(this.policyFile(id), JSON.stringify(envelope, null, 2) + "\n"));
+	}
+	removeProject(id) {
+		rmSync(this.projectDir(id), {
+			recursive: true,
+			force: true
+		});
+		const reg = this.readRegistry();
+		delete reg[id];
+		this.writeJson("registry.json", reg);
+	}
+	readGlobalConfig() {
+		return this.readJson("config.json") ?? {};
+	}
+	writeGlobalConfig(cfg) {
+		this.writeJson("config.json", cfg);
+	}
+	readRegistry() {
+		return this.readJson("registry.json") ?? {};
+	}
+	/** Records where a project lives. Returns the previous entry so callers can detect ID collisions. */
+	touchRegistry(id, info) {
+		const reg = this.readRegistry();
+		const prev = reg[id];
+		const roots = new Set(prev?.roots ?? []);
+		roots.add(info.root);
+		reg[id] = {
+			name: info.name,
+			roots: [...roots],
+			gitRemote: info.gitRemote ?? prev?.gitRemote ?? null,
+			lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.writeJson("registry.json", reg);
+		return prev;
+	}
+	readJson(name) {
+		const file = join(this.root, name);
+		if (!existsSync(file)) return null;
+		try {
+			return JSON.parse(readFileSync(file, "utf8"));
+		} catch {
+			throw new ArcaError(`arca: ${file} is corrupt (not valid JSON).`);
+		}
+	}
+	writeJson(name, data) {
+		ensureDir(this.root);
+		atomicWrite(join(this.root, name), JSON.stringify(data, null, 2) + "\n");
+	}
+	/** Serialises writes to one project's files across processes. */
+	withLock(id, fn) {
+		const dir = this.projectDir(id);
+		ensureDir(dir);
+		const lock = join(dir, ".lock");
+		const deadline = Date.now() + 5e3;
+		for (;;) try {
+			closeSync(openSync(lock, "wx"));
+			break;
+		} catch (e) {
+			if (e.code !== "EEXIST") throw e;
+			try {
+				if (Date.now() - statSync(lock).mtimeMs > 1e4) {
+					rmSync(lock, { force: true });
+					continue;
+				}
+			} catch {
+				continue;
+			}
+			if (Date.now() > deadline) throw new ArcaError(`arca: the store is locked by another arca process (${lock}).`);
+			Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+		}
+		try {
+			return fn();
+		} finally {
+			rmSync(lock, { force: true });
+		}
+	}
+};
+function emptyVault() {
+	return {
+		vars: {},
+		removed: {},
+		meta: { createdAt: (/* @__PURE__ */ new Date()).toISOString() }
+	};
+}
+function vaultAad(id, profile) {
+	return `arca-vault:v1:${id}:${profile}`;
+}
+function readEnvelope(file, format) {
+	let env;
+	try {
+		env = JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		throw new ArcaError(`arca: ${file} is corrupt. A previous version may be in ${file}.bak.`);
+	}
+	if (env.format !== format || env.v !== 1) throw new ArcaError(`arca: ${file} has an unknown format.`);
+	return env;
+}
+function ensureDir(dir) {
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+}
+function atomicWrite(file, content) {
+	const tmp = `${file}.${process.pid}.tmp`;
+	const fd = openSync(tmp, "w", 384);
+	try {
+		writeFileSync(fd, content);
+		fsyncSync(fd);
+	} finally {
+		closeSync(fd);
+	}
+	for (let attempt = 0;; attempt++) try {
+		renameSync(tmp, file);
+		break;
+	} catch (e) {
+		const code = e.code;
+		if (attempt >= 10 || code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") {
+			rmSync(tmp, { force: true });
+			throw e;
+		}
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+	}
+	if (process.platform !== "win32") chmodSync(file, 384);
+}
+//#endregion
+//#region src/paths.ts
+/** The store lives outside every project: never in the repo, never in `.vault/`. */
+function storeRoot(env, platform) {
+	if (env.ARCA_HOME) return env.ARCA_HOME;
+	if (platform === "win32") return join(env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "arca");
+	if (platform === "darwin") return join(homedir(), "Library", "Application Support", "arca");
+	return join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "arca");
+}
+//#endregion
+//#region src/keychain.ts
+const SERVICE = "arca";
+/** The keychain account. A custom ARCA_HOME gets its own entry so stores never share keys by accident. */
+function keychainAccount(store, io) {
+	const defaultRoot = storeRoot({
+		...io.env,
+		ARCA_HOME: void 0
+	}, io.platform);
+	if (store.root === defaultRoot) return "master-key/v1";
+	return `master-key/v1/${createHash("sha256").update(store.root).digest("hex").slice(0, 12)}`;
+}
+function chooseBackend(store, io) {
+	const configured = store.readGlobalConfig().keychain ?? io.env.ARCA_KEYCHAIN;
+	if (configured === "os" || configured === "passphrase") return configured;
+	if (io.platform === "linux") {
+		if (readSafe("/proc/version").toLowerCase().includes("microsoft") || !io.env.DBUS_SESSION_BUS_ADDRESS) return "passphrase";
+	}
+	return "os";
+}
+function readSafe(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch {
+		return "";
+	}
+}
+async function osEntry() {
+	try {
+		const { Entry } = await import("@napi-rs/keyring");
+		return Entry;
+	} catch (e) {
+		throw new ArcaError(`arca: the OS keychain binding could not be loaded (${e.message}).\nUse passphrase mode instead: set ARCA_KEYCHAIN=passphrase before the first \`npx arca set\`.`);
+	}
+}
+async function loadMasterKey(store, io, opts) {
+	const backend = chooseBackend(store, io);
+	const key = backend === "os" ? await readOsKey(store, io) : await readPassphraseKey(store, io);
+	if (key) return key;
+	if (!opts.create) return null;
+	if (store.hasAnyVault()) throw new ArcaError(`arca: the master key is missing from your keychain, but encrypted vaults exist in
+  ${store.root}\nWithout the key they cannot be decrypted. Restore the keychain entry, or delete that folder to start over.`);
+	const fresh = newMasterKey();
+	if (backend === "os") await writeOsKey(store, io, fresh);
+	else await writePassphraseKey(store, io, fresh);
+	store.writeGlobalConfig({
+		...store.readGlobalConfig(),
+		keychain: backend
+	});
+	return fresh;
+}
+/** Like loadMasterKey without create, but fails with a clear message. */
+async function requireMasterKey(store, io) {
+	const key = await loadMasterKey(store, io, { create: false });
+	if (!key) throw new ArcaError(`arca: no master key found, so the stored secrets cannot be decrypted.
+  Store: ${store.root}\n  Run \`npx arca doctor\` for details.`);
+	return key;
+}
+async function readOsKey(store, io) {
+	const Entry = await osEntry();
+	let value;
+	try {
+		value = new Entry(SERVICE, keychainAccount(store, io)).getPassword();
+	} catch (e) {
+		throw new ArcaError(`arca: could not read the OS keychain (${e.message}).\nIf this machine has no keychain, use passphrase mode: set ARCA_KEYCHAIN=passphrase.`);
+	}
+	if (!value) return null;
+	const key = Buffer.from(value, "base64");
+	if (key.length !== 32) throw new ArcaError("arca: the master key in the keychain is malformed.");
+	return key;
+}
+async function writeOsKey(store, io, key) {
+	const entry = new (await (osEntry()))(SERVICE, keychainAccount(store, io));
+	entry.setPassword(key.toString("base64"));
+	if (entry.getPassword() !== key.toString("base64")) throw new ArcaError("arca: the OS keychain did not keep the master key. Use passphrase mode: set ARCA_KEYCHAIN=passphrase.");
+}
+function wrappedFile(store) {
+	return join(store.root, "master.key.enc");
+}
+async function readPassphraseKey(store, io) {
+	const file = wrappedFile(store);
+	if (!existsSync(file)) return null;
+	return unwrapMasterKey(JSON.parse(readFileSync(file, "utf8")), await getPassphrase(io, "arca passphrase"));
+}
+async function writePassphraseKey(store, io, key) {
+	let passphrase = io.env.ARCA_PASSPHRASE;
+	if (!passphrase) {
+		passphrase = await getPassphrase(io, "Choose an arca passphrase (protects all your vaults on this machine)");
+		if (await getPassphrase(io, "Repeat the passphrase") !== passphrase) throw new ArcaError("arca: the passphrases did not match.");
+	}
+	if (passphrase.length < 8) throw new ArcaError("arca: use a passphrase of at least 8 characters.");
+	ensureDir(store.root);
+	atomicWrite(wrappedFile(store), JSON.stringify(wrapMasterKey(key, passphrase), null, 2) + "\n");
+}
+async function getPassphrase(io, message) {
+	if (io.env.ARCA_PASSPHRASE) return io.env.ARCA_PASSPHRASE;
+	if (!io.stdinIsTTY || !io.stderr.isTTY) throw new ArcaError("arca: this store uses a passphrase. Run the command in an interactive terminal, or set ARCA_PASSPHRASE.");
+	const value = await io.prompts.password(message);
+	if (value === null) throw new ArcaError("arca: cancelled.");
+	return value;
+}
+//#endregion
+//#region src/style.ts
+const codes = {
+	bold: [1, 22],
+	dim: [2, 22],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	cyan: [36, 39],
+	gray: [90, 39]
+};
+function colorEnabled(s, env) {
+	if (env.NO_COLOR) return false;
+	if (env.FORCE_COLOR !== void 0) return env.FORCE_COLOR !== "0" && env.FORCE_COLOR !== "false";
+	return s.isTTY;
+}
+function painter(s, env) {
+	const on = colorEnabled(s, env);
+	return (style, text) => {
+		if (!on) return text;
+		const [open, close] = codes[style];
+		return `\u001b[${open}m${text}\u001b[${close}m`;
+	};
+}
+/** Pads a string to a visible width (ignores ANSI escapes). */
+function pad(text, width) {
+	const visible = text.replace(/\u001b\[[0-9;]*m/g, "").length;
+	return visible >= width ? text : text + " ".repeat(width - visible);
+}
+//#endregion
+//#region src/session.ts
+/** Per-invocation state shared by all commands. */
+var Session = class {
+	io;
+	store;
+	ctx;
+	project;
+	out;
+	err;
+	profile = DEFAULT_PROFILE;
+	quiet = false;
+	json = false;
+	master = null;
+	constructor(io, opts = {}) {
+		this.io = io;
+		this.store = new Store(storeRoot(io.env, io.platform));
+		const markers = safeMarkers(this.store);
+		this.ctx = buildContext(io, markers);
+		this.project = loadProject(opts.projectDir ? resolve(io.cwd, opts.projectDir) : io.cwd);
+		this.out = painter(io.stdout, io.env);
+		this.err = painter(io.stderr, io.env);
+	}
+	print(text = "") {
+		this.io.stdout.write(text + "\n");
+	}
+	/** Status and warnings go to stderr, so stdout stays clean for data. */
+	note(text) {
+		this.io.stderr.write(text + "\n");
+	}
+	warnConfig() {
+		if (!this.project || this.quiet) return;
+		for (const w of this.project.warnings) this.note(this.err("yellow", `arca: ${w}`));
+	}
+	requireProject() {
+		if (!this.project) throw new ArcaError("arca: no arca.json found in this folder or any parent. Run `npx arca init` to set up arca for this project.");
+		return this.project;
+	}
+	get projectId() {
+		return this.requireProject().config.id;
+	}
+	hasVault() {
+		return this.project ? this.store.hasVault(this.project.config.id, this.profile) : false;
+	}
+	async masterKey(create = false) {
+		if (this.master) return this.master;
+		this.master = create ? await loadMasterKey(this.store, this.io, { create: true }) : await requireMasterKey(this.store, this.io);
+		if (!this.master) throw new ArcaError("arca: no master key.");
+		return this.master;
+	}
+	/** The project's vault. Doesn't touch the keychain when no vault exists yet. */
+	async readVault() {
+		if (!this.hasVault()) return emptyVault();
+		return this.store.readVault(await this.masterKey(), this.projectId, this.profile);
+	}
+	async writeVault(data) {
+		const project = this.requireProject();
+		const master = await this.masterKey(true);
+		this.store.writeVault(master, project.config.id, this.profile, data);
+		const prev = this.store.touchRegistry(project.config.id, {
+			name: project.config.name,
+			root: project.root,
+			gitRemote: gitRemote(project.root)
+		});
+		this.warnCollision(prev);
+	}
+	warnCollision(prev) {
+		const project = this.project;
+		if (!project || !prev?.gitRemote) return;
+		const remote = gitRemote(project.root);
+		if (remote && remote !== prev.gitRemote) this.note(this.err("yellow", `arca: arca.json id ${project.config.id} is also used by ${prev.roots[0] ?? "another project"} (git remote ${prev.gitRemote}).\n  Two different repos share secrets. If that is wrong, run \`npx arca init --new-id\` in one of them.`));
+	}
+	async policy() {
+		if (!this.project || !this.store.hasPolicy(this.project.config.id)) return { agentRun: "scripts" };
+		return this.store.readPolicy(await this.masterKey(), this.project.config.id);
+	}
+	/** Stored values that count as secrets (masking needles, leak-guard exact matches). */
+	secrets(vault) {
+		const decls = this.project?.config.vars ?? {};
+		return Object.entries(vault.vars).filter(([name]) => isSensitive(decls[name])).map(([name, v]) => ({
+			name,
+			value: v.value
+		}));
+	}
+	/** Nearest directory with a package.json, from cwd up to the project root. */
+	packageRoot() {
+		let dir = resolve(this.io.cwd);
+		for (;;) {
+			if (existsSync(join(dir, "package.json"))) return dir;
+			const parent = dirname(dir);
+			if (parent === dir || this.project && dir === this.project.root) return null;
+			dir = parent;
+		}
+	}
+	/** Every .env* file the leak guard reads: project root, nearest package root, and envFiles. */
+	envFilesForGuard() {
+		const project = this.requireProject();
+		const dirs = [project.root];
+		const pkg = this.packageRoot();
+		if (pkg && pkg !== project.root) dirs.push(pkg);
+		const files = findEnvFiles(dirs);
+		for (const f of project.config.envFiles) {
+			const path = resolve(project.root, f);
+			if (files.some((x) => x.path === path)) continue;
+			const file = readEnvFile(path, f);
+			if (file) files.push(file);
+		}
+		return files;
+	}
+};
+function safeMarkers(store) {
+	try {
+		return store.readGlobalConfig().agentMarkers ?? [];
+	} catch {
+		return [];
+	}
+}
+function gitRemote(root) {
+	try {
+		return execFileSync("git", [
+			"config",
+			"--get",
+			"remote.origin.url"
+		], {
+			cwd: root,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 3e3
+		}).trim() || null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/util.ts
+function levenshtein(a, b) {
+	const dp = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		let prev = dp[0];
+		dp[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const tmp = dp[j];
+			dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+			prev = tmp;
+		}
+	}
+	return dp[b.length];
+}
+/** The closest candidate within a small edit distance, for "did you mean …?". */
+function suggest(input, candidates) {
+	let best = null;
+	let bestDist = Infinity;
+	for (const c of candidates) {
+		if (c === input) continue;
+		const d = levenshtein(input.toUpperCase(), c.toUpperCase());
+		if (d < bestDist) {
+			best = c;
+			bestDist = d;
+		}
+	}
+	const limit = Math.max(1, Math.min(3, Math.floor(input.length / 4)));
+	return bestDist <= limit ? best : null;
+}
+function plural(n, one, many = `${one}s`) {
+	return `${n} ${n === 1 ? one : many}`;
+}
+function shortDate(iso) {
+	return iso ? iso.slice(0, 10) : "";
+}
+//#endregion
+//#region src/commands/values.ts
+const now = () => (/* @__PURE__ */ new Date()).toISOString();
+function storeValue(vault, name, value, source) {
+	const old = vault.vars[name];
+	vault.vars[name] = {
+		value,
+		updatedAt: now(),
+		source,
+		previous: old ? {
+			value: old.value,
+			updatedAt: old.updatedAt
+		} : vault.removed[name] ?? null
+	};
+	delete vault.removed[name];
+}
+function checkName(name, usage) {
+	if (!name) throw new ArcaError(`arca: missing variable name. Usage: ${usage}`, 2);
+	if (!VAR_NAME.test(name)) throw new ArcaError(`arca: "${name}" is not a valid environment variable name.`, 2);
+	return name;
+}
+async function setCommand(s, opts) {
+	const project = s.requireProject();
+	let name = checkName(opts.name, "npx arca set NAME");
+	const fromStdin = opts.value === void 0 && opts.generate === void 0 && !s.io.stdinIsTTY;
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: `npx arca set ${name}`,
+		allowPipedStdin: fromStdin
+	});
+	const declared = project.config.vars;
+	if (!(name in declared)) {
+		const guess = suggest(name, Object.keys(declared));
+		if (guess && s.io.stdinIsTTY) {
+			const yes = await s.io.prompts.confirm(`${name} isn't declared in arca.json. Did you mean ${guess}?`, true);
+			if (yes === null) throw new ArcaError("arca: cancelled.");
+			if (yes) name = guess;
+		}
+	}
+	const decl = declared[name];
+	let value;
+	if (opts.generate !== void 0) value = generateSecret(opts.generate === true ? decl?.generate?.bytes ?? 32 : opts.generate, decl?.generate?.encoding ?? "base64url");
+	else if (opts.value !== void 0) {
+		s.note(s.err("yellow", "⚠ value passed on the command line; it may be in your shell history. Next time use `npx arca set NAME` (hidden prompt)."));
+		value = opts.value;
+	} else if (fromStdin) value = (await s.io.readStdin()).replace(/\r?\n$/, "");
+	else {
+		const entered = await s.io.prompts.password(`${name}${decl?.description ? ` (${decl.description})` : ""}`);
+		if (entered === null) throw new ArcaError("arca: cancelled. Nothing was changed.");
+		value = entered;
+	}
+	if (value === "") throw new ArcaError("arca: empty value. Nothing was changed. (To remove a value, use `npx arca unset NAME`.)");
+	const vault = await s.readVault();
+	const existed = name in vault.vars;
+	storeValue(vault, name, value, opts.generate !== void 0 ? "generate" : fromStdin ? "stdin" : "set");
+	await s.writeVault(vault);
+	if (!(name in declared)) {
+		let declare = false;
+		if (s.io.stdinIsTTY) declare = await s.io.prompts.confirm(`Declare ${name} in arca.json, so teammates know it's needed?`, true) === true;
+		if (declare) declareVars(project.file, { [name]: { required: true } });
+		else s.note(s.err("dim", `arca: ${name} isn't declared in arca.json. It's still injected; declare it so \`npx arca check\` and teammates know about it.`));
+	}
+	if (isSensitive(decl) && value.length < 6) s.note(s.err("yellow", `⚠ ${name} is shorter than 6 characters, so it can't be masked in output.`));
+	if (decl && !isSensitive(decl)) s.note(s.err("dim", `arca: ${name} is declared as config (sensitive: false). It's stored in arca anyway and arca's value wins over .env.`));
+	const what = opts.generate !== void 0 ? "Generated" : existed ? "Updated" : "Set";
+	s.note(`${s.err("green", "✔")} ${what} ${name} for ${project.config.name}${existed ? " (previous value kept, `npx arca restore " + name + "` undoes this)" : ""}`);
+	return 0;
+}
+async function unsetCommand(s, rawName) {
+	const project = s.requireProject();
+	const name = checkName(rawName, "npx arca unset NAME");
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: `npx arca unset ${name}`
+	});
+	const vault = await s.readVault();
+	const v = vault.vars[name];
+	if (!v) throw new ArcaError(`arca: ${name} is not stored in arca for ${project.config.name}.`);
+	vault.removed[name] = {
+		value: v.value,
+		updatedAt: v.updatedAt
+	};
+	delete vault.vars[name];
+	await s.writeVault(vault);
+	s.note(`${s.err("green", "✔")} Removed ${name}. \`npx arca restore ${name}\` brings it back.`);
+	return 0;
+}
+async function restoreCommand(s, rawName) {
+	s.requireProject();
+	const name = checkName(rawName, "npx arca restore NAME");
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: `npx arca restore ${name}`
+	});
+	const vault = await s.readVault();
+	const current = vault.vars[name];
+	if (current?.previous) vault.vars[name] = {
+		value: current.previous.value,
+		updatedAt: now(),
+		source: "restore",
+		previous: {
+			value: current.value,
+			updatedAt: current.updatedAt
+		}
+	};
+	else if (!current && vault.removed[name]) storeValue(vault, name, vault.removed[name].value, "restore");
+	else throw new ArcaError(`arca: there's no previous value of ${name} to restore.`);
+	await s.writeVault(vault);
+	s.note(`${s.err("green", "✔")} Restored the previous value of ${name}. Run it again to undo.`);
+	return 0;
+}
+async function revealCommand(s, rawName) {
+	const project = s.requireProject();
+	const name = checkName(rawName, "npx arca reveal NAME");
+	await humanGate(s.io, s.ctx, {
+		kind: "reveal",
+		command: `npx arca reveal ${name}`
+	});
+	const vault = await s.readVault();
+	const v = vault.vars[name];
+	if (!v) {
+		const guess = suggest(name, Object.keys(vault.vars));
+		throw new ArcaError(`arca: ${name} is not stored in arca for ${project.config.name}.${guess ? ` Did you mean ${guess}?` : ""}`);
+	}
+	s.print(v.value);
+	return 0;
+}
+async function exportCommand(s, opts) {
+	const project = s.requireProject();
+	const format = opts.format ?? "dotenv";
+	if (![
+		"dotenv",
+		"json",
+		"shell"
+	].includes(format)) throw new ArcaError("arca: --format must be dotenv, json or shell.", 2);
+	await humanGate(s.io, s.ctx, {
+		kind: "reveal",
+		command: "npx arca export"
+	});
+	const vault = await s.readVault();
+	const entries = Object.entries(vault.vars).map(([k, v]) => [k, v.value]);
+	let text;
+	if (format === "json") text = JSON.stringify(Object.fromEntries(entries), null, 2);
+	else if (format === "shell") text = entries.map(([k, v]) => `export ${k}='${v.replace(/'/g, `'\\''`)}'`).join("\n");
+	else text = entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join("\n");
+	if (opts.output) {
+		writeFileSync(resolve(s.io.cwd, opts.output), text + "\n", { mode: 384 });
+		s.note(`${s.err("green", "✔")} Wrote ${plural(entries.length, "secret")} to ${opts.output}`);
+		s.note(s.err("yellow", `⚠ That file holds plaintext secrets. Delete it when you're done. The leak guard will flag it while it sits in ${project.config.name}.`));
+	} else s.print(text);
+	return 0;
+}
+async function setupCommand(s, opts) {
+	const project = s.requireProject();
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: "npx arca setup"
+	});
+	const vault = await s.readVault();
+	const todo = Object.entries(project.config.vars).filter(([name, d]) => isSensitive(d) && !(name in vault.vars) && (opts.all || d.required));
+	if (todo.length === 0) {
+		s.note(`${s.err("green", "✔")} All ${opts.all ? "declared" : "required"} secrets are set for ${project.config.name}.`);
+		return 0;
+	}
+	s.note(`arca: ${plural(todo.length, "variable")} to set for ${project.config.name}. Leave a prompt empty to skip it.\n`);
+	let set = 0;
+	for (const [name, d] of todo) {
+		s.note(`${s.err("cyan", "◆")} ${s.err("bold", name)}${d.description ? `: ${d.description}` : ""}`);
+		if (d.docs) s.note(`  get it at ${d.docs}`);
+		if (d.example) s.note(s.err("dim", `  example: ${d.example}`));
+		let value = null;
+		if (d.generate) {
+			const gen = await s.io.prompts.confirm(`Generate a random value for ${name}?`, true);
+			if (gen === null) break;
+			if (gen) value = generateSecret(d.generate.bytes ?? 32, d.generate.encoding ?? "base64url");
+		}
+		if (value === null) {
+			const entered = await s.io.prompts.password(name);
+			if (entered === null) break;
+			value = entered === "" ? null : entered;
+		}
+		if (value === null) {
+			s.note(s.err("dim", `  skipped ${name}`));
+			continue;
+		}
+		storeValue(vault, name, value, "setup");
+		await s.writeVault(vault);
+		set++;
+	}
+	const left = todo.length - set;
+	if (left === 0) s.note(`\n${s.err("green", "✔")} All ${opts.all ? "declared" : "required"} variables set. Run \`npm run dev\`.`);
+	else s.note(`\narca: set ${set}, ${left} still missing. Run \`npx arca setup\` again later.`);
+	return left === 0 ? 0 : 1;
+}
+/** Decides which entries of which files are secrets. Shared with `arca init`. */
+function planImport(s, files, opts = {}) {
+	const project = s.requireProject();
+	const sources = [];
+	for (const f of files) {
+		const file = readEnvFile(resolve(s.io.cwd, f), f) ?? readEnvFile(join(project.root, f), f);
+		if (file) sources.push(file);
+	}
+	const merged = /* @__PURE__ */ new Map();
+	for (const file of sources) for (const e of file.entries) merged.set(e.key, {
+		value: e.value,
+		file: file.name
+	});
+	const only = opts.only ? new Set(opts.only) : null;
+	const secrets = /* @__PURE__ */ new Map();
+	const skipped = [];
+	for (const [key, v] of merged) {
+		if (only && !only.has(key)) continue;
+		if (v.value === "") {
+			skipped.push({
+				key,
+				why: "empty"
+			});
+			continue;
+		}
+		const decl = project.config.vars[key];
+		if (decl && !isSensitive(decl)) {
+			skipped.push({
+				key,
+				why: "declared as config"
+			});
+			continue;
+		}
+		if (decl || only || opts.includePublic || secretReason(key, v.value)) secrets.set(key, v);
+		else skipped.push({
+			key,
+			why: "doesn't look secret"
+		});
+	}
+	return {
+		sources,
+		secrets,
+		skipped
+	};
+}
+function defaultImportFiles(s) {
+	const root = s.requireProject().root;
+	return DEV_FILES.filter((f) => existsSync(join(root, f)));
+}
+async function importCommand(s, opts) {
+	const project = s.requireProject();
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: "npx arca import" + (opts.delete ? " --delete" : "")
+	});
+	const files = opts.files.length ? opts.files : defaultImportFiles(s);
+	if (files.length === 0) throw new ArcaError(`arca: no .env files found in ${project.root}. Name the file: npx arca import path/to/.env`);
+	const plan = planImport(s, files, opts);
+	if (plan.sources.length === 0) throw new ArcaError(`arca: none of these files exist: ${files.join(", ")}`);
+	const vault = await s.readVault();
+	const conflicts = [...plan.secrets].filter(([k, v]) => vault.vars[k] && vault.vars[k].value !== v.value).map(([k]) => k);
+	let overwrite = Boolean(opts.yes);
+	if (conflicts.length && !opts.yes) {
+		const answer = await s.io.prompts.confirm(`${conflicts.join(", ")} already in arca with a different value. Overwrite?`, false);
+		if (answer === null) throw new ArcaError("arca: cancelled. Nothing was changed.");
+		overwrite = answer;
+	}
+	const imported = [];
+	for (const [key, v] of plan.secrets) {
+		if (vault.vars[key]?.value === v.value) {
+			imported.push(key);
+			continue;
+		}
+		if (vault.vars[key] && !overwrite) continue;
+		storeValue(vault, key, v.value, `import:${v.file}`);
+		imported.push(key);
+	}
+	if (imported.length) await s.writeVault(vault);
+	const undeclared = imported.filter((k) => !(k in project.config.vars));
+	if (undeclared.length) declareVars(project.file, Object.fromEntries(undeclared.map((k) => [k, {}])));
+	s.note(`${s.err("green", "✔")} Imported ${plural(imported.length, "secret")} into arca${imported.length ? `: ${imported.join(", ")}` : ""}`);
+	if (undeclared.length) s.note(`${s.err("green", "✔")} Declared ${undeclared.join(", ")} in arca.json`);
+	const config = plan.skipped.filter((x) => x.why !== "empty");
+	if (config.length) s.note(s.err("dim", `  stays in .env: ${config.map((x) => x.key).join(", ")}${opts.includePublic ? "" : " (use --include-public or --only to import these too)"}`));
+	if (opts.delete && imported.length) {
+		const keys = new Set(imported);
+		for (const src of plan.sources) {
+			const result = removeEntries(src.path, keys);
+			const name = relative(project.root, src.path) || src.name;
+			if (result === "edited") s.note(`${s.err("green", "✔")} Removed the imported entries from ${name} (other lines kept)`);
+			if (result === "deleted") s.note(`${s.err("green", "✔")} Deleted ${name} (nothing else was in it)`);
+		}
+	} else if (imported.length) {
+		s.note(s.err("yellow", `⚠ Your .env files were not changed, so these secrets still have plaintext copies.`));
+		s.note(`  Remove just those entries (config lines stay):   npx arca import --delete`);
+	}
+	return 0;
+}
+//#endregion
+//#region src/commands/init.ts
+const KNOWN_TOOLS = /* @__PURE__ */ new Set([
+	"next",
+	"vite",
+	"astro",
+	"nuxt",
+	"nuxi",
+	"react-router",
+	"remix",
+	"svelte-kit",
+	"vinxi",
+	"tsx",
+	"node",
+	"vitest",
+	"jest",
+	"playwright",
+	"prisma",
+	"drizzle-kit",
+	"wrangler",
+	"turbo",
+	"nodemon",
+	"ts-node",
+	"tsup",
+	"tanstack",
+	"storybook",
+	"start-storybook",
+	"netlify",
+	"vercel",
+	"nest",
+	"expo",
+	"react-scripts",
+	"webpack"
+]);
+/** The tool a script runs first (`next dev` → next, `npx prisma migrate` → prisma). Null for compound scripts. */
+function firstCommand(script) {
+	if (/&&|\|\||[;|<>]/.test(script)) return null;
+	const tokens = tokenize(script);
+	let i = 0;
+	if (tokens[i] === "npx" || tokens[i] === "bunx" || tokens[i] === "dotenv") i++;
+	if ((tokens[i] === "pnpm" || tokens[i] === "yarn") && tokens[i + 1] === "exec") i += 2;
+	const t = tokens[i];
+	if (!t || /^[A-Za-z_][A-Za-z0-9_]*=/.test(t) || t === "cross-env") return null;
+	return basename(t);
+}
+const FRAMEWORKS = [
+	["next", "Next.js"],
+	["@tanstack/react-start", "TanStack Start"],
+	["@tanstack/solid-start", "TanStack Start"],
+	["astro", "Astro"],
+	["nuxt", "Nuxt"],
+	["@sveltejs/kit", "SvelteKit"],
+	["@remix-run/dev", "Remix"],
+	["@react-router/dev", "React Router"],
+	["vite", "Vite"]
+];
+function detectFramework(pkg) {
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	for (const [dep, label] of FRAMEWORKS) if (deps[dep]) return `${label} ${deps[dep].replace(/^[\^~]/, "")}`;
+	return null;
+}
+async function initCommand(s, opts) {
+	const { io } = s;
+	const root = io.cwd;
+	const configFile = join(root, CONFIG_FILE);
+	const pkgFile = join(root, "package.json");
+	const pkg = existsSync(pkgFile) ? JSON.parse(readFileSync(pkgFile, "utf8")) : null;
+	const interactive = s.ctx.interactiveOutput && s.ctx.stdinIsTTY && !opts.yes;
+	const ok = (t) => s.note(`${s.err("green", "✔")} ${t}`);
+	const step = (t) => s.note(`${s.err("cyan", "◇")} ${t}`);
+	const ask = async (q, initial = true) => {
+		if (!interactive) return initial;
+		const r = await io.prompts.confirm(q, initial);
+		if (r === null) throw new ArcaError("arca: cancelled.");
+		return r;
+	};
+	let created = false;
+	if (existsSync(configFile)) {
+		if (opts.newId) {
+			const id = newProjectId();
+			updateConfigFile(configFile, (raw) => {
+				raw.id = id;
+			});
+			ok(`New project ID ${id}. This project no longer shares secrets with the old ID.`);
+			return 0;
+		}
+		const existing = parseProject(readFileSync(configFile, "utf8"), configFile);
+		step(`arca.json already exists (${existing.config.name}, ${existing.config.id}). Checking the rest of the setup.`);
+	} else {
+		let name = pkg?.name?.replace(/^@[^/]+\//, "") ?? basename(root);
+		if (interactive) {
+			const answer = await io.prompts.text("Project name", { initial: name });
+			if (answer === null) throw new ArcaError("arca: cancelled.");
+			name = answer.trim() || name;
+		}
+		writeFileSync(configFile, JSON.stringify(newConfig(name), null, 2) + "\n");
+		created = true;
+	}
+	const framework = pkg ? detectFramework(pkg) : null;
+	if (framework) step(`Detected ${framework}`);
+	const devFiles = DEV_FILES.map((f) => readEnvFile(join(root, f), f)).filter((f) => f !== null);
+	const otherFiles = safeReaddir(root).filter((n) => /^\.env\./.test(n) && !DEV_FILES.includes(n) && !isTemplateFile(n));
+	const merged = /* @__PURE__ */ new Map();
+	for (const f of devFiles) for (const e of f.entries) merged.set(e.key, e.value);
+	let secretKeys = [];
+	const config = parseProject(readFileSync(configFile, "utf8"), configFile).config;
+	if (merged.size === 0) step("No .env files with values found. Secrets go in arca (`npx arca set NAME`), non-sensitive config can stay in .env.");
+	else {
+		step(`Found ${devFiles.map((f) => `${f.name} (${plural(f.entries.length, "var")})`).join(", ")}`);
+		const keys = [...merged.keys()];
+		const suggested = keys.filter((k) => {
+			const d = config.vars[k];
+			if (d) return d.sensitive !== false;
+			return Boolean(secretReason(k, merged.get(k)));
+		});
+		if (interactive) {
+			const picked = await io.prompts.multiselect("Which of these are secrets? Secrets move to arca, the rest stays in .env as config.", keys.map((k) => ({
+				value: k,
+				label: k,
+				hint: isPublicName(k) ? "public" : secretReason(k, merged.get(k)) ?? void 0
+			})), suggested);
+			if (picked === null) throw new ArcaError("arca: cancelled.");
+			secretKeys = picked;
+		} else secretKeys = suggested;
+		const stays = keys.filter((k) => !secretKeys.includes(k));
+		s.note(`    → arca    ${secretKeys.join(", ") || "(none)"}`);
+		s.note(`    stays     ${stays.join(", ") || "(none)"}`);
+		const decls = {};
+		for (const k of secretKeys) decls[k] = { required: true };
+		for (const k of stays) decls[k] = { sensitive: false };
+		declareVars(configFile, decls);
+	}
+	if (otherFiles.length) step(`Left alone: ${otherFiles.join(", ")} (separate sets of values arrive with profiles in a later version)`);
+	ok(`${created ? "Created" : "Updated"} arca.json${created ? ` (id ${parseProject(readFileSync(configFile, "utf8"), configFile).config.id})` : ""}`);
+	const session = new Session(io);
+	let imported = 0;
+	if (secretKeys.length && opts.import !== false) try {
+		await humanGate(io, session.ctx, {
+			kind: "write",
+			command: "npx arca import"
+		});
+		const hadKey = session.store.readGlobalConfig().keychain !== void 0;
+		const vault = await session.readVault();
+		for (const k of secretKeys) {
+			const v = merged.get(k);
+			if (v === "") continue;
+			storeValue(vault, k, v, `import:${[...devFiles].reverse().find((f) => f.entries.some((e) => e.key === k))?.name ?? ".env"}`);
+			imported++;
+		}
+		await session.writeVault(vault);
+		if (!hadKey) ok(`Master key created in ${chooseBackend(session.store, io) === "os" ? keychainLabel(io.platform) : "a passphrase-protected file"}`);
+		ok(`Imported ${plural(imported, "secret")} into arca`);
+		ok("Your .env files were not changed");
+	} catch (e) {
+		if (!(e instanceof ArcaError)) throw e;
+		s.note(`${s.err("yellow", "✋")} Moving secret values into arca needs a human. Ask the user to run:  npx arca import`);
+		s.note("   (the .env files stay untouched)");
+	}
+	if (pkg?.scripts) {
+		const candidates = Object.entries(pkg.scripts).filter(([k, v]) => k !== "start" && !/\barca\s+run\b/.test(v) && KNOWN_TOOLS.has(firstCommand(v) ?? ""));
+		let toWrap = candidates.map(([k]) => k);
+		if (candidates.length && interactive) {
+			const picked = await io.prompts.multiselect("Wrap these package.json scripts with `arca run`, so they get secrets?", candidates.map(([k, v]) => ({
+				value: k,
+				label: k,
+				hint: v
+			})), toWrap);
+			if (picked === null) throw new ArcaError("arca: cancelled.");
+			toWrap = picked;
+		}
+		if (toWrap.length) {
+			wrapScripts(pkgFile, toWrap);
+			ok(`Wrapped scripts: ${toWrap.join(", ")}`);
+			for (const k of toWrap) s.note(s.err("dim", `    ${k}: "${pkg.scripts[k]}"  →  "arca run -- ${pkg.scripts[k]}"`));
+		}
+		const wrappedAlready = Object.keys(pkg.scripts).filter((k) => /\barca\s+run\b/.test(pkg.scripts[k]));
+		if (wrappedAlready.length && !toWrap.length) step(`Already wrapped: ${wrappedAlready.join(", ")}`);
+		const wrappedNow = /* @__PURE__ */ new Set([...wrappedAlready, ...toWrap]);
+		const skipped = Object.entries(pkg.scripts).filter(([k]) => !wrappedNow.has(k));
+		if (skipped.length) {
+			step("Not wrapped:");
+			for (const [k, v] of skipped) s.note(s.err("dim", `    ${k}: ${skipReason(k, v, pkg.scripts, wrappedNow)}`));
+		}
+		const start = pkg.scripts.start;
+		if (start && !/\barca\s+run\b/.test(start) && !pkg.scripts["start:local"] && KNOWN_TOOLS.has(firstCommand(start) ?? "")) {
+			if (await ask("Add \"start:local\" to run the production build locally with your secrets?", true)) {
+				addScript(pkgFile, "start:local", `arca run -- ${start}`);
+				ok(`Added "start:local": "arca run -- ${start}"`);
+			}
+		}
+	} else if (!pkg) step("No package.json here. Wrap your commands yourself: arca run -- <command>");
+	const docs = ["AGENTS.md", "CLAUDE.md"].filter((f) => existsSync(join(root, f)));
+	const marker = "## Secrets (arca)";
+	const missingSnippet = docs.filter((f) => !readFileSync(join(root, f), "utf8").includes(marker));
+	if (docs.length === 0) {
+		if (await ask("Create AGENTS.md with a short \"Secrets (arca)\" section for AI agents?", true)) {
+			writeFileSync(join(root, "AGENTS.md"), `# Agent instructions\n\n${agentsSnippet()}`);
+			ok("Created AGENTS.md with the \"Secrets (arca)\" section");
+		}
+	} else if (missingSnippet.length) {
+		if (await ask(`Add a "Secrets (arca)" section to ${missingSnippet.join(" and ")}?`, true)) {
+			for (const f of missingSnippet) {
+				const text = readFileSync(join(root, f), "utf8");
+				appendFileSync(join(root, f), `${text.endsWith("\n") ? "" : "\n"}\n${agentsSnippet()}`);
+			}
+			ok(`Added the "Secrets (arca)" section to ${missingSnippet.join(" and ")}`);
+		}
+	}
+	const outdated = docs.filter((f) => {
+		const section = findSection(readFileSync(join(root, f), "utf8"), marker);
+		return section !== null && section.text.trim() !== agentsSnippet().trim();
+	});
+	if (outdated.length && await ask(`Update the "Secrets (arca)" section in ${outdated.join(" and ")} to the current text?`, true)) {
+		for (const f of outdated) {
+			const text = readFileSync(join(root, f), "utf8");
+			const section = findSection(text, marker);
+			const trailing = /\s*$/.exec(section.text)?.[0] ?? "\n";
+			writeFileSync(join(root, f), text.slice(0, section.start) + agentsSnippet().trimEnd() + trailing + text.slice(section.end));
+		}
+		ok(`Updated the "Secrets (arca)" section in ${outdated.join(" and ")}`);
+	}
+	const deps = {
+		...pkg?.dependencies,
+		...pkg?.devDependencies
+	};
+	if (pkg && !deps["@bremmdev/arca-env"]) s.note(`\nInstall arca in this project:  npm i -D @bremmdev/arca-env`);
+	if (imported) {
+		s.note("\n" + s.err("yellow", `⚠ The ${plural(imported, "secret")} still have plaintext copies in ${devFiles.map((f) => f.name).join(", ")}.`));
+		s.note("  Remove just those entries (config lines stay):   npx arca import --delete");
+	} else if (!secretKeys.length) s.note("\nNext: npx arca set DATABASE_URL   or   npx arca setup");
+	return 0;
+}
+/** The arca section of an AGENTS.md: from its heading to the next heading or HTML comment block. */
+function findSection(text, marker) {
+	const start = text.indexOf(marker);
+	if (start === -1) return null;
+	const next = text.slice(start + marker.length).search(/\n(?=#{1,2} |<!--)/);
+	const end = next === -1 ? text.length : start + marker.length + next + 1;
+	return {
+		start,
+		end,
+		text: text.slice(start, end)
+	};
+}
+/** Why `init` leaves a script unwrapped, in words a user can act on. */
+function skipReason(name, script, scripts, wrapped) {
+	if (name === "start") return "production start, left alone on purpose (the host provides the env, and arca may not be installed there)";
+	if (/&&|\|\||;/.test(script)) {
+		if (script.split(/&&|\|\||;/).map((p) => p.trim()).filter(Boolean).every((part) => {
+			const run = /^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?([\w:.-]+)/.exec(part)?.[1];
+			if (run) return wrapped.has(run) || !(run in scripts) || !KNOWN_TOOLS.has(firstCommand(scripts[run]) ?? "");
+			const tool = firstCommand(part);
+			return tool !== null && !KNOWN_TOOLS.has(tool);
+		})) return "chains other scripts and tools; the ones that need secrets are wrapped themselves";
+		return "compound command, wrap the part that needs secrets by hand";
+	}
+	const tool = firstCommand(script);
+	if (tool === null) return "sets env vars inline or uses cross-env, wrap by hand if it needs secrets";
+	return `${tool} doesn't need secrets (wrap by hand if it does: arca run -- ${script})`;
+}
+function addScript(pkgFile, name, script) {
+	const text = readFileSync(pkgFile, "utf8");
+	const indent = /\n(\s+)"/.exec(text)?.[1] ?? "  ";
+	const pkg = JSON.parse(text);
+	pkg.scripts = {
+		...pkg.scripts,
+		[name]: script
+	};
+	const eol = text.includes("\r\n") ? "\r\n" : "\n";
+	writeFileSync(pkgFile, JSON.stringify(pkg, null, indent).replace(/\n/g, eol) + eol);
+}
+function wrapScripts(pkgFile, names) {
+	const text = readFileSync(pkgFile, "utf8");
+	const indent = /\n(\s+)"/.exec(text)?.[1] ?? "  ";
+	const pkg = JSON.parse(text);
+	for (const n of names) {
+		const v = pkg.scripts[n];
+		if (!/\barca\s+run\b/.test(v)) pkg.scripts[n] = `arca run -- ${v}`;
+	}
+	const eol = text.includes("\r\n") ? "\r\n" : "\n";
+	writeFileSync(pkgFile, JSON.stringify(pkg, null, indent).replace(/\n/g, eol) + eol);
+}
+function safeReaddir(dir) {
+	try {
+		return readdirSync(dir);
+	} catch {
+		return [];
+	}
+}
+function keychainLabel(platform) {
+	return platform === "win32" ? "Windows Credential Manager" : platform === "darwin" ? "the macOS Keychain" : "the Secret Service keyring";
+}
+//#endregion
+//#region src/commands/info.ts
+function rows(s, vault) {
+	const project = s.requireProject();
+	const decls = project.config.vars;
+	const files = s.envFilesForGuard().filter((f) => !isTemplateFile(f.name));
+	const inFile = (name) => files.find((f) => f.entries.some((e) => e.key === name && e.value !== ""));
+	return [.../* @__PURE__ */ new Set([...Object.keys(decls), ...Object.keys(vault.vars)])].map((name) => {
+		const d = decls[name];
+		const stored = vault.vars[name];
+		const sensitive = isSensitive(d);
+		const file = inFile(name);
+		const base = {
+			name,
+			sensitive,
+			required: Boolean(d?.required),
+			declared: Boolean(d),
+			description: d?.description
+		};
+		if (stored) return {
+			...base,
+			status: "arca",
+			updatedAt: stored.updatedAt
+		};
+		if (file) return {
+			...base,
+			status: sensitive ? "env-file-sensitive" : "env-file",
+			source: relative(project.root, file.path) || file.name
+		};
+		return {
+			...base,
+			status: d?.required ? "missing" : "unset"
+		};
+	});
+}
+function statusText(r, p) {
+	switch (r.status) {
+		case "arca": return p("green", "✔ arca");
+		case "env-file": return p("cyan", `✔ ${r.source}`);
+		case "env-file-sensitive": return p("yellow", `⚠ ${r.source} (should be in arca)`);
+		case "missing": return p("red", "✖ missing (required)");
+		case "unset": return p("dim", "– not set");
+	}
+}
+async function listCommand(s) {
+	const project = s.requireProject();
+	s.warnConfig();
+	const list = rows(s, await s.readVault());
+	if (s.json) {
+		s.print(JSON.stringify(list.map(({ description, ...r }) => ({
+			...r,
+			description: description ?? null
+		})), null, 2));
+		return 0;
+	}
+	const p = s.out;
+	if (list.length === 0) {
+		s.print(`No variables declared or stored for ${project.config.name} yet. Declare them in arca.json, then run \`npx arca setup\`.`);
+		return 0;
+	}
+	const w = Math.max(4, ...list.map((r) => r.name.length)) + 2;
+	const sw = Math.max(...list.map((r) => statusText(r, (_, t) => t).length)) + 2;
+	s.print(p("bold", `${pad("NAME", w)}${pad("STATUS", sw)}${pad("KIND", 9)}UPDATED`));
+	for (const r of list) {
+		const kind = r.sensitive ? "secret" : "config";
+		const extra = r.declared ? "" : p("dim", "  (undeclared)");
+		s.print(`${pad(r.name, w)}${pad(statusText(r, p), sw)}${pad(kind, 9)}${shortDate(r.updatedAt)}${extra}`);
+	}
+	return 0;
+}
+async function checkCommand(s, opts) {
+	const project = s.requireProject();
+	s.warnConfig();
+	const vault = await s.readVault();
+	const files = s.envFilesForGuard().filter((f) => !isTemplateFile(f.name));
+	const envFileValues = loadEnvFiles(project.root, project.config.envFiles);
+	const present = (name) => name in vault.vars || Boolean(s.io.env[name]) || Boolean(envFileValues[name]) || files.some((f) => f.entries.some((e) => e.key === name && e.value !== ""));
+	const required = Object.entries(project.config.vars).filter(([, d]) => d.required);
+	const missing = required.filter(([n]) => !present(n)).map(([n]) => n);
+	const misplaced = required.filter(([n, d]) => isSensitive(d) && !(n in vault.vars) && !s.io.env[n] && present(n)).map(([n]) => n);
+	const findings = scanEnvFiles(project, s.envFilesForGuard(), s.secrets(vault));
+	const undeclared = Object.keys(vault.vars).filter((n) => !(n in project.config.vars));
+	if (s.json) s.print(JSON.stringify({
+		ok: missing.length === 0 && (!opts.strict || findings.length === 0),
+		missing,
+		inEnvFiles: misplaced,
+		undeclared,
+		leakGuard: findings
+	}, null, 2));
+	else {
+		const p = s.out;
+		if (missing.length === 0) s.print(`${p("green", "✔")} All ${plural(required.length, "required variable")} set for ${project.config.name}`);
+		else {
+			s.print(`${p("red", "✖")} ${plural(missing.length, "required variable")} missing for ${project.config.name}: ${missing.join(", ")}`);
+			s.print(`  Run \`npx arca setup\` to set them. (AI agents: ask the user to run it.)`);
+		}
+		for (const n of misplaced) s.print(`${p("yellow", "⚠")} ${n} is a secret but comes from a .env file. Move it: npx arca import --only ${n} --delete`);
+		if (undeclared.length) s.print(p("dim", `  stored but not declared in arca.json: ${undeclared.join(", ")}`));
+		if (findings.length) s.print(`${p("yellow", "⚠")} Leak guard: ${plural(findings.length, "possible secret")} in .env files (run \`npx arca doctor\` for details)`);
+	}
+	if (missing.length) return 1;
+	if (opts.strict && findings.length) return 1;
+	return 0;
+}
+async function doctorCommand(s) {
+	const p = s.out;
+	const ok = (t) => s.print(`  ${p("green", "✔")} ${t}`);
+	const warn = (t) => s.print(`  ${p("yellow", "⚠")} ${t}`);
+	const bad = (t) => s.print(`  ${p("red", "✖")} ${t}`);
+	const info = (t) => s.print(`  ${p("dim", "·")} ${t}`);
+	let problems = 0;
+	s.print(p("bold", "Context"));
+	info(`Node ${process.version} on ${s.io.platform}`);
+	const a = s.ctx.agent;
+	if (a.detected) info(`You look like an AI agent: ${a.name} via ${a.via}. Values can't be shown or changed from here.`);
+	else info("No AI agent detected");
+	info(s.ctx.interactiveOutput && s.ctx.stdinIsTTY ? "Interactive terminal" : "Not an interactive terminal");
+	if (s.ctx.ci) info("CI detected: wrapped scripts pass through without a store");
+	s.print(p("bold", "\nStore"));
+	info(`Location: ${s.store.root}`);
+	info(`Key storage: ${chooseBackend(s.store, s.io) === "os" ? osKeychainName(s.io.platform) : "passphrase (master.key.enc)"}`);
+	let master = null;
+	try {
+		master = await loadMasterKey(s.store, s.io, { create: false });
+		if (master) ok("Master key found");
+		else if (s.store.hasAnyVault()) {
+			bad("Master key missing, but vaults exist. They cannot be decrypted.");
+			problems++;
+		} else info("No master key yet (created on the first `npx arca set`)");
+	} catch (e) {
+		bad(e.message.replace(/^arca: /, ""));
+		problems++;
+	}
+	if (!s.project) {
+		s.print(p("bold", "\nProject"));
+		info("No arca.json here or in any parent folder. Run `npx arca init`.");
+		return problems ? 1 : 0;
+	}
+	const project = s.project;
+	s.print(p("bold", "\nProject"));
+	info(`${project.config.name} (${project.config.id})`);
+	info(`Config: ${project.file}`);
+	for (const w of project.warnings) warn(w);
+	const vault = master && s.hasVault() ? s.store.readVault(master, project.config.id, s.profile) : null;
+	if (s.hasVault()) ok(`Vault: ${plural(Object.keys(vault?.vars ?? {}).length, "secret")} stored`);
+	else info("No secrets stored for this project on this machine yet");
+	const reg = s.store.readRegistry()[project.config.id];
+	const remote = gitRemote(project.root);
+	if (reg?.gitRemote && remote && reg.gitRemote !== remote) {
+		warn(`The ID is also used by ${reg.roots[0]} (git remote ${reg.gitRemote}). If these are different projects: npx arca init --new-id`);
+		problems++;
+	}
+	const decls = project.config.vars;
+	const short = Object.entries(vault?.vars ?? {}).filter(([n, v]) => isSensitive(decls[n]) && v.value.length < 6);
+	for (const [n] of short) warn(`${n} is shorter than 6 characters, so it isn't masked in output`);
+	const missing = Object.entries(decls).filter(([n, d]) => d.required && isSensitive(d) && !vault?.vars[n]).map(([n]) => n);
+	if (missing.length) warn(`Required secrets not stored: ${missing.join(", ")}. Run \`npx arca setup\`.`);
+	const pkgFile = join(s.packageRoot() ?? project.root, "package.json");
+	if (existsSync(pkgFile)) {
+		s.print(p("bold", "\nScripts"));
+		const scripts = JSON.parse(readFileSync(pkgFile, "utf8")).scripts ?? {};
+		const wrapped = Object.keys(scripts).filter((k) => /\barca\s+run\b/.test(scripts[k]));
+		const unwrapped = Object.entries(scripts).filter(([k, v]) => k !== "start" && !/\barca\s+run\b/.test(v) && KNOWN_TOOLS.has(firstCommand(v) ?? "")).map(([k]) => k);
+		if (wrapped.length) ok(`Wrapped with arca run: ${wrapped.join(", ")}`);
+		else warn("No scripts use `arca run` yet, so nothing gets secrets. Run `npx arca init` to wrap them.");
+		if (unwrapped.length) info(`Not wrapped (no secrets): ${unwrapped.join(", ")}`);
+	}
+	const modeFiles = project.config.envFiles.filter((f) => /^\.env\.(development|production|test)(\.local)?$/.test(f));
+	for (const f of modeFiles) warn(`envFiles lists ${f}. arca injects it as process env, which beats the framework's own mode files (e.g. in \`next build\`). Prefer a name frameworks don't load.`);
+	s.print(p("bold", "\nLeak guard (.env files)"));
+	const files = s.envFilesForGuard();
+	const findings = scanEnvFiles(project, files, vault ? s.secrets(vault) : []);
+	if (files.length === 0) info("No .env files");
+	else if (findings.length === 0) ok(`${plural(files.length, "file")} checked, no secrets found: ${files.map((f) => f.name).join(", ")}`);
+	for (const f of findings) {
+		(f.tracked ? bad : warn)(`${f.detail}${f.tracked ? " (committed to git!)" : ""}`);
+		s.print(`      ${p("dim", fixFor(f))}`);
+		problems++;
+	}
+	const secretPrefixes = new Set(Object.keys(vault?.vars ?? {}).map((n) => n.split("_")[0]));
+	for (const file of files) for (const e of file.entries) {
+		if (!/^https?:\/\//i.test(e.value) || decls[e.key]?.sensitive === true) continue;
+		if (secretPrefixes.has(e.key.split("_")[0]) && !(e.key in (vault?.vars ?? {}))) info(`${e.key} in ${file.name} is a URL next to the secret ${e.key.split("_")[0]}_… If it receives that credential, keep it in arca so only you can change it.`);
+	}
+	if (master) {
+		const policy = s.store.readPolicy(master, project.config.id);
+		s.print(p("bold", "\nAgent policy"));
+		info(policy.agentRun === "scripts" ? "Agents get secrets only through package.json scripts (default)" : "Agents never get secrets (deny)");
+	}
+	s.print("");
+	s.print(problems ? `${p("yellow", `${plural(problems, "issue")} found.`)}` : p("green", "No problems found."));
+	return problems ? 1 : 0;
+}
+function fixFor(f) {
+	if (f.rule === "stored") return `fix: delete the line from ${f.file}, or run: npx arca import ${f.file} --only ${f.key} --delete`;
+	if (f.rule === "declared") return `fix: npx arca import ${f.file} --only ${f.key} --delete   (or declare it "sensitive": false if it's config)`;
+	return `fix: npx arca import ${f.file} --only ${f.key} --delete   (or, if it's not secret, declare it "sensitive": false or add it to leakGuard.ignore)`;
+}
+function osKeychainName(platform) {
+	if (platform === "win32") return "Windows Credential Manager";
+	if (platform === "darwin") return "macOS Keychain";
+	return "Secret Service (GNOME Keyring / KWallet)";
+}
+async function statusCommand(s, version) {
+	const p = s.out;
+	s.print(`${p("bold", "arca")} ${version}: secrets out of your .env files, masked in all output`);
+	if (!s.project) {
+		s.print("\nNo arca.json in this folder or any parent. Get started:  npx arca init");
+		s.print("Commands:  npx arca help");
+		return 0;
+	}
+	s.warnConfig();
+	const project = s.project;
+	const vault = await s.readVault();
+	const missing = rows(s, vault).filter((r) => r.status === "missing").map((r) => r.name);
+	s.print(`\nProject   ${project.config.name} (${project.config.id})`);
+	s.print(`Secrets   ${plural(Object.keys(vault.vars).length, "stored")}${missing.length ? p("red", `, missing: ${missing.join(", ")}`) : ""}`);
+	const policy = await s.policy();
+	s.print(`Agents    ${policy.agentRun === "scripts" ? "package scripts only, output masked" : "denied"}`);
+	s.print(`You       ${s.ctx.agent.detected ? `AI agent (${s.ctx.agent.name} via ${s.ctx.agent.via})` : s.ctx.interactiveOutput ? "interactive terminal" : "non-interactive"}`);
+	s.print(`Store     ${s.store.root}`);
+	s.print(`\n${missing.length ? "Next: npx arca setup" : "Run your app as usual, e.g. npm run dev"}    ·    npx arca help`);
+	return 0;
+}
+async function policyCommand(s, args) {
+	const project = s.requireProject();
+	const [action = "show", key, value] = args;
+	if (action === "show") {
+		const policy = await s.policy();
+		s.print(`agent-run: ${policy.agentRun}`);
+		s.print(s.out("dim", policy.agentRun === "scripts" ? "  Agents get secrets only through verified package.json scripts (default)." : "  Agents never get secrets."));
+		return 0;
+	}
+	if (action !== "set" || key !== "agent-run" || value !== "scripts" && value !== "deny") throw new ArcaError("arca: usage: npx arca policy [show]  |  npx arca policy set agent-run <scripts|deny>", 2);
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: `npx arca policy set agent-run ${value}`
+	});
+	const master = await s.masterKey(true);
+	s.store.writePolicy(master, project.config.id, { agentRun: value });
+	s.note(`${s.err("green", "✔")} agent-run is now ${value} for ${project.config.name}`);
+	return 0;
+}
+async function projectsCommand(s, args) {
+	const [action, id] = args;
+	const reg = s.store.readRegistry();
+	if (!action || action === "list") {
+		const ids = /* @__PURE__ */ new Set([...Object.keys(reg), ...s.store.projectIds()]);
+		if (ids.size === 0) {
+			s.print("No projects on this machine yet.");
+			return 0;
+		}
+		for (const pid of ids) {
+			const e = reg[pid];
+			s.print(`${pid}  ${e?.name ?? "(unknown)"}  ${s.out("dim", e?.roots.join(", ") ?? "")}`);
+		}
+		return 0;
+	}
+	if (action !== "rm" || !id) throw new ArcaError("arca: usage: npx arca projects [list]  |  npx arca projects rm <id>", 2);
+	await humanGate(s.io, s.ctx, {
+		kind: "write",
+		command: `npx arca projects rm ${id}`
+	});
+	if (!reg[id] && !s.store.projectIds().includes(id)) throw new ArcaError(`arca: no project ${id} on this machine.`);
+	if (!await s.io.prompts.confirm(`Delete all secrets of ${reg[id]?.name ?? id} on this machine? This can't be undone.`, false)) throw new ArcaError("arca: cancelled.");
+	s.store.removeProject(id);
+	s.note(`${s.err("green", "✔")} Removed ${id}`);
+	return 0;
+}
+//#endregion
+//#region src/main.ts
+const VERSION = "0.1.0";
+const HELP = `arca: keep secrets out of .env files and out of reach of AI agents
+
+Usage: npx arca <command> [options]    (inside package.json scripts, plain "arca" works)
+
+Everyday
+  run [opts] -- <cmd>     Run a command with the project's secrets injected, output masked
+                          --only A,B      inject only these
+                          --passthrough   run without the store, checking required vars (like CI)
+                          --no-override   let values inherited from the shell win over arca
+  list, ls                Variables and where each one comes from (names only, never values)
+  check [--strict]        Exit 1 if required variables are missing (--strict: also on leak-guard findings)
+  doctor                  Diagnose keychain, project, scripts and .env files
+
+Values (only a person at a terminal)
+  set NAME [--generate]   Store a value (hidden prompt, or piped: … | arca set NAME)
+  setup [--all]           Set every missing required variable, one prompt each
+  unset NAME              Remove a value          restore NAME   Undo the last change
+  reveal NAME             Print a value           export         Print all values (--format dotenv|json|shell, --output file)
+  import [files] [--only A,B] [--include-public] [--delete]
+                          Move secrets from .env files into arca. Files are untouched unless --delete.
+
+Project
+  init [--yes] [--new-id] Set up arca: arca.json, import secrets, wrap scripts, AGENTS.md
+  policy [set agent-run scripts|deny]
+  projects [rm <id>]      Projects with secrets on this machine
+
+Global options: --project-dir <path>, --json, --quiet, --help, --version
+Docs: https://www.npmjs.com/package/@bremmdev/arca-env`;
+const GLOBAL_OPTIONS = {
+	"project-dir": { type: "string" },
+	json: { type: "boolean" },
+	quiet: {
+		type: "boolean",
+		short: "q"
+	},
+	help: {
+		type: "boolean",
+		short: "h"
+	}
+};
+function parse(args, options = {}) {
+	try {
+		const r = parseArgs({
+			args,
+			options: {
+				...GLOBAL_OPTIONS,
+				...options
+			},
+			allowPositionals: true,
+			strict: true
+		});
+		return {
+			values: r.values,
+			positionals: r.positionals
+		};
+	} catch (e) {
+		throw new ArcaError(`arca: ${e.message.replace(/\. To specify a positional.*$/s, "")}\nRun \`npx arca help\` for usage.`, 2);
+	}
+}
+const COMMANDS = [
+	"run",
+	"list",
+	"ls",
+	"check",
+	"doctor",
+	"set",
+	"setup",
+	"unset",
+	"restore",
+	"reveal",
+	"export",
+	"import",
+	"init",
+	"policy",
+	"projects",
+	"help",
+	"version"
+];
+async function main(argv, io) {
+	try {
+		return await dispatch(argv, io);
+	} catch (e) {
+		if (e instanceof ArcaError) {
+			if (e.message) io.stderr.write(e.message + "\n");
+			return e.code;
+		}
+		io.stderr.write(`arca: unexpected error: ${e.stack ?? String(e)}\n`);
+		return 1;
+	}
+}
+async function dispatch(argv, io) {
+	const [command, ...rest] = argv;
+	if (command === "--version" || command === "-v" || command === "version") {
+		io.stdout.write("0.1.0\n");
+		return 0;
+	}
+	if (command === "--help" || command === "-h" || command === "help") {
+		io.stdout.write(HELP + "\n");
+		return 0;
+	}
+	if (command === void 0 || command.startsWith("-") && command !== "--") {
+		const { values } = parse(argv);
+		return statusCommand(session(io, values), VERSION);
+	}
+	if (command === "run" || command === "--") return run(command === "--" ? ["--", ...rest] : rest, io);
+	if (!COMMANDS.includes(command)) {
+		const guess = suggest(command, COMMANDS);
+		throw new ArcaError(`arca: unknown command "${command}".${guess ? ` Did you mean \`npx arca ${guess}\`?` : ""} Run \`npx arca help\`.`, 2);
+	}
+	switch (command) {
+		case "list":
+		case "ls": {
+			const { values } = parse(rest, profileOption);
+			return listCommand(session(io, values));
+		}
+		case "check": {
+			const { values } = parse(rest, {
+				strict: { type: "boolean" },
+				...profileOption
+			});
+			return checkCommand(session(io, values), { strict: Boolean(values.strict) });
+		}
+		case "doctor": {
+			const { values } = parse(rest);
+			return doctorCommand(session(io, values));
+		}
+		case "set": {
+			const { values, positionals } = parse(rest.map((a) => a === "--generate" || a === "-g" ? "--generate=default" : a), {
+				generate: { type: "string" },
+				...profileOption
+			});
+			let generate;
+			if (typeof values.generate === "string") if (values.generate === "default") generate = true;
+			else {
+				generate = Number(values.generate);
+				if (!Number.isInteger(generate) || generate < 8 || generate > 1024) throw new ArcaError("arca: --generate takes a number of bytes from 8 to 1024.", 2);
+			}
+			if (positionals.length > 2) throw new ArcaError("arca: too many arguments. Usage: npx arca set NAME [value]", 2);
+			return setCommand(session(io, values), {
+				name: positionals[0],
+				value: positionals[1],
+				generate
+			});
+		}
+		case "setup": {
+			const { values } = parse(rest, {
+				all: { type: "boolean" },
+				...profileOption
+			});
+			return setupCommand(session(io, values), { all: Boolean(values.all) });
+		}
+		case "unset":
+		case "restore":
+		case "reveal": {
+			const { values, positionals } = parse(rest, {
+				copy: { type: "boolean" },
+				...profileOption
+			});
+			if (values.copy) throw new ArcaError("arca: --copy is not available yet. Use `npx arca reveal NAME` in your terminal.", 2);
+			const s = session(io, values);
+			if (command === "unset") return unsetCommand(s, positionals[0]);
+			if (command === "restore") return restoreCommand(s, positionals[0]);
+			return revealCommand(s, positionals[0]);
+		}
+		case "export": {
+			const { values } = parse(rest, {
+				format: { type: "string" },
+				output: {
+					type: "string",
+					short: "o"
+				},
+				...profileOption
+			});
+			return exportCommand(session(io, values), {
+				format: values.format,
+				output: values.output
+			});
+		}
+		case "import": {
+			const { values, positionals } = parse(rest, {
+				only: { type: "string" },
+				"include-public": { type: "boolean" },
+				delete: { type: "boolean" },
+				yes: {
+					type: "boolean",
+					short: "y"
+				},
+				...profileOption
+			});
+			return importCommand(session(io, values), {
+				files: positionals,
+				only: splitList(values.only),
+				includePublic: Boolean(values["include-public"]),
+				delete: Boolean(values.delete),
+				yes: Boolean(values.yes)
+			});
+		}
+		case "init": {
+			const { values } = parse(rest, {
+				yes: {
+					type: "boolean",
+					short: "y"
+				},
+				"new-id": { type: "boolean" },
+				"no-import": { type: "boolean" }
+			});
+			return initCommand(session(io, values), {
+				yes: Boolean(values.yes),
+				newId: Boolean(values["new-id"]),
+				import: !values["no-import"]
+			});
+		}
+		case "policy": {
+			const { values, positionals } = parse(rest);
+			return policyCommand(session(io, values), positionals);
+		}
+		case "projects": {
+			const { values, positionals } = parse(rest);
+			return projectsCommand(session(io, values), positionals);
+		}
+	}
+	return 2;
+}
+const profileOption = { profile: {
+	type: "string",
+	short: "p"
+} };
+function session(io, values) {
+	if (values.help) {
+		io.stdout.write(HELP + "\n");
+		throw new ArcaError("", 0);
+	}
+	if (values.profile !== void 0) throw new ArcaError("arca: profiles are not available in this version yet. Every command uses the project's single set of values.", 2);
+	const s = new Session(io, { projectDir: values["project-dir"] });
+	s.json = Boolean(values.json);
+	s.quiet = Boolean(values.quiet);
+	return s;
+}
+function splitList(v) {
+	if (typeof v !== "string") return void 0;
+	return v.split(",").map((x) => x.trim()).filter(Boolean);
+}
+/** `arca run [opts] [--] <cmd…>`: arca's options end at `--` or at the first non-option. */
+async function run(args, io) {
+	const own = [];
+	let i = 0;
+	for (; i < args.length; i++) {
+		const a = args[i];
+		if (a === "--") {
+			i++;
+			break;
+		}
+		if (!a.startsWith("-")) break;
+		own.push(a);
+		if (RUN_OPTIONS_WITH_VALUE.has(a) && i + 1 < args.length) own.push(args[++i]);
+	}
+	const command = args.slice(i);
+	const { values } = parse(own, {
+		only: { type: "string" },
+		passthrough: { type: "boolean" },
+		"no-override": { type: "boolean" },
+		...profileOption
+	});
+	return runCommand(session(io, values), {
+		command,
+		only: splitList(values.only),
+		passthrough: Boolean(values.passthrough),
+		noOverride: Boolean(values["no-override"])
+	});
+}
+//#endregion
+export { detectAgent as a, parseEnvEntries as i, main as n, detectCI as o, parseEnv as r, processIO as s, VERSION as t };