@nail00749/agent-gvozd 0.1.8 → 0.2.1

package/dist/cli.js

@@ -988,6 +988,7 @@ var i = `${styleText("gray", S_BAR)}  `;
 
 // src/cli.ts
 import { realpathSync as realpathSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/config.ts
@@ -7229,8 +7230,8 @@ function loadConfig(projectDirectory, options = {}) {
 }
 
 // src/cli/doctor.ts
-import { existsSync as existsSync3, lstatSync as lstatSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "node:fs";
-import { join as join4, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync3, lstatSync as lstatSync3, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "node:fs";
+import { join as join5, resolve as resolve4 } from "node:path";
 
 // src/tool-permissions.ts
 function family(command, ...variants) {
@@ -7336,9 +7337,9 @@ function buildAgentPermissions(agent, mcpServers) {
 
 // src/release-metadata.ts
 var PACKAGE_NAME = "@nail00749/agent-gvozd";
-var PACKAGE_VERSION = "0.1.8";
+var PACKAGE_VERSION = "0.2.1";
 var PACKAGE_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
-var SUPPORTED_OPENCODE_VERSION = "2.0.2";
+var SUPPORTED_OPENCODE_VERSION = "2.0.*";
 var CONFIG_SCHEMA_VERSION = 2;
 
 // src/constants.ts
@@ -7433,12 +7434,15 @@ function redactDiagnostic(error) {
 
 // src/cli/opencode.ts
 import { spawn } from "node:child_process";
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { closeSync, mkdtempSync, openSync, readFileSync as readFileSync3, rmSync } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join4 } from "node:path";
+import { tmpdir } from "node:os";
 var MAX_OUTPUT_BYTES = 64 * 1024;
 var AGENT_OUTPUT_BYTES = 4 * 1024 * 1024;
 var DEFAULT_TIMEOUT_MS = 15000;
 var defaultProcessRunner = {
-  run(executable, args, timeoutMs = DEFAULT_TIMEOUT_MS, maxOutputBytes = MAX_OUTPUT_BYTES) {
+  run(executable, args, timeoutMs = DEFAULT_TIMEOUT_MS, maxOutputBytes = MAX_OUTPUT_BYTES, options) {
+    const stdoutFile = options?.stdoutFile;
     const appendBounded = (current, chunk) => {
       if (Buffer.byteLength(current) >= maxOutputBytes)
         return current;
@@ -7447,11 +7451,21 @@ var defaultProcessRunner = {
     };
     return new Promise((resolve, reject) => {
       const grouped = process.platform !== "win32";
+      let stdoutFd;
+      try {
+        if (stdoutFile)
+          stdoutFd = openSync(stdoutFile, "w");
+      } catch (error) {
+        reject(error);
+        return;
+      }
       const child = spawn(executable, [...args], {
         detached: grouped,
         shell: false,
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: ["ignore", stdoutFile ? stdoutFd : "pipe", "pipe"]
       });
+      if (stdoutFd !== undefined)
+        closeSync(stdoutFd);
       let stdout = "";
       let stderr = "";
       let settled = false;
@@ -7494,10 +7508,10 @@ var defaultProcessRunner = {
         settled = true;
         clearTimers();
         if (destroy) {
-          child.stdout.off("data", onStdout);
-          child.stderr.off("data", onStderr);
-          child.stdout.destroy();
-          child.stderr.destroy();
+          child.stderr?.off("data", onStderr);
+          child.stderr?.destroy();
+          child.stdout?.off("data", onStdout);
+          child.stdout?.destroy();
         }
         reject(timeoutError());
       };
@@ -7512,18 +7526,20 @@ var defaultProcessRunner = {
         hardDeadline.unref();
       }, timeoutMs);
       timer.unref();
-      child.stdout.on("data", onStdout);
-      child.stderr.on("data", onStderr);
+      if (child.stdout)
+        child.stdout.on("data", onStdout);
+      if (child.stderr)
+        child.stderr.on("data", onStderr);
       child.once("error", (error) => {
         clearTimers();
         if (settled)
           return;
         settled = true;
         if (timedOut) {
-          child.stdout.off("data", onStdout);
-          child.stderr.off("data", onStderr);
-          child.stdout.destroy();
-          child.stderr.destroy();
+          child.stderr?.off("data", onStderr);
+          child.stderr?.destroy();
+          child.stdout?.off("data", onStdout);
+          child.stdout?.destroy();
         }
         reject(error);
       });
@@ -7536,7 +7552,16 @@ var defaultProcessRunner = {
           return;
         }
         settled = true;
-        resolve({ code: code ?? 1, stdout, stderr });
+        const finish = (stdoutText) => resolve({ code: code ?? 1, stdout: stdoutText, stderr });
+        if (stdoutFile) {
+          try {
+            finish(bounded(readFileSync3(stdoutFile, "utf8"), maxOutputBytes));
+          } catch (error) {
+            reject(error);
+          }
+          return;
+        }
+        finish(stdout);
       });
     });
   }
@@ -7544,8 +7569,8 @@ var defaultProcessRunner = {
 function bounded(value, maxOutputBytes = MAX_OUTPUT_BYTES) {
   return Buffer.from(value).subarray(0, maxOutputBytes).toString("utf8");
 }
-async function checked(runner, executable, args, timeoutMs, maxOutputBytes) {
-  const result = await runner.run(executable, args, timeoutMs, maxOutputBytes);
+async function checked(runner, executable, args, timeoutMs, maxOutputBytes, options) {
+  const result = await runner.run(executable, args, timeoutMs, maxOutputBytes, options);
   if (result.code !== 0) {
     const detail = redactDiagnostic(bounded(result.stderr).trim());
     throw new Error(`OpenCode command exited ${result.code}${detail ? `: ${detail}` : ""}`);
@@ -7568,6 +7593,18 @@ function parseDebugPaths(output) {
 function parseOpenCodeVersion(output) {
   return output.match(/(?:^|\s)v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?=$|\s)/)?.[1];
 }
+function satisfiesOpenCodeRange(version, range) {
+  if (!version)
+    return false;
+  const [prerelease] = version.split("-").slice(1);
+  if (prerelease)
+    return false;
+  if (!range.includes("*"))
+    return version === range;
+  const [rangeMajor, rangeMinor] = range.split(".").slice(0, 2);
+  const [major, minor] = version.split(".").slice(0, 2);
+  return major === rangeMajor && minor === rangeMinor;
+}
 function parseAgentIdentifiers(output) {
   try {
     const parsed = JSON.parse(output);
@@ -7603,8 +7640,14 @@ function createClient(executable, runner) {
       return checked(runner, executable, spec ? ["plugin", "check", spec] : ["plugin", "check"], 30000);
     },
     async debugAgents() {
-      const raw = await checked(runner, executable, ["debug", "agents"], 60000, AGENT_OUTPUT_BYTES);
-      return parseAgentIdentifiers(raw);
+      const directory = mkdtempSync(join4(tmpdir(), "gvozd-agents-"));
+      const stdoutFile = join4(directory, "agents.out");
+      try {
+        const raw = await checked(runner, executable, ["debug", "agents"], 60000, AGENT_OUTPUT_BYTES, { stdoutFile });
+        return parseAgentIdentifiers(raw);
+      } finally {
+        rmSync(directory, { recursive: true, force: true });
+      }
     },
     serviceStatus() {
       return checked(runner, executable, ["service", "status"]);
@@ -7711,23 +7754,23 @@ function checkGlobalFiles(config, configRoot) {
   for (const [id, agent] of Object.entries(config.agents).sort(([left], [right]) => left.localeCompare(right))) {
     if (agent.disabled)
       continue;
-    const path = join4(configRoot, "agents", `${id}.md`);
+    const path = join5(configRoot, "agents", `${id}.md`);
     if (!safeFile(path)) {
       missing.push(id);
       continue;
     }
-    const content = readFileSync3(path, "utf8");
+    const content = readFileSync4(path, "utf8");
     if (!hasGeneratedAgentMarker(content) || content !== renderAgent(agent))
       stale.push(id);
   }
   const enabled = new Set(Object.entries(config.agents).filter(([, agent]) => !agent.disabled).map(([id]) => `${id}.md`));
   const orphans = [];
-  const directory = join4(configRoot, "agents");
+  const directory = join5(configRoot, "agents");
   if (existsSync3(directory) && lstatSync3(directory).isDirectory() && !lstatSync3(directory).isSymbolicLink()) {
     for (const entry of readdirSync3(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
       if (!entry.isFile() || !entry.name.endsWith(".md") || enabled.has(entry.name))
         continue;
-      const content = readFileSync3(join4(directory, entry.name), "utf8");
+      const content = readFileSync4(join5(directory, entry.name), "utf8");
       if (hasGeneratedAgentMarker(content))
         orphans.push(entry.name.slice(0, -3));
     }
@@ -7744,10 +7787,10 @@ function checkGlobalFiles(config, configRoot) {
 }
 function checkLegacy(config) {
   const duplicates = [];
-  const plugin = join4(config.projectRoot, ".opencode", "plugins", "agent-gvozd", "index.ts");
+  const plugin = join5(config.projectRoot, ".opencode", "plugins", "agent-gvozd", "index.ts");
   if (safeFile(plugin))
     duplicates.push("local plugin");
-  const agents = Object.keys(config.agents).filter((id) => safeFile(join4(config.projectRoot, ".opencode", "agents", `${id}.md`)));
+  const agents = Object.keys(config.agents).filter((id) => safeFile(join5(config.projectRoot, ".opencode", "agents", `${id}.md`)));
   if (agents.length > 0)
     duplicates.push(`${agents.length} local agents`);
   if (duplicates.length === 0)
@@ -7766,7 +7809,7 @@ async function runDoctor(input) {
   const checks = [];
   try {
     const version = await input.client.version();
-    checks.push(parseOpenCodeVersion(version) === supportedVersion ? { id: "opencode-version", status: "pass", summary: `OpenCode ${supportedVersion} is available` } : { id: "opencode-version", status: "fail", summary: `unsupported OpenCode version: ${redactDiagnostic(version)}`, remediation: `Install OpenCode ${supportedVersion}` });
+    checks.push(satisfiesOpenCodeRange(parseOpenCodeVersion(version), supportedVersion) ? { id: "opencode-version", status: "pass", summary: `OpenCode ${supportedVersion} is available` } : { id: "opencode-version", status: "fail", summary: `unsupported OpenCode version: ${redactDiagnostic(version)}`, remediation: `Install OpenCode ${supportedVersion}` });
   } catch (error) {
     checks.push({ id: "opencode-version", status: "fail", summary: `OpenCode version check failed: ${redactDiagnostic(error)}`, remediation: `Install OpenCode ${supportedVersion}` });
   }
@@ -7798,13 +7841,13 @@ async function runDoctor(input) {
   }
   let config;
   let globalConfig;
-  const configPath = join4(input.configRoot, "gvozd", "config.jsonc");
-  const schemaPath = join4(input.configRoot, "gvozd", "schema.json");
+  const configPath = join5(input.configRoot, "gvozd", "config.jsonc");
+  const schemaPath = join5(input.configRoot, "gvozd", "schema.json");
   try {
     if (!safeFile(configPath) || !safeFile(schemaPath))
       throw new Error("global config.jsonc or schema.json is missing");
     const schemaErrors = [];
-    const schema = parse2(readFileSync3(schemaPath, "utf8"), schemaErrors);
+    const schema = parse2(readFileSync4(schemaPath, "utf8"), schemaErrors);
     if (schemaErrors.length > 0 || schema?.["x-agent-gvozd-schema-version"] !== CONFIG_SCHEMA_VERSION || schema?.$comment !== GENERATED_PLUGIN_MARKER) {
       throw new Error("global schema is invalid, incompatible, or unmanaged");
     }
@@ -7871,18 +7914,18 @@ function doctorOperationalFailure(error) {
   return { schemaVersion: CONFIG_SCHEMA_VERSION, status: "fail", checks };
 }
 
-// src/cli/setup.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+// src/cli/agents.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/cli/config-store.ts
-import { accessSync, closeSync, constants as fsConstants, existsSync as existsSync4, lstatSync as lstatSync5, mkdirSync, openSync, readFileSync as readFileSync4, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { accessSync, closeSync as closeSync2, constants as fsConstants, existsSync as existsSync4, lstatSync as lstatSync5, mkdirSync, openSync as openSync2, readFileSync as readFileSync5, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { dirname as dirname3, join as join7 } from "node:path";
 
 // src/secure-path.ts
 import { lstatSync as lstatSync4, realpathSync as realpathSync3 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join5, parse as parse6, relative as relative3, resolve as resolve5, sep } from "node:path";
+import { isAbsolute as isAbsolute5, join as join6, parse as parse6, relative as relative3, resolve as resolve5, sep } from "node:path";
 function secureCanonicalPath(target, label = "Path") {
   if (!isAbsolute5(target))
     throw new Error(`${label} must be absolute: ${target}`);
@@ -7898,7 +7941,7 @@ function secureCanonicalPath(target, label = "Path") {
     throw new Error(`${label} has an unsafe filesystem root: ${root}`);
   const existingDirectories = [{ path: root, stat: rootStat }];
   for (const component of components) {
-    current = join5(current, component);
+    current = join6(current, component);
     if (missing) {
       missingSuffix.push(component);
       continue;
@@ -7943,8 +7986,8 @@ function secureCanonicalPath(target, label = "Path") {
 }
 
 // src/cli/config-store.ts
-var FAST_AGENT_IDS = ["back-fast", "front-fast", "review-fast", "researcher", "git", "docs", "verifier"];
-var DEEP_AGENT_IDS = ["master", "planner", "back-deep", "front-deep", "review-deep", "debugger", "security", "devops"];
+var FAST_AGENT_IDS = ["back-fast", "front-fast", "review-fast", "researcher", "git", "docs"];
+var DEEP_AGENT_IDS = ["master", "master-trusted", "planner", "back-deep", "front-deep", "review-deep", "debugger", "security", "devops"];
 var ALL_AGENT_IDS = [...DEEP_AGENT_IDS, ...FAST_AGENT_IDS, "explorer"];
 var formattingOptions = { insertSpaces: true, tabSize: 2, eol: `
 ` };
@@ -7969,13 +8012,16 @@ function applyModelProfile(source, profile) {
   updated = setJsonc(updated, ["agents", "explorer", "models"], profile.agentOverrides.explorer ?? profile.fast);
   return updated;
 }
+function writeManagedGlobalFile(path, content, expected) {
+  atomicWrite(path, content, expected);
+}
 function matchesSnapshot(path, expected) {
   if (!expected.exists)
     return !existsSync4(path);
   if (!existsSync4(path))
     return false;
   const stat = lstatSync5(path);
-  return stat.isFile() && !stat.isSymbolicLink() && stat.dev === expected.dev && stat.ino === expected.ino && readFileSync4(path, "utf8") === expected.bytes;
+  return stat.isFile() && !stat.isSymbolicLink() && stat.dev === expected.dev && stat.ino === expected.ino && readFileSync5(path, "utf8") === expected.bytes;
 }
 function atomicWrite(path, content, expected) {
   const canonicalPath = secureCanonicalPath(path, "Managed global config path");
@@ -7986,16 +8032,16 @@ function atomicWrite(path, content, expected) {
     throw new Error(`Global config path changed during write: ${path}`);
   assertWriteable(dirname3(canonicalPath), "Managed global config directory");
   const temporary = `${canonicalPath}.tmp-${process.pid}-${randomUUID()}`;
-  const descriptor = openSync(temporary, "wx", 384);
+  const descriptor = openSync2(temporary, "wx", 384);
   try {
     writeFileSync(descriptor, content);
-    closeSync(descriptor);
+    closeSync2(descriptor);
     if (!matchesSnapshot(canonicalPath, expected))
       throw new Error(`Refusing to replace concurrently changed file: ${canonicalPath}`);
     renameSync(temporary, canonicalPath);
   } catch (error) {
     try {
-      closeSync(descriptor);
+      closeSync2(descriptor);
     } catch {}
     try {
       unlinkSync(temporary);
@@ -8047,7 +8093,7 @@ function snapshot(path) {
   const stat = lstatSync5(path);
   if (!stat.isFile() || stat.isSymbolicLink())
     throw new Error(`Managed global config snapshot target is unsafe: ${path}`);
-  return Object.freeze({ path, exists: true, bytes: readFileSync4(path, "utf8"), dev: stat.dev, ino: stat.ino });
+  return Object.freeze({ path, exists: true, bytes: readFileSync5(path, "utf8"), dev: stat.dev, ino: stat.ino });
 }
 function preflightGlobalConfig(configRoot, schemaSource) {
   const canonicalRoot = secureCanonicalPath(configRoot, "OpenCode config root");
@@ -8056,24 +8102,24 @@ function preflightGlobalConfig(configRoot, schemaSource) {
     throw new Error(`OpenCode config root is not a safe directory: ${canonicalRoot}`);
   }
   assertWriteable(canonicalRoot, "OpenCode config root");
-  const directory = secureCanonicalPath(join6(canonicalRoot, "gvozd"), "Global Gvozd directory");
+  const directory = secureCanonicalPath(join7(canonicalRoot, "gvozd"), "Global Gvozd directory");
   const directoryStat = existsSync4(directory) ? lstatSync5(directory) : undefined;
   if (directoryStat && (directoryStat.isSymbolicLink() || !directoryStat.isDirectory())) {
     throw new Error(`Global Gvozd path is not a safe directory: ${directory}`);
   }
   assertWriteable(directory, "Global Gvozd directory");
-  const configPath = join6(directory, "config.jsonc");
-  const schemaPath = join6(directory, "schema.json");
+  const configPath = join7(directory, "config.jsonc");
+  const schemaPath = join7(directory, "schema.json");
   if (existsSync4(configPath)) {
     if (!isRegularFile(configPath))
       throw new Error(`Global Gvozd config is not a safe file: ${configPath}`);
-    assertValidJsonc(readFileSync4(configPath, "utf8"), configPath);
+    assertValidJsonc(readFileSync5(configPath, "utf8"), configPath);
     assertWriteable(configPath, "Global Gvozd config");
   }
   if (existsSync4(schemaPath)) {
     if (!isRegularFile(schemaPath))
       throw new Error(`Refusing to overwrite unmanaged Gvozd schema: ${schemaPath}`);
-    const schema = readFileSync4(schemaPath, "utf8");
+    const schema = readFileSync5(schemaPath, "utf8");
     if (!hasGeneratedSchemaMarker(schema) && !legacySchemaMatches(schema, schemaSource)) {
       throw new Error(`Refusing to overwrite unmanaged Gvozd schema: ${schemaPath}`);
     }
@@ -8086,9 +8132,9 @@ function writeGlobalConfig(input) {
   const canonicalRoot = secureCanonicalPath(input.configRoot, "OpenCode config root");
   if (state.configRoot !== canonicalRoot)
     throw new Error("Global config snapshot belongs to another config root");
-  const directory = join6(state.configRoot, "gvozd");
-  const configPath = join6(directory, "config.jsonc");
-  const schemaPath = join6(directory, "schema.json");
+  const directory = join7(state.configRoot, "gvozd");
+  const configPath = join7(directory, "config.jsonc");
+  const schemaPath = join7(directory, "schema.json");
   const base = state.config.exists ? state.config.bytes : `{
   "$schema": "./schema.json",
   "agents": {}
@@ -8108,6 +8154,51 @@ function writeGlobalConfig(input) {
   return { configPath, schemaPath, config };
 }
 
+// src/cli/agents.ts
+var formattingOptions2 = { insertSpaces: true, tabSize: 2, eol: `
+` };
+function assertValidJsonc2(source, label) {
+  const errors = [];
+  const value = parse2(source, errors, { allowTrailingComma: true, disallowComments: false });
+  if (errors.length > 0 || value === undefined || value === null || Array.isArray(value) || typeof value !== "object") {
+    const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
+    throw new Error(`Invalid JSONC in ${label}${details ? `: ${details}` : ""}`);
+  }
+}
+function listAgents(cwd) {
+  const config = loadConfig(cwd, { configRoot: resolveOpenCodeConfigRoot() });
+  return Object.entries(config.agents).map(([id, agent]) => ({
+    id,
+    mode: agent.mode,
+    lease: agent.fileLease,
+    disabled: agent.disabled,
+    model: agent.models[0] ?? ""
+  }));
+}
+function setAgentDisabled(source, agentID, disabled) {
+  if (!ALL_AGENT_IDS.includes(agentID)) {
+    throw new Error(`Unknown agent: ${agentID}`);
+  }
+  assertValidJsonc2(source, "global Gvozd config");
+  return applyEdits(source, modify(source, ["agents", agentID, "disabled"], disabled, { formattingOptions: formattingOptions2 }));
+}
+function readGlobalConfig(configRoot) {
+  const path = join8(configRoot, "gvozd", "config.jsonc");
+  if (!existsSync5(path))
+    return `{
+  "$schema": "./schema.json",
+  "agents": {}
+}
+`;
+  const source = readFileSync6(path, "utf8");
+  assertValidJsonc2(source, path);
+  return source;
+}
+
+// src/cli/setup.ts
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname6, join as join10 } from "node:path";
+
 // src/cli/configure.ts
 function availableProfile(profile, catalog) {
   if (!profile)
@@ -8177,9 +8268,9 @@ function profileFromAgents(agents, catalog) {
 }
 
 // src/cli/global-sync.ts
-import { accessSync as accessSync2, closeSync as closeSync2, constants as fsConstants2, existsSync as existsSync5, lstatSync as lstatSync6, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync5, readdirSync as readdirSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { accessSync as accessSync2, closeSync as closeSync3, constants as fsConstants2, existsSync as existsSync6, lstatSync as lstatSync6, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync7, readdirSync as readdirSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 function stat(path) {
   try {
     return lstatSync6(path);
@@ -8191,7 +8282,7 @@ function stat(path) {
 }
 function assertWriteable2(path, label) {
   let candidate = path;
-  while (!existsSync5(candidate)) {
+  while (!existsSync6(candidate)) {
     const parent = dirname4(candidate);
     if (parent === candidate)
       break;
@@ -8213,11 +8304,11 @@ function createFile(path, content) {
   const canonicalPath = secureCanonicalPath(path, "Managed global agent path");
   if (canonicalPath !== path)
     throw new Error(`Managed global agent path changed: ${path}`);
-  const descriptor = openSync2(canonicalPath, "wx", 384);
+  const descriptor = openSync3(canonicalPath, "wx", 384);
   try {
     writeFileSync2(descriptor, content);
   } finally {
-    closeSync2(descriptor);
+    closeSync3(descriptor);
   }
 }
 function replaceFile(path, content) {
@@ -8236,7 +8327,7 @@ function replaceFile(path, content) {
 }
 function writeManagedAgents(input) {
   const configRoot = secureCanonicalPath(input.configRoot, "OpenCode config root");
-  const agentsDirectory = secureCanonicalPath(join7(configRoot, "agents"), "OpenCode agents path");
+  const agentsDirectory = secureCanonicalPath(join9(configRoot, "agents"), "OpenCode agents path");
   const result = { created: [], updated: [], unchanged: [], conflicts: [], removed: [] };
   const writes = [];
   const removals = new Map;
@@ -8255,21 +8346,21 @@ function writeManagedAgents(input) {
     for (const entry of readdirSync4(agentsDirectory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
       if (!entry.isFile() || !entry.name.endsWith(".md") || enabled.has(entry.name))
         continue;
-      const path = join7(agentsDirectory, entry.name);
+      const path = join9(agentsDirectory, entry.name);
       const currentStat = stat(path);
       if (!currentStat || currentStat.isSymbolicLink() || !currentStat.isFile())
         continue;
-      if (hasGeneratedAgentMarker(readFileSync5(path, "utf8"))) {
+      if (hasGeneratedAgentMarker(readFileSync7(path, "utf8"))) {
         assertWriteable2(path, "Managed global agent");
         result.removed.push(path);
-        removals.set(path, readFileSync5(path, "utf8"));
+        removals.set(path, readFileSync7(path, "utf8"));
       }
     }
   }
   for (const [id, agent] of Object.entries(input.agents).sort(([left], [right]) => left.localeCompare(right))) {
     if (agent.disabled)
       continue;
-    const path = join7(agentsDirectory, `${id}.md`);
+    const path = join9(agentsDirectory, `${id}.md`);
     const content = renderAgent(agent);
     const currentStat = stat(path);
     if (!currentStat) {
@@ -8281,7 +8372,7 @@ function writeManagedAgents(input) {
       result.conflicts.push(path);
       continue;
     }
-    const current = readFileSync5(path, "utf8");
+    const current = readFileSync7(path, "utf8");
     if (!hasGeneratedAgentMarker(current)) {
       result.conflicts.push(path);
       continue;
@@ -8319,7 +8410,7 @@ function writeManagedAgents(input) {
     if (!currentStat || currentStat.isSymbolicLink() || !currentStat.isFile()) {
       throw new Error(`Refusing to remove a changed or unmanaged global agent: ${path}`);
     }
-    const current = readFileSync5(path, "utf8");
+    const current = readFileSync7(path, "utf8");
     if (!hasGeneratedAgentMarker(current) || current !== removals.get(path)) {
       throw new Error(`Refusing to remove a concurrently changed global agent: ${path}`);
     }
@@ -8328,7 +8419,7 @@ function writeManagedAgents(input) {
   for (const write of writes) {
     if (write.replace) {
       const currentStat = stat(write.path);
-      const current = currentStat?.isFile() && !currentStat.isSymbolicLink() ? readFileSync5(write.path, "utf8") : undefined;
+      const current = currentStat?.isFile() && !currentStat.isSymbolicLink() ? readFileSync7(write.path, "utf8") : undefined;
       if (!current || !hasGeneratedAgentMarker(current) || current !== write.previous) {
         throw new Error(`Refusing to replace a concurrently changed global agent: ${write.path}`);
       }
@@ -8341,8 +8432,30 @@ function writeManagedAgents(input) {
 
 // src/file-lock.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { accessSync as accessSync3, closeSync as closeSync3, constants, existsSync as existsSync6, fstatSync, lstatSync as lstatSync7, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { accessSync as accessSync3, closeSync as closeSync4, constants, existsSync as existsSync7, fstatSync, lstatSync as lstatSync7, mkdirSync as mkdirSync3, openSync as openSync4, readFileSync as readFileSync8, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
+var STALE_LOCK_AGE_MS = 30 * 60 * 1000;
+function lockOwnerAlive(path) {
+  let contents;
+  try {
+    contents = readFileSync8(path, "utf8");
+  } catch {
+    return true;
+  }
+  const pid = Number(contents.split(":")[0]);
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  if (pid === process.pid)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error.code === "ESRCH")
+      return false;
+    return true;
+  }
+}
 function assertSecure(path) {
   const stat = lstatSync7(path);
   if (!stat.isDirectory() || stat.isSymbolicLink())
@@ -8364,22 +8477,48 @@ function acquire(path, operation) {
 `;
   let descriptor;
   try {
-    descriptor = openSync3(canonicalPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+    descriptor = openSync4(canonicalPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
   } catch (error) {
-    if (error.code === "EEXIST") {
+    if (error.code !== "EEXIST")
+      throw error;
+    if (removeStaleLock(canonicalPath)) {
+      descriptor = openSync4(canonicalPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+    } else {
       throw new Error(`Another Gvozd ${operation} is active or left a lock at ${canonicalPath}; inspect it manually and do not delete it while work may be running`);
     }
-    throw error;
   }
   const created = fstatSync(descriptor);
   writeFileSync3(descriptor, nonce);
   return { path: canonicalPath, descriptor, nonce, dev: created.dev, ino: created.ino };
 }
+function removeStaleLock(path) {
+  let stat;
+  try {
+    stat = lstatSync7(path);
+  } catch {
+    return false;
+  }
+  if (!stat.isFile() || stat.isSymbolicLink())
+    return false;
+  if (Date.now() - stat.mtimeMs < STALE_LOCK_AGE_MS)
+    return false;
+  if (lockOwnerAlive(path))
+    return false;
+  try {
+    const current = lstatSync7(path);
+    if (current.isSymbolicLink() || !current.isFile() || current.ino !== stat.ino || current.dev !== stat.dev)
+      return false;
+    unlinkSync3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function release(lock) {
-  closeSync3(lock.descriptor);
-  if (existsSync6(lock.path)) {
+  closeSync4(lock.descriptor);
+  if (existsSync7(lock.path)) {
     const current = lstatSync7(lock.path);
-    if (current.isFile() && !current.isSymbolicLink() && current.dev === lock.dev && current.ino === lock.ino && readFileSync6(lock.path, "utf8") === lock.nonce)
+    if (current.isFile() && !current.isSymbolicLink() && current.dev === lock.dev && current.ino === lock.ino && readFileSync8(lock.path, "utf8") === lock.nonce)
       unlinkSync3(lock.path);
   }
 }
@@ -8402,14 +8541,14 @@ function withExclusiveFileLockSync(path, callback, operation = "operation") {
 
 // src/cli/setup.ts
 function assertVersion(version) {
-  if (parseOpenCodeVersion(version) !== SUPPORTED_OPENCODE_VERSION) {
+  if (!satisfiesOpenCodeRange(parseOpenCodeVersion(version), SUPPORTED_OPENCODE_VERSION)) {
     throw new Error(`Unsupported OpenCode version. Gvozd ${PACKAGE_VERSION} requires ${SUPPORTED_OPENCODE_VERSION}.`);
   }
 }
 async function selectProfile(input, client, configRoot) {
   const catalog = parseModels(await client.models());
   const config = loadConfig(input.cwd, { configRoot, includeProject: false });
-  const hasGlobalConfig = existsSync7(join8(configRoot, "gvozd", "config.jsonc"));
+  const hasGlobalConfig = existsSync8(join10(configRoot, "gvozd", "config.jsonc"));
   return chooseModelProfile({
     catalog,
     ui: input.ui,
@@ -8435,6 +8574,22 @@ async function registeredPackageSpecs(client, packageName, target) {
   const specs = [...new Set(output.match(specPattern) ?? [])];
   return specs.filter((spec) => spec !== target);
 }
+async function awaitRegisteredPlugin(client, timeoutMs = 15000) {
+  const target = PACKAGE_SPEC;
+  const started = Date.now();
+  for (;; ) {
+    try {
+      const output = await client.pluginList();
+      const escapedName = PACKAGE_NAME.replace(/[/@]/g, "\\$&");
+      const registered = new RegExp(`${escapedName}(?:@|\\s+)v?${PACKAGE_VERSION}(?=$|[^0-9.])`, "m").test(output);
+      if (registered)
+        return;
+    } catch {}
+    if (Date.now() - started >= timeoutMs)
+      throw new Error(`OpenCode did not report ${target} within ${timeoutMs}ms after the service restart`);
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+}
 async function runSetup(input) {
   const client = await (input.findClient ?? (() => findOpenCode()))();
   const paths = await client.debugPaths();
@@ -8445,8 +8600,8 @@ async function runSetup(input) {
   const runtimeConfigRoot = input.runtimeConfigRoot ?? resolveOpenCodeConfigRoot();
   assertVersion(await client.version());
   const before = loadConfig(input.cwd, { configRoot, includeProject: false });
-  const schemaSource = join8(dirname6(before.sources[0]), "schema.json");
-  const packagedSchema = readFileSync7(schemaSource, "utf8");
+  const schemaSource = join10(dirname6(before.sources[0]), "schema.json");
+  const packagedSchema = readFileSync9(schemaSource, "utf8");
   const previewSnapshot = preflightGlobalConfig(configRoot, packagedSchema);
   const preview = writeManagedAgents({ configRoot, agents: before.agents, check: true });
   const profile = await selectProfile(input, client, configRoot);
@@ -8454,17 +8609,17 @@ async function runSetup(input) {
     return { status: "cancelled" };
   input.output?.([
     `Register ${PACKAGE_SPEC}`,
-    `Write ${join8(configRoot, "gvozd", "config.jsonc")}`,
-    `Write managed agents in ${join8(configRoot, "agents")}`,
+    `Write ${join10(configRoot, "gvozd", "config.jsonc")}`,
+    `Write managed agents in ${join10(configRoot, "agents")}`,
     ...preview.removed.length > 0 ? [`Remove ${preview.removed.length} stale or disabled managed agent(s)`] : []
   ].join(`
 `));
   if (!await confirm2(input, "Run setup?"))
     return { status: "cancelled" };
-  return withExclusiveFileLock(join8(configRoot, "gvozd", "setup.lock"), async () => {
+  return withExclusiveFileLock(join10(configRoot, "gvozd", "setup.lock"), async () => {
     if (secureCanonicalPath(configRoot, "OpenCode config root") !== configRoot)
       throw new Error("OpenCode config root changed while setup awaited the lock");
-    const lockedSchema = readFileSync7(schemaSource, "utf8");
+    const lockedSchema = readFileSync9(schemaSource, "utf8");
     const snapshot = preflightGlobalConfig(configRoot, lockedSchema);
     if (!sameSnapshot(previewSnapshot, snapshot))
       throw new Error("Global Gvozd configuration changed while setup awaited confirmation; review and rerun setup");
@@ -8486,6 +8641,7 @@ async function runSetup(input) {
       const configured = loadConfig(input.cwd, { configRoot, includeProject: false });
       writeManagedAgents({ configRoot, agents: configured.agents });
       await client.serviceRestart();
+      await awaitRegisteredPlugin(client);
       const report = await runDoctor({ client, configRoot, runtimeConfigRoot, cwd: input.cwd });
       return { status: "complete", report };
     } catch (error) {
@@ -8504,16 +8660,16 @@ async function runConfigure(input) {
   const runtimeConfigRoot = input.runtimeConfigRoot ?? resolveOpenCodeConfigRoot();
   assertVersion(await client.version());
   const config = loadConfig(input.cwd, { configRoot, includeProject: false });
-  const schemaSource = join8(dirname6(config.sources[0]), "schema.json");
-  const packagedSchema = readFileSync7(schemaSource, "utf8");
+  const schemaSource = join10(dirname6(config.sources[0]), "schema.json");
+  const packagedSchema = readFileSync9(schemaSource, "utf8");
   const previewSnapshot = preflightGlobalConfig(configRoot, packagedSchema);
   const profile = await selectProfile(input, client, configRoot);
   if (!profile || !await confirm2(input, "Apply model configuration?"))
     return { status: "cancelled" };
-  return withExclusiveFileLock(join8(configRoot, "gvozd", "setup.lock"), async () => {
+  return withExclusiveFileLock(join10(configRoot, "gvozd", "setup.lock"), async () => {
     if (secureCanonicalPath(configRoot, "OpenCode config root") !== configRoot)
       throw new Error("OpenCode config root changed while configuration awaited the lock");
-    const lockedSchema = readFileSync7(schemaSource, "utf8");
+    const lockedSchema = readFileSync9(schemaSource, "utf8");
     const snapshot = preflightGlobalConfig(configRoot, lockedSchema);
     if (!sameSnapshot(previewSnapshot, snapshot))
       throw new Error("Global Gvozd configuration changed while configuration awaited confirmation; review and rerun");
@@ -8537,13 +8693,13 @@ function setupExitCode(result) {
 }
 
 // src/sync.ts
-import { closeSync as closeSync4, lstatSync as lstatSync8, mkdirSync as mkdirSync4, openSync as openSync4, readFileSync as readFileSync8, readdirSync as readdirSync5, realpathSync as realpathSync4, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { closeSync as closeSync5, lstatSync as lstatSync8, mkdirSync as mkdirSync4, openSync as openSync5, readFileSync as readFileSync10, readdirSync as readdirSync5, realpathSync as realpathSync4, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { basename, dirname as dirname7, join as join9, relative as relative4 } from "node:path";
+import { basename, dirname as dirname7, join as join11, relative as relative4 } from "node:path";
 function renderPluginEntrypoint(config, destination) {
   let moduleSpecifier = "agent-gvozd/server";
   if (realpathSync4(config.packageRoot) === realpathSync4(config.projectRoot)) {
-    moduleSpecifier = relative4(destination, join9(config.packageRoot, "src", "index")).replaceAll("\\", "/");
+    moduleSpecifier = relative4(destination, join11(config.packageRoot, "src", "index")).replaceAll("\\", "/");
     if (!moduleSpecifier.startsWith("."))
       moduleSpecifier = `./${moduleSpecifier}`;
   }
@@ -8588,7 +8744,7 @@ function stat2(path) {
 function safeDirectory(root, segments, create) {
   let current = realpathSync4(root);
   for (const segment of segments) {
-    current = join9(current, segment);
+    current = join11(current, segment);
     const currentStat = stat2(current);
     if (currentStat) {
       if (currentStat.isSymbolicLink() || !currentStat.isDirectory()) {
@@ -8610,11 +8766,11 @@ function assertRegularFile(path) {
   return true;
 }
 function createFile2(path, content) {
-  const descriptor = openSync4(path, "wx", 384);
+  const descriptor = openSync5(path, "wx", 384);
   try {
     writeFileSync4(descriptor, content);
   } finally {
-    closeSync4(descriptor);
+    closeSync5(descriptor);
   }
 }
 function replaceFile2(path, content) {
@@ -8632,7 +8788,7 @@ function replaceFile2(path, content) {
 function planProjectTemplate(config, result, check) {
   const directory = safeDirectory(config.projectRoot, ["docs", ".gvozd"], !check);
   const writes = [];
-  const configPath = join9(directory, "config.jsonc");
+  const configPath = join11(directory, "config.jsonc");
   if (!assertRegularFile(configPath)) {
     result.created.push(configPath);
     writes.push({
@@ -8649,14 +8805,14 @@ function planProjectTemplate(config, result, check) {
 `)
     });
   }
-  const schemaSource = join9(dirname7(config.sources[0]), "schema.json");
-  const schemaTarget = join9(directory, "schema.json");
-  const schema = readFileSync8(schemaSource, "utf8");
+  const schemaSource = join11(dirname7(config.sources[0]), "schema.json");
+  const schemaTarget = join11(directory, "schema.json");
+  const schema = readFileSync10(schemaSource, "utf8");
   if (!assertRegularFile(schemaTarget)) {
     result.created.push(schemaTarget);
     writes.push({ target: schemaTarget, content: schema, replace: false });
   } else {
-    const current = readFileSync8(schemaTarget, "utf8");
+    const current = readFileSync10(schemaTarget, "utf8");
     if (current !== schema) {
       if (!hasGeneratedSchemaMarker(current) && !isEquivalentLegacySchema(current, schema)) {
         throw new Error(`Refusing to overwrite an unmanaged project schema: ${schemaTarget}`);
@@ -8681,8 +8837,8 @@ function syncAgentsUnlocked(config, options) {
     for (const entry of readdirSync5(destination, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
       if (!entry.isFile() || !entry.name.endsWith(".md") || enabled.has(entry.name))
         continue;
-      const target = join9(destination, entry.name);
-      const current = readFileSync8(target, "utf8");
+      const target = join11(destination, entry.name);
+      const current = readFileSync10(target, "utf8");
       if (!hasGeneratedAgentMarker(current))
         continue;
       result.removed.push(target);
@@ -8693,14 +8849,14 @@ function syncAgentsUnlocked(config, options) {
   for (const [id, agent] of Object.entries(config.agents)) {
     if (agent.disabled)
       continue;
-    const target = join9(destination, `${id}.md`);
+    const target = join11(destination, `${id}.md`);
     const content = renderAgent(agent);
     if (!assertRegularFile(target)) {
       result.created.push(target);
       writes.push({ target, content, replace: false });
       continue;
     }
-    const current = readFileSync8(target, "utf8");
+    const current = readFileSync10(target, "utf8");
     if (current === content) {
       result.unchanged.push(target);
       continue;
@@ -8712,11 +8868,11 @@ function syncAgentsUnlocked(config, options) {
     options.onDiff?.(renderDiff(target, current, content));
     writes.push({ target, content, replace: true, previous: current });
   }
-  const pluginTarget = join9(pluginDestination, "index.ts");
+  const pluginTarget = join11(pluginDestination, "index.ts");
   const pluginContent = renderPluginEntrypoint(config, pluginDestination);
   if (!options.devPlugin) {
     if (assertRegularFile(pluginTarget)) {
-      const current = readFileSync8(pluginTarget, "utf8");
+      const current = readFileSync10(pluginTarget, "utf8");
       if (hasGeneratedPluginMarker(current)) {
         result.removed.push(pluginTarget);
         removals.set(pluginTarget, current);
@@ -8727,7 +8883,7 @@ function syncAgentsUnlocked(config, options) {
     result.created.push(pluginTarget);
     pluginWrite = { target: pluginTarget, content: pluginContent, replace: false };
   } else {
-    const current = readFileSync8(pluginTarget, "utf8");
+    const current = readFileSync10(pluginTarget, "utf8");
     if (current === pluginContent) {
       result.unchanged.push(pluginTarget);
     } else {
@@ -8746,7 +8902,7 @@ function syncAgentsUnlocked(config, options) {
       if (!assertRegularFile(target)) {
         throw new Error(`Refusing to remove a changed or unsafe generated file: ${target}`);
       }
-      const current = readFileSync8(target, "utf8");
+      const current = readFileSync10(target, "utf8");
       const generated = target.endsWith("index.ts") ? hasGeneratedPluginMarker(current) : hasGeneratedAgentMarker(current);
       if (!generated || current !== removals.get(target)) {
         throw new Error(`Refusing to remove a concurrently changed generated file: ${target}`);
@@ -8755,27 +8911,27 @@ function syncAgentsUnlocked(config, options) {
     }
     for (const write of writes) {
       if (!write.replace) {
-        createFile2(join9(writableDestination, basename(write.target)), write.content);
+        createFile2(join11(writableDestination, basename(write.target)), write.content);
         continue;
       }
       if (!assertRegularFile(write.target)) {
         throw new Error(`Refusing to replace a changed or unsafe agent file: ${write.target}`);
       }
-      const current = readFileSync8(write.target, "utf8");
+      const current = readFileSync10(write.target, "utf8");
       if (!hasGeneratedAgentMarker(current) || current !== write.previous) {
         throw new Error(`Refusing to replace a concurrently changed agent file: ${write.target}`);
       }
       replaceFile2(write.target, write.content);
     }
     if (pluginWrite) {
-      const target = join9(writablePluginDestination, basename(pluginWrite.target));
+      const target = join11(writablePluginDestination, basename(pluginWrite.target));
       if (!pluginWrite.replace) {
         createFile2(target, pluginWrite.content);
       } else {
         if (!assertRegularFile(target)) {
           throw new Error(`Refusing to replace a changed or unsafe plugin entrypoint: ${target}`);
         }
-        const current = readFileSync8(target, "utf8");
+        const current = readFileSync10(target, "utf8");
         if (!hasGeneratedPluginMarker(current) || current !== pluginWrite.previous) {
           throw new Error(`Refusing to replace a concurrently changed plugin entrypoint: ${target}`);
         }
@@ -8784,11 +8940,11 @@ function syncAgentsUnlocked(config, options) {
     }
     const templateDirectory = safeDirectory(config.projectRoot, ["docs", ".gvozd"], true);
     for (const write of templateWrites) {
-      const target = join9(templateDirectory, basename(write.target));
+      const target = join11(templateDirectory, basename(write.target));
       if (!write.replace)
         createFile2(target, write.content);
       else {
-        if (!assertRegularFile(target) || readFileSync8(target, "utf8") !== write.previous) {
+        if (!assertRegularFile(target) || readFileSync10(target, "utf8") !== write.previous) {
           throw new Error(`Refusing to replace a concurrently changed project schema: ${target}`);
         }
         replaceFile2(target, write.content);
@@ -8803,7 +8959,7 @@ function syncAgents(config, options = {}) {
   if (options.check)
     return syncAgentsUnlocked(config, options);
   const root = realpathSync4(config.projectRoot);
-  return withExclusiveFileLockSync(join9(root, ".agent-gvozd-sync.lock"), () => syncAgentsUnlocked(config, options), "sync");
+  return withExclusiveFileLockSync(join11(root, ".agent-gvozd-sync.lock"), () => syncAgentsUnlocked(config, options), "sync");
 }
 function formatSyncResult(result, check) {
   const lines = [check ? "agent-gvozd sync check" : "agent-gvozd sync complete"];
@@ -8838,6 +8994,8 @@ var HELP = [
   "",
   "Commands:",
   "  setup [--yes]    Install or upgrade the global agent team",
+  "  agents [list]    Show the resolved agent team",
+  "  agents disable <id> | enable <id>  Toggle an agent in the global config",
   "  config [--yes]   Configure model preferences",
   "  doctor [--json]  Diagnose the global installation",
   "  sync [--check] [--dev-plugin]  Maintain the project-local installation",
@@ -8922,6 +9080,32 @@ async function runCli(args, io = defaultIO, commands = { setup: runSetup, config
       io.stdout(formatSyncResult(result, check));
       return check && result.created.length + result.updated.length + result.removed.length > 0 ? 1 : 0;
     }
+    if (command === "agents") {
+      const [action, agentID] = rest;
+      if (!action || action === "list") {
+        if (rest.length > 1)
+          return usage(io);
+        const rows = listAgents(io.cwd());
+        for (const row of rows) {
+          io.stdout(`${row.disabled ? "✗" : " "} ${row.id.padEnd(12)} ${row.mode.padEnd(8)} ${row.lease.padEnd(12)} ${row.model}`);
+        }
+        return 0;
+      }
+      if (action === "disable" || action === "enable") {
+        if (agentID === undefined || agentID.startsWith("--") || rest.length > 2)
+          return usage(io);
+        const configRoot = resolveOpenCodeConfigRoot();
+        await withExclusiveFileLock(join12(configRoot, "gvozd", "setup.lock"), async () => {
+          preflightGlobalConfig(configRoot);
+          const snapshot2 = snapshot(join12(configRoot, "gvozd", "config.jsonc"));
+          const next = setAgentDisabled(readGlobalConfig(configRoot), agentID, action === "disable");
+          writeManagedGlobalFile(join12(configRoot, "gvozd", "config.jsonc"), next, snapshot2);
+        });
+        io.stdout(`${action}d ${agentID}; run gvozd sync and gvozd doctor to apply`);
+        return 0;
+      }
+      return usage(io);
+    }
     if (command === "trust-project") {
       const parsed = parseFlags(rest, []);
       if (!parsed || parsed.positional.length > 1)
@@ -8936,8 +9120,13 @@ async function runCli(args, io = defaultIO, commands = { setup: runSetup, config
   }
 }
 var invokedPath = process.argv[1];
-if (invokedPath && realpathSync5(invokedPath) === realpathSync5(fileURLToPath2(import.meta.url))) {
-  process.exitCode = await runCli(process.argv.slice(2));
+try {
+  if (invokedPath && realpathSync5(invokedPath) === realpathSync5(fileURLToPath2(import.meta.url))) {
+    process.exitCode = await runCli(process.argv.slice(2));
+  }
+} catch (error) {
+  if (error.code !== "ENOENT")
+    throw error;
 }
 export {
   runCli