glimmervoid 0.30.0 → 0.32.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,94 @@
 #!/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-B8fJb_Or.js";
+import { i as execSync } from "../chunks/child-process-safe-DDELk9XC.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-DuaNFq7n.js";
+import { r as gitDoctorRows, t as probeGitVersion } from "../chunks/git-version-CrLW4a6r.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 +107,8 @@ 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
+  push              From inside a Glimmervoid session, land its commits on the integration branch and push it
+  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 +116,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-CKn-wUw9.js");
+		return runPairCli(subcommandArgs);
+	}],
+	["agent", async (subcommandArgs) => {
+		const { runAgentSetupCli } = await import("../chunks/agent-setup-cli-D4956BfN.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-Bjy9_kv5.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-BhFdym5n.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-V_BkYhBI.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 +203,7 @@ async function readDeclaredCustomAgents() {
 		declared: [],
 		error: null
 	};
-	const { loadConfigFile } = await import("../chunks/config-store-CC8T3okC.js");
+	const { loadConfigFile } = await import("../chunks/config-store-Cp62jN1O.js");
 	try {
 		const loaded = loadConfigFile(decided.path, { exitOnError: false });
 		if (!loaded.config) return {
@@ -132,7 +217,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 +279,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-BU74M4QZ.js");
 		const declaredCustomAgents = await readDeclaredCustomAgents();
 		if (declaredCustomAgents.error) line("config", declaredCustomAgents.error);
 		setCustomAgents(declaredCustomAgents.declared);
@@ -202,24 +287,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-D4956BfN.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-CIVLE_xk.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-B3zcPdFM.js");
+		const { inspectGrokAgentSetup } = await import("../chunks/agent-setup-cli-D4956BfN.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 +314,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();
@@ -244,6 +329,8 @@ async function runDoctor() {
 		platform,
 		exec: execSync
 	}))) line(label, value);
+	switchSection("Git");
+	for (const [label, value] of gitDoctorRows(probeGitVersion())) line(label, value);
 	switchSection("Config");
 	line("resolved config", resolveConfigPathReadOnly());
 	flush();

package/dist/chunks/{adapters-Dho1VSY5.js → adapters-BU74M4QZ.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-CoC18rdt.js";
 export { describeAgentResolvability, listAgentIds, setCustomAgents };

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

@@ -1,26 +1,13 @@
-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 { b as toolDetailFieldValue, d as PendingPromptQuestion, l as PROMPT_DETAIL_HIDDEN_CHARACTERS, y as firstDetailLine } from "./session-B8fJb_Or.js";
+import { r as execFileSync } from "./child-process-safe-DDELk9XC.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-C4lzPFEg.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-DXujp-Zn.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 = [
-	"Code hygiene for this session:",
-	"Write comments only to explain why, never narration that restates the code (no Now-we, This-function, or Step-1 openers).",
-	"Do not leave debug statements (console.log, print, debugger) in committed code.",
-	"Never swallow exceptions: no empty catch blocks and no catch that only logs and continues.",
-	"No placeholder stubs or in-a-real-implementation hand-waving; implement the real thing or stop and ask.",
-	"Do not silence type or lint errors with as-any, ts-ignore, or eslint-disable; fix the cause.",
-	"Avoid speculative wrappers and single-use indirection. Prefer deleting code over adding it."
-].join(" ");
-function buildAntiSlopArgs(enabled) {
-	return enabled ? ["--append-system-prompt", ANTI_SLOP_NOTE] : [];
-}
-//#endregion
 //#region session/adapters/claude-code.ts
 var ID$1 = "claude-code";
 var COMMAND_NAME$1 = "claude";
@@ -87,9 +74,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 +107,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";
@@ -175,11 +161,40 @@ function buildEnv$1(baseEnv, extraEnv, options) {
 	return buildAgentEnv(baseEnv, extraEnv, envProfile$2, options);
 }
 var settingsArgs = (settingsPath) => ["--settings", settingsPath];
-function buildArgs$1({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], antiSlopPrompt = false, initialPrompt = null } = {}) {
+var SESSION_ID_FLAG = "--session-id";
+function requestedSessionId(extraArgs) {
+	const flagIndex = extraArgs.indexOf(SESSION_ID_FLAG);
+	if (flagIndex !== -1) return extraArgs[flagIndex + 1] ?? null;
+	const assignment = extraArgs.find((argument) => argument.startsWith(`${SESSION_ID_FLAG}=`));
+	return assignment ? assignment.slice(13) : null;
+}
+function launchSessionId({ resumeSessionId, extraArgs, generatedId }) {
+	const knownSessionId = resumeSessionId ?? requestedSessionId(extraArgs);
+	if (knownSessionId) return {
+		agentSessionId: knownSessionId,
+		extraArgs: [...extraArgs]
+	};
+	return {
+		agentSessionId: generatedId,
+		extraArgs: [
+			...extraArgs,
+			SESSION_ID_FLAG,
+			generatedId
+		]
+	};
+}
+function buildArgs$1({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], initialPrompt = null } = {}) {
 	const args = dangerouslySkipPermissions ? ["--dangerously-skip-permissions"] : [];
 	if (resumeSessionId) args.push("--resume", resumeSessionId);
-	if (extraArgs.length > 0) args.push(...extraArgs);
-	args.push(...buildAntiSlopArgs(antiSlopPrompt));
+	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);
+	}
 	if (initialPrompt != null) args.push(initialPrompt);
 	return args;
 }
@@ -196,6 +211,7 @@ var claudeCode = {
 	buildEnv: buildEnv$1,
 	buildArgs: buildArgs$1,
 	settingsArgs,
+	launchSessionId,
 	capabilities: {
 		hooks: true,
 		awaitingInput: true,
@@ -204,7 +220,6 @@ var claudeCode = {
 		statusLine: true,
 		rtk: true,
 		saneYolo: true,
-		antiSlop: true,
 		compactQuiet: true,
 		skipPermissionsFlag: true,
 		headless: true
@@ -344,10 +359,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;
@@ -387,7 +414,6 @@ var codex = {
 		statusLine: false,
 		rtk: true,
 		saneYolo: true,
-		antiSlop: false,
 		compactQuiet: false,
 		skipPermissionsFlag: true,
 		headless: true
@@ -407,7 +433,6 @@ var TITLE_ONLY_CAPABILITIES = Object.freeze({
 	statusLine: false,
 	rtk: false,
 	saneYolo: false,
-	antiSlop: false,
 	compactQuiet: false,
 	skipPermissionsFlag: false,
 	headless: false

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

@@ -0,0 +1,142 @@
+import { t as errorCode } from "./text-DoirglWV.js";
+import { a as AgentDispatchRequest, n as AGENT_URL_ENV, s as AgentTicketRequest } from "./session-B8fJb_Or.js";
+import { i as resolveHookTarget } from "./hook-relay-core-DA_bz2KA.js";
+import { n as decideSandboxProxy } from "./sandbox-proxy-core-hnQgKR0T.js";
+import { c as isAgentApiVerb, l as isOrchestratorAgentVerb } from "./agent-api-core-B3YI8SYs.js";
+import http from "node:http";
+//#region server/agent-api-cli.ts
+var AGENT_PATH_PREFIX = "/agent/";
+function ticketBody(rest) {
+	const parsed = AgentTicketRequest.safeParse({ workId: rest[0] });
+	return parsed.success ? parsed.data : null;
+}
+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: () => ({}),
+	push: () => ({}),
+	dispatch: (rest) => {
+		const parsed = AgentDispatchRequest.safeParse(rest[0] === "--ready" ? { readyIntent: rest[1] } : { workId: rest[0] });
+		return parsed.success ? parsed.data : null;
+	},
+	reopen: (rest) => ticketBody(rest),
+	cancel: (rest) => ticketBody(rest)
+};
+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 (isOrchestratorAgentVerb(verb)) {
+			console.error(`glimmervoid ${verb}: 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 };