@nail00749/agent-gvozd 0.1.7 → 0.2.0

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 join11 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/config.ts
@@ -7336,9 +7337,9 @@ function buildAgentPermissions(agent, mcpServers) {
 
 // src/release-metadata.ts
 var PACKAGE_NAME = "@nail00749/agent-gvozd";
-var PACKAGE_VERSION = "0.1.7";
+var PACKAGE_VERSION = "0.2.0";
 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
@@ -7568,6 +7569,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);
@@ -7593,6 +7606,9 @@ function createClient(executable, runner) {
     async pluginAdd(spec) {
       await checked(runner, executable, ["plugin", "add", spec], 60000);
     },
+    async pluginRemove(spec) {
+      await checked(runner, executable, ["plugin", "remove", spec]);
+    },
     pluginList() {
       return checked(runner, executable, ["plugin", "list"]);
     },
@@ -7763,7 +7779,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}` });
   }
@@ -7868,9 +7884,9 @@ 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 readFileSync5 } from "node:fs";
+import { join as join7 } 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";
@@ -7940,8 +7956,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: `
 ` };
@@ -7966,6 +7982,9 @@ 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);
@@ -8105,6 +8124,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 = join7(configRoot, "gvozd", "config.jsonc");
+  if (!existsSync5(path))
+    return `{
+  "$schema": "./schema.json",
+  "agents": {}
+}
+`;
+  const source = readFileSync5(path, "utf8");
+  assertValidJsonc2(source, path);
+  return source;
+}
+
+// src/cli/setup.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname6, join as join9 } from "node:path";
+
 // src/cli/configure.ts
 function availableProfile(profile, catalog) {
   if (!profile)
@@ -8174,9 +8238,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 closeSync2, constants as fsConstants2, existsSync as existsSync6, lstatSync as lstatSync6, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync6, 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 join8 } from "node:path";
 function stat(path) {
   try {
     return lstatSync6(path);
@@ -8188,7 +8252,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;
@@ -8233,7 +8297,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(join8(configRoot, "agents"), "OpenCode agents path");
   const result = { created: [], updated: [], unchanged: [], conflicts: [], removed: [] };
   const writes = [];
   const removals = new Map;
@@ -8252,21 +8316,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 = join8(agentsDirectory, entry.name);
       const currentStat = stat(path);
       if (!currentStat || currentStat.isSymbolicLink() || !currentStat.isFile())
         continue;
-      if (hasGeneratedAgentMarker(readFileSync5(path, "utf8"))) {
+      if (hasGeneratedAgentMarker(readFileSync6(path, "utf8"))) {
         assertWriteable2(path, "Managed global agent");
         result.removed.push(path);
-        removals.set(path, readFileSync5(path, "utf8"));
+        removals.set(path, readFileSync6(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 = join8(agentsDirectory, `${id}.md`);
     const content = renderAgent(agent);
     const currentStat = stat(path);
     if (!currentStat) {
@@ -8278,7 +8342,7 @@ function writeManagedAgents(input) {
       result.conflicts.push(path);
       continue;
     }
-    const current = readFileSync5(path, "utf8");
+    const current = readFileSync6(path, "utf8");
     if (!hasGeneratedAgentMarker(current)) {
       result.conflicts.push(path);
       continue;
@@ -8316,7 +8380,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 = readFileSync6(path, "utf8");
     if (!hasGeneratedAgentMarker(current) || current !== removals.get(path)) {
       throw new Error(`Refusing to remove a concurrently changed global agent: ${path}`);
     }
@@ -8325,7 +8389,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() ? readFileSync6(write.path, "utf8") : undefined;
       if (!current || !hasGeneratedAgentMarker(current) || current !== write.previous) {
         throw new Error(`Refusing to replace a concurrently changed global agent: ${write.path}`);
       }
@@ -8338,7 +8402,7 @@ 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 closeSync3, constants, existsSync as existsSync7, fstatSync, lstatSync as lstatSync7, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 function assertSecure(path) {
   const stat = lstatSync7(path);
@@ -8374,9 +8438,9 @@ function acquire(path, operation) {
 }
 function release(lock) {
   closeSync3(lock.descriptor);
-  if (existsSync6(lock.path)) {
+  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 && readFileSync7(lock.path, "utf8") === lock.nonce)
       unlinkSync3(lock.path);
   }
 }
@@ -8399,14 +8463,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(join9(configRoot, "gvozd", "config.jsonc"));
   return chooseModelProfile({
     catalog,
     ui: input.ui,
@@ -8426,6 +8490,28 @@ async function confirm2(input, message) {
 function sameSnapshot(left, right) {
   return left.configRoot === right.configRoot && left.config.exists === right.config.exists && left.config.dev === right.config.dev && left.config.ino === right.config.ino && left.config.bytes === right.config.bytes && left.schema.exists === right.schema.exists && left.schema.dev === right.schema.dev && left.schema.ino === right.schema.ino && left.schema.bytes === right.schema.bytes;
 }
+async function registeredPackageSpecs(client, packageName, target) {
+  const output = await client.pluginList();
+  const specPattern = new RegExp(`${packageName.replace(/[/@]/g, "\\$&")}@[^\\s]+`, "g");
+  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();
@@ -8436,8 +8522,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 = join9(dirname6(before.sources[0]), "schema.json");
+  const packagedSchema = readFileSync8(schemaSource, "utf8");
   const previewSnapshot = preflightGlobalConfig(configRoot, packagedSchema);
   const preview = writeManagedAgents({ configRoot, agents: before.agents, check: true });
   const profile = await selectProfile(input, client, configRoot);
@@ -8445,17 +8531,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 ${join9(configRoot, "gvozd", "config.jsonc")}`,
+    `Write managed agents in ${join9(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(join9(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 = readFileSync8(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");
@@ -8468,12 +8554,16 @@ async function runSetup(input) {
       throw new Error("Global Gvozd configuration changed during locked setup revalidation; review and rerun setup");
     }
     writeManagedAgents({ configRoot, agents: lockedBefore.agents, check: true });
+    for (const stale of await registeredPackageSpecs(client, PACKAGE_NAME, PACKAGE_SPEC)) {
+      await client.pluginRemove(stale);
+    }
     await client.pluginAdd(PACKAGE_SPEC);
     try {
       writeGlobalConfig({ configRoot, profile: lockedProfile, schemaSource: lockedSchema, snapshot });
       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) {
@@ -8492,16 +8582,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 = join9(dirname6(config.sources[0]), "schema.json");
+  const packagedSchema = readFileSync8(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(join9(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 = readFileSync8(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");
@@ -8525,13 +8615,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 closeSync4, lstatSync as lstatSync8, mkdirSync as mkdirSync4, openSync as openSync4, readFileSync as readFileSync9, 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 join10, 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, join10(config.packageRoot, "src", "index")).replaceAll("\\", "/");
     if (!moduleSpecifier.startsWith("."))
       moduleSpecifier = `./${moduleSpecifier}`;
   }
@@ -8576,7 +8666,7 @@ function stat2(path) {
 function safeDirectory(root, segments, create) {
   let current = realpathSync4(root);
   for (const segment of segments) {
-    current = join9(current, segment);
+    current = join10(current, segment);
     const currentStat = stat2(current);
     if (currentStat) {
       if (currentStat.isSymbolicLink() || !currentStat.isDirectory()) {
@@ -8620,7 +8710,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 = join10(directory, "config.jsonc");
   if (!assertRegularFile(configPath)) {
     result.created.push(configPath);
     writes.push({
@@ -8637,14 +8727,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 = join10(dirname7(config.sources[0]), "schema.json");
+  const schemaTarget = join10(directory, "schema.json");
+  const schema = readFileSync9(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 = readFileSync9(schemaTarget, "utf8");
     if (current !== schema) {
       if (!hasGeneratedSchemaMarker(current) && !isEquivalentLegacySchema(current, schema)) {
         throw new Error(`Refusing to overwrite an unmanaged project schema: ${schemaTarget}`);
@@ -8669,8 +8759,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 = join10(destination, entry.name);
+      const current = readFileSync9(target, "utf8");
       if (!hasGeneratedAgentMarker(current))
         continue;
       result.removed.push(target);
@@ -8681,14 +8771,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 = join10(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 = readFileSync9(target, "utf8");
     if (current === content) {
       result.unchanged.push(target);
       continue;
@@ -8700,11 +8790,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 = join10(pluginDestination, "index.ts");
   const pluginContent = renderPluginEntrypoint(config, pluginDestination);
   if (!options.devPlugin) {
     if (assertRegularFile(pluginTarget)) {
-      const current = readFileSync8(pluginTarget, "utf8");
+      const current = readFileSync9(pluginTarget, "utf8");
       if (hasGeneratedPluginMarker(current)) {
         result.removed.push(pluginTarget);
         removals.set(pluginTarget, current);
@@ -8715,7 +8805,7 @@ function syncAgentsUnlocked(config, options) {
     result.created.push(pluginTarget);
     pluginWrite = { target: pluginTarget, content: pluginContent, replace: false };
   } else {
-    const current = readFileSync8(pluginTarget, "utf8");
+    const current = readFileSync9(pluginTarget, "utf8");
     if (current === pluginContent) {
       result.unchanged.push(pluginTarget);
     } else {
@@ -8734,7 +8824,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 = readFileSync9(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}`);
@@ -8743,27 +8833,27 @@ function syncAgentsUnlocked(config, options) {
     }
     for (const write of writes) {
       if (!write.replace) {
-        createFile2(join9(writableDestination, basename(write.target)), write.content);
+        createFile2(join10(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 = readFileSync9(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 = join10(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 = readFileSync9(target, "utf8");
         if (!hasGeneratedPluginMarker(current) || current !== pluginWrite.previous) {
           throw new Error(`Refusing to replace a concurrently changed plugin entrypoint: ${target}`);
         }
@@ -8772,11 +8862,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 = join10(templateDirectory, basename(write.target));
       if (!write.replace)
         createFile2(target, write.content);
       else {
-        if (!assertRegularFile(target) || readFileSync8(target, "utf8") !== write.previous) {
+        if (!assertRegularFile(target) || readFileSync9(target, "utf8") !== write.previous) {
           throw new Error(`Refusing to replace a concurrently changed project schema: ${target}`);
         }
         replaceFile2(target, write.content);
@@ -8791,7 +8881,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(join10(root, ".agent-gvozd-sync.lock"), () => syncAgentsUnlocked(config, options), "sync");
 }
 function formatSyncResult(result, check) {
   const lines = [check ? "agent-gvozd sync check" : "agent-gvozd sync complete"];
@@ -8826,6 +8916,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",
@@ -8910,6 +9002,30 @@ 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();
+        preflightGlobalConfig(configRoot);
+        const snapshot2 = snapshot(join11(configRoot, "gvozd", "config.jsonc"));
+        const next = setAgentDisabled(readGlobalConfig(configRoot), agentID, action === "disable");
+        writeManagedGlobalFile(join11(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)