glimmervoid 0.30.0 → 0.31.0

package/README.md

@@ -57,7 +57,7 @@ Update a clone with `git pull --ff-only && npm ci && npm run build`, then restar
 - **Claude Code CLI** on PATH, or another supported agent below.
 - **git** on PATH, for per-session worktrees.
 - **Linux only:** `build-essential` and `python3` for node-pty.
-- **Linux only:** `bubblewrap` (`bwrap`) and `socat` for Claude Code's sandbox, which team review, Keep mergeable, workflow sessions and benchmark runs use (`sudo apt install bubblewrap socat`). `glimmervoid doctor` reports both.
+- **Linux only:** `bubblewrap` (`bwrap`), `socat` and `ripgrep` (`rg`) for the sandbox that sandboxed sessions and factory checks run in (`sudo apt install bubblewrap socat ripgrep`). `glimmervoid doctor` reports all three.
 
 ## Supported agents
 

package/dist/bin/glimmervoid.js

@@ -1,15 +1,93 @@
 #!/usr/bin/env node
-import { o as nodePtyRebuildHint, t as probeNodePty } from "../chunks/node-pty-preflight-CK1knGIR.js";
-import { a as packageRoot } from "../chunks/runtime-paths-Ci_ksSkj.js";
-import { t as AGENT_API_VERBS } from "../chunks/session-Cez8aIWg.js";
-import { i as execSync } from "../chunks/child-process-safe-DRGsp0TE.js";
+import { o as nodePtyRebuildHint, r as firstLine, t as probeNodePty } from "../chunks/node-pty-preflight-C8QIlrtU.js";
+import { i as errorText } from "../chunks/text-DoirglWV.js";
+import { a as packageRoot } from "../chunks/runtime-paths-BPoxENmK.js";
+import { t as AGENT_API_VERBS } from "../chunks/session-fc4pFbon.js";
+import { i as execSync } from "../chunks/child-process-safe-Ch-Zgxqs.js";
 import { t as renderTable } from "../chunks/ascii-figure-core-pDAwtlKO.js";
 import { n as glimmervoidHomeDir, t as decideConfigPath } from "../chunks/config-path-core-DFt-TemS.js";
-import { i as sandboxDoctorRows, r as probeSandboxDependencies } from "../chunks/sandbox-deps-Dd5-kZnf.js";
+import { i as sandboxDoctorRows, r as probeSandboxDependencies } from "../chunks/sandbox-deps-BPKE-ylr.js";
 import { i as pnpmGlobalBinDir, n as npmGlobalBinDir, r as onPath, t as formatPathNotice } from "../chunks/path-doctor-C23VAqeu.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+//#region server/core/command-line-core.ts
+var SUBCOMMANDS_HONORING_TRAILING_GLOBAL_OPTIONS = /* @__PURE__ */ new Set([
+	"doctor",
+	"pair",
+	"visions"
+]);
+var SUBCOMMANDS_HONORING_A_LEADING_HELP_OR_VERSION = new Set(AGENT_API_VERBS);
+var OPTIONS_TAKING_A_VALUE = {
+	"--config": "configPath",
+	"--port": "port"
+};
+function scanGlobalOption(argv, index, state) {
+	const token = argv[index];
+	const valueKey = OPTIONS_TAKING_A_VALUE[token];
+	if (valueKey) {
+		const value = argv[index + 1];
+		if (value !== void 0) state[valueKey] = value;
+		return index + 2;
+	}
+	if (token === "--help" || token === "-h") state.wantsHelp = true;
+	if (token === "--version") state.wantsVersion = true;
+	if (token === "--doctor") state.wantsDoctor = true;
+	return index + 1;
+}
+function scanTrailingGlobalOptions(subcommandArgs, state) {
+	let index = 0;
+	while (index < subcommandArgs.length) {
+		if (!subcommandArgs[index].startsWith("-")) {
+			index += 1;
+			continue;
+		}
+		index = scanGlobalOption(subcommandArgs, index, state);
+	}
+}
+function scanLeadingHelpOrVersion(subcommandArgs, state) {
+	const firstArgument = subcommandArgs[0];
+	if (firstArgument === "--help" || firstArgument === "-h") state.wantsHelp = true;
+	if (firstArgument === "--version") state.wantsVersion = true;
+}
+function parseCommandLine(argv) {
+	const state = {
+		configPath: null,
+		port: null,
+		wantsHelp: false,
+		wantsVersion: false,
+		wantsDoctor: false
+	};
+	let index = 0;
+	while (index < argv.length && argv[index].startsWith("-")) index = scanGlobalOption(argv, index, state);
+	const name = argv[index];
+	const subcommandArgs = argv.slice(index + 1);
+	if (name !== void 0 && SUBCOMMANDS_HONORING_TRAILING_GLOBAL_OPTIONS.has(name)) scanTrailingGlobalOptions(subcommandArgs, state);
+	if (name !== void 0 && SUBCOMMANDS_HONORING_A_LEADING_HELP_OR_VERSION.has(name)) scanLeadingHelpOrVersion(subcommandArgs, state);
+	if (state.wantsHelp) return { kind: "help" };
+	if (state.wantsVersion) return { kind: "version" };
+	const globalOptions = {
+		configPath: state.configPath,
+		port: state.port
+	};
+	if (state.wantsDoctor) return {
+		kind: "subcommand",
+		name: "doctor",
+		subcommandArgs: [],
+		globalOptions
+	};
+	if (name === void 0) return {
+		kind: "server",
+		globalOptions
+	};
+	return {
+		kind: "subcommand",
+		name,
+		subcommandArgs,
+		globalOptions
+	};
+}
+//#endregion
 //#region bin/glimmervoid.ts
 var args = process.argv.slice(2);
 var pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
@@ -28,6 +106,7 @@ Commands:
   spawn <prompt>    From inside a Glimmervoid session, start a sibling session on that prompt
   attention <note>  From inside a Glimmervoid session, flag it as needing the operator
   board             From inside a Glimmervoid session, list the live sessions
+  kg [command]      Experimental typed knowledge and task graph (Settings > Lanes > Knowledge graph)
 
 Options:
   --name <label>    Label for the device being paired (with: pair)
@@ -35,71 +114,75 @@ Options:
   --config <path>   Path to config file (default: ~/.glimmervoid/config.json)
   --version         Show version number
   --help, -h        Show this help message`;
-if (args.includes("--help") || args.includes("-h")) {
+var commandLine = parseCommandLine(args);
+if (commandLine.kind === "help") {
 	console.log(USAGE);
 	process.exit(0);
 }
-if (args.includes("--version")) {
+if (commandLine.kind === "version") {
 	console.log(pkg.version);
 	process.exit(0);
 }
-function getArgValue(flag) {
-	const idx = args.indexOf(flag);
-	if (idx !== -1 && idx + 1 < args.length) return args[idx + 1];
-	return null;
-}
-var configArg = getArgValue("--config");
-if (configArg) process.env.GLIMMERVOID_CONFIG = configArg;
-var portArg = getArgValue("--port");
-if (portArg) process.env.GLIMMERVOID_PORT = portArg;
+if (commandLine.globalOptions.configPath) process.env.GLIMMERVOID_CONFIG = commandLine.globalOptions.configPath;
+if (commandLine.globalOptions.port) process.env.GLIMMERVOID_PORT = commandLine.globalOptions.port;
 var SUBCOMMAND_RUNNERS = new Map([
 	["doctor", async () => {
 		await runDoctor();
 		return 0;
 	}],
-	["pair", async (commandArgs) => {
-		const { runPairCli } = await import("../chunks/pair-cli-w-gCAF-1.js");
-		return runPairCli(commandArgs.slice(1));
+	["pair", async (subcommandArgs) => {
+		const { runPairCli } = await import("../chunks/pair-cli-BbCBfd6l.js");
+		return runPairCli(subcommandArgs);
+	}],
+	["agent", async (subcommandArgs) => {
+		const { runAgentSetupCli } = await import("../chunks/agent-setup-cli-CiJSDWSo.js");
+		return runAgentSetupCli(subcommandArgs);
 	}],
-	["agent", async (commandArgs) => {
-		const { runAgentSetupCli } = await import("../chunks/agent-setup-cli-B5Atxr3F.js");
-		return runAgentSetupCli(commandArgs.slice(1));
+	["kg", async (subcommandArgs) => {
+		const { runKnowledgeGraphCommand } = await import("../chunks/knowledge-graph-cli-D2tt5hPn.js");
+		return runKnowledgeGraphCommand(subcommandArgs);
 	}],
-	["visions", async (commandArgs) => {
-		const { runVisionsCli } = await import("../chunks/visions-cli-BXQFIBCX.js");
-		return runVisionsCli(commandArgs.slice(1));
+	["visions", async (subcommandArgs) => {
+		const { runVisionsCli } = await import("../chunks/visions-cli-CT5rjiwf.js");
+		return runVisionsCli(subcommandArgs);
 	}],
-	...AGENT_API_VERBS.map((verb) => [verb, async (commandArgs) => {
-		const { runAgentApiCli } = await import("../chunks/agent-api-cli-D0MmtEdz.js");
-		return runAgentApiCli(commandArgs);
+	...AGENT_API_VERBS.map((verb) => [verb, async (subcommandArgs, subcommandName) => {
+		const { runAgentApiCli } = await import("../chunks/agent-api-cli-DAA7Jx8N.js");
+		return runAgentApiCli([subcommandName, ...subcommandArgs]);
 	}])
 ]);
+function flushStream(stream) {
+	return new Promise((resolve) => {
+		stream.once("error", () => resolve());
+		stream.write("", () => resolve());
+	});
+}
+async function exitAfterOutputDrains(exitCode) {
+	await Promise.all([flushStream(process.stdout), flushStream(process.stderr)]);
+	process.exit(exitCode);
+}
+async function runSubcommandToExitCode(runSubcommand, subcommandArgs, subcommandName) {
+	try {
+		return await runSubcommand(subcommandArgs, subcommandName);
+	} catch (err) {
+		console.error(errorText(err));
+		return 1;
+	}
+}
 async function dispatchCommandLine() {
-	const requestedSubcommand = args.includes("--doctor") ? "doctor" : args[0];
-	if (!requestedSubcommand || requestedSubcommand.startsWith("-")) {
+	if (commandLine.kind !== "subcommand") {
 		await import("../server/index.js");
 		return;
 	}
-	const runSubcommand = SUBCOMMAND_RUNNERS.get(requestedSubcommand);
+	const runSubcommand = SUBCOMMAND_RUNNERS.get(commandLine.name);
 	if (!runSubcommand) {
-		console.error(`Unknown command: ${requestedSubcommand}\n${USAGE}`);
-		process.exit(1);
-	}
-	try {
-		process.exit(await runSubcommand(args));
-	} catch (err) {
-		console.error(messageOf(err));
-		process.exit(1);
+		console.error(`Unknown command: ${commandLine.name}\n${USAGE}`);
+		await exitAfterOutputDrains(1);
+		return;
 	}
+	await exitAfterOutputDrains(await runSubcommandToExitCode(runSubcommand, commandLine.subcommandArgs, commandLine.name));
 }
 await dispatchCommandLine();
-function messageOf(error) {
-	if (error instanceof Error && error.message) return error.message;
-	return String(error);
-}
-function firstLineOf(error) {
-	return messageOf(error).split("\n")[0];
-}
 function decideReadOnlyConfigPath() {
 	return decideConfigPath({
 		env: process.env,
@@ -118,7 +201,7 @@ async function readDeclaredCustomAgents() {
 		declared: [],
 		error: null
 	};
-	const { loadConfigFile } = await import("../chunks/config-store-CC8T3okC.js");
+	const { loadConfigFile } = await import("../chunks/config-store-DbBp7LJZ.js");
 	try {
 		const loaded = loadConfigFile(decided.path, { exitOnError: false });
 		if (!loaded.config) return {
@@ -132,7 +215,7 @@ async function readDeclaredCustomAgents() {
 	} catch (err) {
 		return {
 			declared: [],
-			error: `could not read ${decided.path}: ${firstLineOf(err)}`
+			error: `could not read ${decided.path}: ${firstLine(errorText(err))}`
 		};
 	}
 }
@@ -194,7 +277,7 @@ async function runDoctor() {
 	}
 	switchSection("Agents");
 	try {
-		const { listAgentIds, describeAgentResolvability, setCustomAgents } = await import("../chunks/adapters-Dho1VSY5.js");
+		const { listAgentIds, describeAgentResolvability, setCustomAgents } = await import("../chunks/adapters-ClA_GbtA.js");
 		const declaredCustomAgents = await readDeclaredCustomAgents();
 		if (declaredCustomAgents.error) line("config", declaredCustomAgents.error);
 		setCustomAgents(declaredCustomAgents.declared);
@@ -202,24 +285,24 @@ async function runDoctor() {
 			const { label, path: resolvedPath } = describeAgentResolvability(id);
 			line(`${id} (${label})`, resolvedPath ?? "not found on PATH");
 		}
-		const { inspectGrokAgentSetup } = await import("../chunks/agent-setup-cli-B5Atxr3F.js");
+		const { inspectGrokAgentSetup } = await import("../chunks/agent-setup-cli-CiJSDWSo.js");
 		const grokSetup = inspectGrokAgentSetup();
 		line("grok hook setup", `${grokSetup.classification}: ${grokSetup.filePath}`);
 	} catch (err) {
-		line("agents", `probe failed: ${firstLineOf(err)}`);
+		line("agents", `probe failed: ${firstLine(errorText(err))}`);
 	}
 	switchSection("rtk");
 	try {
-		const { getRtkPath } = await import("../chunks/rtk-resolver-CMQAidlI.js");
+		const { getRtkPath } = await import("../chunks/rtk-resolver-D4Nke1Fr.js");
 		line("rtk", getRtkPath() || "not installed (Glimmervoid installs it when the rtk setting is on)");
 	} catch (err) {
-		line("rtk", `probe failed: ${firstLineOf(err)}`);
+		line("rtk", `probe failed: ${firstLine(errorText(err))}`);
 	}
 	switchSection("Sane YOLO");
 	try {
-		const { resolvePackageBin } = await import("../chunks/runtime-paths-JLrZ3wyi.js");
-		const { execFileSync } = await import("../chunks/child-process-safe-DvQjXsgz.js");
-		const { inspectGrokAgentSetup } = await import("../chunks/agent-setup-cli-B5Atxr3F.js");
+		const { resolvePackageBin } = await import("../chunks/runtime-paths-DU5jBEEO.js");
+		const { execFileSync } = await import("../chunks/child-process-safe-BKPZ-5qQ.js");
+		const { inspectGrokAgentSetup } = await import("../chunks/agent-setup-cli-CiJSDWSo.js");
 		const binPath = resolvePackageBin("cc-safety-net", "cc-safety-net");
 		line("Sane YOLO", binPath || "not installed");
 		if (binPath) line("cc-safety-net version", execFileSync(process.execPath, [binPath, "--version"], {
@@ -229,7 +312,7 @@ async function runDoctor() {
 		line("Codex hook trust", "Sane YOLO is inactive unless Codex trusts the injected hooks.");
 		line("Grok Sane YOLO", inspectGrokAgentSetup().saneYoloReady ? "installed" : "inactive; run glimmervoid agent setup grok");
 	} catch (err) {
-		line("Sane YOLO", `probe failed: ${firstLineOf(err)}`);
+		line("Sane YOLO", `probe failed: ${firstLine(errorText(err))}`);
 	}
 	switchSection("Native module");
 	const nodePty = await probeNodePty();

package/dist/chunks/{adapters-Dho1VSY5.js → adapters-ClA_GbtA.js}

@@ -1,2 +1,2 @@
-import { a as describeAgentResolvability, d as setCustomAgents, l as listAgentIds } from "./adapters-zPDx1Xox.js";
+import { a as describeAgentResolvability, d as setCustomAgents, l as listAgentIds } from "./adapters-gn7ulNO4.js";
 export { describeAgentResolvability, listAgentIds, setCustomAgents };

package/dist/chunks/{adapters-zPDx1Xox.js → adapters-gn7ulNO4.js}

@@ -1,11 +1,12 @@
-import { o as relayPath } from "./runtime-paths-Ci_ksSkj.js";
-import { _ as toolDetailFieldValue, c as PendingPromptQuestion, g as firstDetailLine, o as PROMPT_DETAIL_HIDDEN_CHARACTERS } from "./session-Cez8aIWg.js";
-import { r as execFileSync } from "./child-process-safe-DRGsp0TE.js";
+import { o as relayPath } from "./runtime-paths-BPoxENmK.js";
+import { _ as firstDetailLine, l as PendingPromptQuestion, s as PROMPT_DETAIL_HIDDEN_CHARACTERS, v as toolDetailFieldValue } from "./session-fc4pFbon.js";
+import { r as execFileSync } from "./child-process-safe-Ch-Zgxqs.js";
 import { n as resolveAgentCommand, t as buildAgentSpawnCommand } from "./spawn-command-Cc40FiZI.js";
-import { i as isSpinnerChar, n as classifyAgentTitle, r as isBrailleChar, s as buildAgentEnv, t as grok } from "./grok-DuU8xVLZ.js";
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+import { c as buildAgentEnv, i as isSpinnerChar, n as classifyAgentTitle, r as isBrailleChar, t as grok } from "./grok-CXKeSt2z.js";
 import { t as buildHookCommand } from "./hook-command-core-DclEoE9e.js";
-import "./contracts-DGkKNh9W.js";
-import { n as mergeCodexPreToolUse, t as HOOK_TOOLS } from "./hook-tools-pSJia7ks.js";
+import "./contracts-3LkrilQX.js";
+import { n as mergeCodexPreToolUse, t as HOOK_TOOLS } from "./hook-tools-UX2fmt81.js";
 import fs from "node:fs";
 //#region session/core/anti-slop-prompt.ts
 var ANTI_SLOP_NOTE = [
@@ -87,9 +88,6 @@ function mapHookPromptDetail(event, payload) {
 		question: answerableQuestionOf(toolName, payload?.tool_input)
 	};
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function answerableQuestionOf(toolName, toolInput) {
 	if (toolName !== "AskUserQuestion" || !isRecord(toolInput)) return null;
 	const questions = toolInput.questions;
@@ -123,6 +121,8 @@ function isWholeBashCommandShown(toolName, toolInput, fieldValue, summary) {
 function mapHookToSignal$1(event, payload) {
 	switch (String(event || "").toLowerCase()) {
 		case "sessionstart": return "session-start";
+		case "precompact": return "compaction-start";
+		case "postcompact": return "compaction-end";
 		case "sessionend": return "session-end";
 		case "userpromptsubmit": return "resume";
 		case "stop": return "ready";
@@ -178,7 +178,15 @@ var settingsArgs = (settingsPath) => ["--settings", settingsPath];
 function buildArgs$1({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], antiSlopPrompt = false, initialPrompt = null } = {}) {
 	const args = dangerouslySkipPermissions ? ["--dangerously-skip-permissions"] : [];
 	if (resumeSessionId) args.push("--resume", resumeSessionId);
-	if (extraArgs.length > 0) args.push(...extraArgs);
+	for (let index = 0; index < extraArgs.length; index += 1) {
+		const argument = extraArgs[index];
+		if (resumeSessionId && argument === "--session-id") {
+			index += 1;
+			continue;
+		}
+		if (resumeSessionId && argument.startsWith("--session-id=")) continue;
+		args.push(argument);
+	}
 	args.push(...buildAntiSlopArgs(antiSlopPrompt));
 	if (initialPrompt != null) args.push(initialPrompt);
 	return args;
@@ -344,10 +352,22 @@ var SKIP_PERMISSIONS_ARGS = [
 	"-s",
 	"workspace-write"
 ];
-function buildArgs({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], initialPrompt = null } = {}) {
+var OUTER_SANDBOX_ARGS = ["-s", "danger-full-access"];
+var OUTER_SANDBOX_SKIP_PERMISSIONS_ARGS = [
+	"-a",
+	"never",
+	...OUTER_SANDBOX_ARGS
+];
+function permissionArgs(dangerouslySkipPermissions, hasOuterSandbox) {
+	if (hasOuterSandbox && dangerouslySkipPermissions) return OUTER_SANDBOX_SKIP_PERMISSIONS_ARGS;
+	if (hasOuterSandbox) return OUTER_SANDBOX_ARGS;
+	if (dangerouslySkipPermissions) return SKIP_PERMISSIONS_ARGS;
+	return [];
+}
+function buildArgs({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], initialPrompt = null, hasOuterSandbox = false } = {}) {
 	const args = [...UPDATE_CHECK_ARGS];
 	if (resumeSessionId) args.push("resume", resumeSessionId);
-	if (dangerouslySkipPermissions) args.push(...SKIP_PERMISSIONS_ARGS);
+	args.push(...permissionArgs(dangerouslySkipPermissions, hasOuterSandbox));
 	if (extraArgs.length > 0) args.push(...extraArgs);
 	if (initialPrompt != null) args.push(initialPrompt);
 	return args;

package/dist/chunks/agent-api-cli-DAA7Jx8N.js

@@ -0,0 +1,135 @@
+import { t as errorCode } from "./text-DoirglWV.js";
+import { a as AgentDispatchRequest, n as AGENT_URL_ENV } from "./session-fc4pFbon.js";
+import { i as resolveHookTarget } from "./hook-relay-core-DA_bz2KA.js";
+import { n as decideSandboxProxy } from "./sandbox-proxy-core-hnQgKR0T.js";
+import { a as isAgentApiVerb } from "./agent-api-core-hVcT26JW.js";
+import http from "node:http";
+//#region server/agent-api-cli.ts
+var AGENT_PATH_PREFIX = "/agent/";
+var BODY_BUILDERS = {
+	spawn: (rest) => {
+		const prompt = rest.join(" ").trim();
+		return prompt ? { prompt } : null;
+	},
+	attention: (rest) => {
+		const note = rest.join(" ").trim();
+		return note ? { note } : null;
+	},
+	board: () => ({}),
+	dispatch: (rest) => {
+		const parsed = AgentDispatchRequest.safeParse(rest[0] === "--ready" ? { readyIntent: rest[1] } : { workId: rest[0] });
+		return parsed.success ? parsed.data : null;
+	}
+};
+function bodySaysOk(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null && parsed.ok === true;
+	} catch {
+		return false;
+	}
+}
+function verbEndpoint(rawUrl, verb) {
+	const target = resolveHookTarget(rawUrl, verb, AGENT_PATH_PREFIX);
+	if (!target.url) return { ok: false };
+	const endpoint = new URL(target.url);
+	const token = endpoint.searchParams.get("t") || "";
+	endpoint.search = "";
+	return {
+		ok: true,
+		endpoint,
+		token
+	};
+}
+async function postDirectly(endpoint, headers, bodyText) {
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers,
+		body: bodyText
+	});
+	return {
+		hasSuccessStatus: response.ok,
+		text: await response.text()
+	};
+}
+function postThroughSandboxProxy(sandboxProxy, endpoint, headers, bodyText) {
+	const proxyHeaders = sandboxProxy.authorization ? { "proxy-authorization": sandboxProxy.authorization } : {};
+	return new Promise((resolve, reject) => {
+		const request = http.request({
+			host: sandboxProxy.hostname,
+			port: sandboxProxy.port,
+			method: "POST",
+			path: endpoint.href,
+			headers: {
+				...headers,
+				...proxyHeaders,
+				host: endpoint.host,
+				"content-length": String(Buffer.byteLength(bodyText))
+			}
+		}, (response) => {
+			const chunks = [];
+			response.on("data", (chunk) => {
+				chunks.push(chunk);
+			});
+			response.on("error", reject);
+			response.on("end", () => {
+				const statusCode = response.statusCode ?? 0;
+				resolve({
+					hasSuccessStatus: statusCode >= 200 && statusCode < 300,
+					text: Buffer.concat(chunks).toString("utf8")
+				});
+			});
+		});
+		request.on("error", reject);
+		request.end(bodyText);
+	});
+}
+function wasConnectionRefused(error) {
+	return errorCode(error?.cause) === "ECONNREFUSED";
+}
+async function postToAgentIngress(endpoint, token, body) {
+	const headers = {
+		"content-type": "application/json",
+		authorization: `Bearer ${token}`
+	};
+	const bodyText = JSON.stringify(body);
+	try {
+		return await postDirectly(endpoint, headers, bodyText);
+	} catch (error) {
+		if (!wasConnectionRefused(error)) throw error;
+		const sandboxProxy = decideSandboxProxy(process.env);
+		if (!sandboxProxy) throw error;
+		return postThroughSandboxProxy(sandboxProxy, endpoint, headers, bodyText);
+	}
+}
+async function runAgentApiCli(args) {
+	const verb = args[0];
+	if (!verb || !isAgentApiVerb(verb)) {
+		console.error(`glimmervoid: ${verb || "that"} is not an agent command`);
+		return 1;
+	}
+	const body = BODY_BUILDERS[verb](args.slice(1));
+	if (!body) {
+		if (verb === "dispatch") {
+			console.error("glimmervoid dispatch: expected a work id matching wrk-[0-9a-f]{16}");
+			return 1;
+		}
+		console.error(`glimmervoid ${verb}: this command needs text, for example "glimmervoid ${verb} check the failing test"`);
+		return 1;
+	}
+	const rawUrl = process.env[AGENT_URL_ENV];
+	if (!rawUrl) {
+		console.error(`glimmervoid: ${AGENT_URL_ENV} is not set, so this is not a Glimmervoid session with the agent API turned on`);
+		return 1;
+	}
+	const target = verbEndpoint(rawUrl, verb);
+	if (!target.ok) {
+		console.error(`glimmervoid: ${AGENT_URL_ENV} must be a loopback http url under ${AGENT_PATH_PREFIX}, so nothing was sent`);
+		return 1;
+	}
+	const reply = await postToAgentIngress(target.endpoint, target.token, body);
+	console.log(reply.text);
+	return reply.hasSuccessStatus && bodySaysOk(reply.text) ? 0 : 1;
+}
+//#endregion
+export { runAgentApiCli };

package/dist/chunks/{agent-api-core-Dz0r21y9.js → agent-api-core-hVcT26JW.js}

@@ -1,4 +1,4 @@
-import { a as AgentSpawnRequest, i as AgentAttentionRequest, t as AGENT_API_VERBS } from "./session-Cez8aIWg.js";
+import { a as AgentDispatchRequest, i as AgentAttentionRequest, o as AgentSpawnRequest, t as AGENT_API_VERBS } from "./session-fc4pFbon.js";
 import crypto from "node:crypto";
 var MAX_SPAWNS_IN_FLIGHT = 1;
 var SPAWNABLE_DEPTH = 0;
@@ -67,6 +67,15 @@ function parseAgentVerb(verb, payload) {
 		status: 404,
 		error: REFUSAL_REASON
 	};
+	if (verb === "dispatch") {
+		const parsed = AgentDispatchRequest.safeParse(payload);
+		if (!parsed.success) return refuseInvalidBody(parsed.error.issues);
+		return {
+			ok: true,
+			verb,
+			request: parsed.data
+		};
+	}
 	if (verb === "board") return {
 		ok: true,
 		verb

package/dist/chunks/{agent-setup-cli-B5Atxr3F.js → agent-setup-cli-CiJSDWSo.js}

@@ -1,16 +1,10 @@
-import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-DuU8xVLZ.js";
+import { a as isMissingFileError, r as errorMessage } from "./text-DoirglWV.js";
+import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-CXKeSt2z.js";
+import { p as writeTextAtomicSync } from "./json-file-oEH9vt-0.js";
 import fs from "node:fs";
 import path from "node:path";
-import crypto from "node:crypto";
 //#region server/agent-setup-cli.ts
 var USAGE = "Usage: glimmervoid agent setup grok";
-function errorCode(error) {
-	const code = error?.code;
-	return typeof code === "string" ? code : void 0;
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 function setupInputs(env = process.env) {
 	return {
 		filePath: grok.hooksFilePath(env),
@@ -26,7 +20,7 @@ function inspectGrokAgentSetup({ env = process.env, readFileSync = fs.readFileSy
 	try {
 		contents = readFileSync(inputs.filePath, "utf8");
 	} catch (error) {
-		if (errorCode(error) === "ENOENT") return {
+		if (isMissingFileError(error, { includeNotDir: false })) return {
 			filePath: inputs.filePath,
 			classification: "absent"
 		};
@@ -59,7 +53,7 @@ function ensureWritableHooksDirectory(directory, fileSystem) {
 			assertRealDirectory(currentDirectory, fileSystem);
 			continue;
 		} catch (directoryError) {
-			if (errorCode(directoryError) !== "ENOENT") throw directoryError;
+			if (!isMissingFileError(directoryError, { includeNotDir: false })) throw directoryError;
 		}
 		fileSystem.mkdirSync(currentDirectory, { mode: 448 });
 		assertRealDirectory(currentDirectory, fileSystem);
@@ -69,23 +63,12 @@ function ensureWritableHooksDirectory(directory, fileSystem) {
 	} catch {}
 }
 function replaceFileAtomically(filePath, contents, fileSystem) {
-	const temporaryPath = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString("hex")}.tmp`;
-	try {
-		fileSystem.writeFileSync(temporaryPath, contents, {
-			encoding: "utf8",
-			mode: 384,
-			flag: "wx"
-		});
-		fileSystem.renameSync(temporaryPath, filePath);
-	} catch (writeError) {
-		try {
-			fileSystem.rmSync(temporaryPath, { force: true });
-		} catch {}
-		throw writeError;
-	}
-	try {
-		fileSystem.chmodSync(filePath, 384);
-	} catch {}
+	writeTextAtomicSync(filePath, contents, {
+		mode: 384,
+		exclusive: true,
+		enforceMode: true,
+		fsSync: fileSystem
+	});
 }
 function runGrokSetup({ env, fileSystem, log, error }) {
 	const inputs = setupInputs(env);

package/dist/chunks/backoff-DjVpfHk7.js

@@ -0,0 +1,14 @@
+//#region shared/backoff.ts
+var DEFAULT_BASE_MS = 6e4;
+var DEFAULT_MAX_MS = 18e5;
+var MAX_DOUBLING_ATTEMPT = 20;
+function nextBackoffMs({ attempt = 1, baseMs = DEFAULT_BASE_MS, maxMs = DEFAULT_MAX_MS, retryAfterMs = null, random = Math.random, jitter = "full" } = {}) {
+	if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) return Math.min(retryAfterMs, maxMs);
+	const exponent = Math.max(0, Math.min(attempt, MAX_DOUBLING_ATTEMPT) - 1);
+	const ceiling = Math.min(maxMs, baseMs * 2 ** exponent);
+	if (jitter === "none") return ceiling;
+	if (jitter === "half") return Math.round(ceiling * (.5 + .5 * random()));
+	return Math.round(random() * ceiling);
+}
+//#endregion
+export { DEFAULT_MAX_MS as n, nextBackoffMs as r, DEFAULT_BASE_MS as t };

package/dist/chunks/child-process-safe-BKPZ-5qQ.js

@@ -0,0 +1,2 @@
+import { r as execFileSync } from "./child-process-safe-Ch-Zgxqs.js";
+export { execFileSync };

package/dist/chunks/coerce-NSst8oRP.js

@@ -0,0 +1,32 @@
+//#region shared/coerce.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textOr(value, fallback) {
+	return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function rawTextOr(value, fallback) {
+	return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function numberOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function positiveNumberOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function nonNegativeIntOr(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return fallback;
+	return Math.floor(value);
+}
+function coercedNumberOr(value, fallback) {
+	const number = Number(value);
+	if (!Number.isFinite(number)) return fallback;
+	return number;
+}
+function positiveIntOr(value, fallback) {
+	const number = Number(value);
+	if (!Number.isFinite(number) || number <= 0) return fallback;
+	return Math.floor(number);
+}
+//#endregion
+export { positiveIntOr as a, textOr as c, numberOr as i, isRecord as n, positiveNumberOr as o, nonNegativeIntOr as r, rawTextOr as s, coercedNumberOr as t };