@nail00749/agent-gvozd 0.2.0 → 0.2.2

package/dist/cli.js

@@ -988,7 +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 { join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/config.ts
@@ -7230,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) {
@@ -7337,7 +7337,7 @@ function buildAgentPermissions(agent, mcpServers) {
 
 // src/release-metadata.ts
 var PACKAGE_NAME = "@nail00749/agent-gvozd";
-var PACKAGE_VERSION = "0.2.0";
+var PACKAGE_VERSION = "0.2.2";
 var PACKAGE_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
 var SUPPORTED_OPENCODE_VERSION = "2.0.*";
 var CONFIG_SCHEMA_VERSION = 2;
@@ -7434,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;
@@ -7448,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;
@@ -7495,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());
       };
@@ -7513,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);
       });
@@ -7537,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);
       });
     });
   }
@@ -7545,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}` : ""}`);
@@ -7616,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"]);
@@ -7724,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));
     }
@@ -7757,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)
@@ -7811,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");
     }
@@ -7885,17 +7915,17 @@ function doctorOperationalFailure(error) {
 }
 
 // src/cli/agents.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
-import { join as join7 } from "node:path";
+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}`);
@@ -7911,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;
@@ -7991,7 +8021,7 @@ function matchesSnapshot(path, expected) {
   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");
@@ -8002,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);
@@ -8063,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");
@@ -8072,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}`);
     }
@@ -8102,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": {}
@@ -8153,21 +8183,21 @@ function setAgentDisabled(source, agentID, disabled) {
   return applyEdits(source, modify(source, ["agents", agentID, "disabled"], disabled, { formattingOptions: formattingOptions2 }));
 }
 function readGlobalConfig(configRoot) {
-  const path = join7(configRoot, "gvozd", "config.jsonc");
+  const path = join8(configRoot, "gvozd", "config.jsonc");
   if (!existsSync5(path))
     return `{
   "$schema": "./schema.json",
   "agents": {}
 }
 `;
-  const source = readFileSync5(path, "utf8");
+  const source = readFileSync6(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";
+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) {
@@ -8238,9 +8268,9 @@ function profileFromAgents(agents, catalog) {
 }
 
 // src/cli/global-sync.ts
-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 { 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 join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 function stat(path) {
   try {
     return lstatSync6(path);
@@ -8274,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) {
@@ -8297,7 +8327,7 @@ function replaceFile(path, content) {
 }
 function writeManagedAgents(input) {
   const configRoot = secureCanonicalPath(input.configRoot, "OpenCode config root");
-  const agentsDirectory = secureCanonicalPath(join8(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;
@@ -8316,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 = join8(agentsDirectory, entry.name);
+      const path = join9(agentsDirectory, entry.name);
       const currentStat = stat(path);
       if (!currentStat || currentStat.isSymbolicLink() || !currentStat.isFile())
         continue;
-      if (hasGeneratedAgentMarker(readFileSync6(path, "utf8"))) {
+      if (hasGeneratedAgentMarker(readFileSync7(path, "utf8"))) {
         assertWriteable2(path, "Managed global agent");
         result.removed.push(path);
-        removals.set(path, readFileSync6(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 = join8(agentsDirectory, `${id}.md`);
+    const path = join9(agentsDirectory, `${id}.md`);
     const content = renderAgent(agent);
     const currentStat = stat(path);
     if (!currentStat) {
@@ -8342,7 +8372,7 @@ function writeManagedAgents(input) {
       result.conflicts.push(path);
       continue;
     }
-    const current = readFileSync6(path, "utf8");
+    const current = readFileSync7(path, "utf8");
     if (!hasGeneratedAgentMarker(current)) {
       result.conflicts.push(path);
       continue;
@@ -8380,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 = readFileSync6(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}`);
     }
@@ -8389,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() ? readFileSync6(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}`);
       }
@@ -8402,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 existsSync7, fstatSync, lstatSync as lstatSync7, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync7, 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())
@@ -8425,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);
+  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 && readFileSync7(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);
   }
 }
@@ -8470,7 +8548,7 @@ function assertVersion(version) {
 async function selectProfile(input, client, configRoot) {
   const catalog = parseModels(await client.models());
   const config = loadConfig(input.cwd, { configRoot, includeProject: false });
-  const hasGlobalConfig = existsSync8(join9(configRoot, "gvozd", "config.jsonc"));
+  const hasGlobalConfig = existsSync8(join10(configRoot, "gvozd", "config.jsonc"));
   return chooseModelProfile({
     catalog,
     ui: input.ui,
@@ -8522,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 = join9(dirname6(before.sources[0]), "schema.json");
-  const packagedSchema = readFileSync8(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);
@@ -8531,17 +8609,17 @@ async function runSetup(input) {
     return { status: "cancelled" };
   input.output?.([
     `Register ${PACKAGE_SPEC}`,
-    `Write ${join9(configRoot, "gvozd", "config.jsonc")}`,
-    `Write managed agents in ${join9(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(join9(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 = readFileSync8(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");
@@ -8582,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 = join9(dirname6(config.sources[0]), "schema.json");
-  const packagedSchema = readFileSync8(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(join9(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 = readFileSync8(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");
@@ -8615,13 +8693,13 @@ function setupExitCode(result) {
 }
 
 // src/sync.ts
-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 { 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 join10, 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, join10(config.packageRoot, "src", "index")).replaceAll("\\", "/");
+    moduleSpecifier = relative4(destination, join11(config.packageRoot, "src", "index")).replaceAll("\\", "/");
     if (!moduleSpecifier.startsWith("."))
       moduleSpecifier = `./${moduleSpecifier}`;
   }
@@ -8666,7 +8744,7 @@ function stat2(path) {
 function safeDirectory(root, segments, create) {
   let current = realpathSync4(root);
   for (const segment of segments) {
-    current = join10(current, segment);
+    current = join11(current, segment);
     const currentStat = stat2(current);
     if (currentStat) {
       if (currentStat.isSymbolicLink() || !currentStat.isDirectory()) {
@@ -8688,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) {
@@ -8710,7 +8788,7 @@ function replaceFile2(path, content) {
 function planProjectTemplate(config, result, check) {
   const directory = safeDirectory(config.projectRoot, ["docs", ".gvozd"], !check);
   const writes = [];
-  const configPath = join10(directory, "config.jsonc");
+  const configPath = join11(directory, "config.jsonc");
   if (!assertRegularFile(configPath)) {
     result.created.push(configPath);
     writes.push({
@@ -8727,14 +8805,14 @@ function planProjectTemplate(config, result, check) {
 `)
     });
   }
-  const schemaSource = join10(dirname7(config.sources[0]), "schema.json");
-  const schemaTarget = join10(directory, "schema.json");
-  const schema = readFileSync9(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 = readFileSync9(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}`);
@@ -8759,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 = join10(destination, entry.name);
-      const current = readFileSync9(target, "utf8");
+      const target = join11(destination, entry.name);
+      const current = readFileSync10(target, "utf8");
       if (!hasGeneratedAgentMarker(current))
         continue;
       result.removed.push(target);
@@ -8771,14 +8849,14 @@ function syncAgentsUnlocked(config, options) {
   for (const [id, agent] of Object.entries(config.agents)) {
     if (agent.disabled)
       continue;
-    const target = join10(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 = readFileSync9(target, "utf8");
+    const current = readFileSync10(target, "utf8");
     if (current === content) {
       result.unchanged.push(target);
       continue;
@@ -8790,11 +8868,11 @@ function syncAgentsUnlocked(config, options) {
     options.onDiff?.(renderDiff(target, current, content));
     writes.push({ target, content, replace: true, previous: current });
   }
-  const pluginTarget = join10(pluginDestination, "index.ts");
+  const pluginTarget = join11(pluginDestination, "index.ts");
   const pluginContent = renderPluginEntrypoint(config, pluginDestination);
   if (!options.devPlugin) {
     if (assertRegularFile(pluginTarget)) {
-      const current = readFileSync9(pluginTarget, "utf8");
+      const current = readFileSync10(pluginTarget, "utf8");
       if (hasGeneratedPluginMarker(current)) {
         result.removed.push(pluginTarget);
         removals.set(pluginTarget, current);
@@ -8805,7 +8883,7 @@ function syncAgentsUnlocked(config, options) {
     result.created.push(pluginTarget);
     pluginWrite = { target: pluginTarget, content: pluginContent, replace: false };
   } else {
-    const current = readFileSync9(pluginTarget, "utf8");
+    const current = readFileSync10(pluginTarget, "utf8");
     if (current === pluginContent) {
       result.unchanged.push(pluginTarget);
     } else {
@@ -8824,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 = readFileSync9(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}`);
@@ -8833,27 +8911,27 @@ function syncAgentsUnlocked(config, options) {
     }
     for (const write of writes) {
       if (!write.replace) {
-        createFile2(join10(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 = readFileSync9(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 = join10(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 = readFileSync9(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}`);
         }
@@ -8862,11 +8940,11 @@ function syncAgentsUnlocked(config, options) {
     }
     const templateDirectory = safeDirectory(config.projectRoot, ["docs", ".gvozd"], true);
     for (const write of templateWrites) {
-      const target = join10(templateDirectory, basename(write.target));
+      const target = join11(templateDirectory, basename(write.target));
       if (!write.replace)
         createFile2(target, write.content);
       else {
-        if (!assertRegularFile(target) || readFileSync9(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);
@@ -8881,7 +8959,7 @@ function syncAgents(config, options = {}) {
   if (options.check)
     return syncAgentsUnlocked(config, options);
   const root = realpathSync4(config.projectRoot);
-  return withExclusiveFileLockSync(join10(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"];
@@ -9017,10 +9095,12 @@ async function runCli(args, io = defaultIO, commands = { setup: runSetup, config
         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);
+        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;
       }
@@ -9040,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

package/dist/index.js

@@ -78,16 +78,27 @@ function normalizeMcpName(name) {
   return name.replaceAll(/[^A-Za-z0-9_-]/g, "_");
 }
 function wildcardMatch(pattern, value) {
-  let source = "^";
-  for (const character of pattern) {
-    if (character === "*")
-      source += ".*";
-    else if (character === "?")
-      source += ".";
-    else
-      source += character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  let patternIndex = 0;
+  let valueIndex = 0;
+  let starPatternIndex = -1;
+  let restartValueIndex = 0;
+  while (valueIndex < value.length) {
+    if (patternIndex < pattern.length && pattern[patternIndex] === "*") {
+      starPatternIndex = patternIndex++;
+      restartValueIndex = valueIndex;
+    } else if (patternIndex < pattern.length && (pattern[patternIndex] === "?" || pattern[patternIndex] === value[valueIndex])) {
+      patternIndex++;
+      valueIndex++;
+    } else if (starPatternIndex >= 0) {
+      patternIndex = starPatternIndex + 1;
+      valueIndex = ++restartValueIndex;
+    } else {
+      return false;
+    }
   }
-  return new RegExp(`${source}$`).test(value);
+  while (patternIndex < pattern.length && pattern[patternIndex] === "*")
+    patternIndex++;
+  return patternIndex === pattern.length;
 }
 function explicitMcpAccess(agent, action, resources) {
   if (resources.length === 0)
@@ -6455,25 +6466,13 @@ var GvozdLeases = Rpc.define({
 function evaluateEffect(rules, action, resource) {
   let matched;
   for (const rule of rules) {
-    if (match(rule.action, action) && match(rule.resource, resource))
+    if (wildcardMatch(rule.action, action) && wildcardMatch(rule.resource, resource))
       matched = rule;
   }
   if (!matched)
     return { effect: "unknown", matchedRule: null };
   return { effect: matched.effect, matchedRule: `${matched.action} ${matched.resource}` };
 }
-function match(pattern, value) {
-  let source = "^";
-  for (const character of pattern) {
-    if (character === "*")
-      source += ".*";
-    else if (character === "?")
-      source += ".";
-    else
-      source += character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-  }
-  return new RegExp(`${source}$`).test(value);
-}
 function evaluateInput(agentRules, input) {
   const results = input.checks.flatMap((request) => (request.resources.length > 0 ? request.resources : ["*"]).map((resource) => {
     const evaluation = agentRules ? evaluateEffect(agentRules, request.action, resource) : { effect: "unknown", matchedRule: null };
@@ -6544,7 +6543,9 @@ function modePermissions(mode) {
       { action: "shell", resource: "git filter-repo*", effect: "deny" },
       { action: "shell", resource: "git rebase*", effect: "deny" },
       { action: "shell", resource: "git checkout --*", effect: "deny" },
-      { action: "shell", resource: "git restore*", effect: "deny" }
+      { action: "shell", resource: "git restore*", effect: "deny" },
+      { action: "shell", resource: "git rebase --abort*", effect: "allow" },
+      { action: "shell", resource: "git rebase --continue*", effect: "allow" }
     ];
   }
   if (mode === "strict") {
@@ -6645,6 +6646,8 @@ function enforceFileLeasePermission(event, config, manager) {
   if (event.action !== "shell" && event.action !== "bash")
     return false;
   if (role === "coordinator") {
+    if (!manager.hasActiveLeases())
+      return false;
     return deny(event, `Agent ${event.agent} cannot use shell while file leases enforce structured mutations`);
   }
   if (role === "writer" && safeReadonlyShell(event.agent, event.resources)) {

package/dist/tui.js

@@ -9,6 +9,71 @@ import { usePlugin } from "@opencode/plugin/tui";
 
 // src/permissions-rpc.ts
 import { Rpc } from "@opencode/plugin/rpc";
+
+// src/tool-permissions.ts
+function family(command, ...variants) {
+  return [command, ...variants].map((entry) => ({
+    exact: entry,
+    wildcard: `${entry} *`
+  }));
+}
+function exactOnly(command, ...variants) {
+  return [command, ...variants].map((entry) => ({ exact: entry, wildcard: entry }));
+}
+var INSPECTION_COMMANDS = [
+  ...family("pwd", "true", "test"),
+  ...family("cat", "head", "tail", "wc", "sort", "uniq"),
+  ...family("grep", "rg", "find", "diff", "cmp"),
+  ...family("ls", "du", "df", "stat", "file", "realpath", "basename", "dirname"),
+  ...family("shasum", "sha256sum", "md5sum"),
+  ...family("uname", "whoami", "hostname", "date", "printenv"),
+  ...family("which", "command -v"),
+  ...family("mktemp"),
+  ...family("tr", "cut", "paste", "column"),
+  ...family("node --version", "python3 --version", "python --version", "deno --version")
+];
+var TOOLCHAIN_COMMANDS = [
+  ...family("bun test", "bun run test", "bun --version"),
+  ...family("bun run typecheck", "bun run lint", "bun run build", "bun run check"),
+  ...family("tsc --noEmit", "npx tsc --noEmit"),
+  ...family("eslint", "biome check", "prettier --check"),
+  ...family("npm test", "npm run test", "npm run typecheck", "npm run lint", "npm run build"),
+  ...family("pnpm test", "pnpm run test", "pnpm run build"),
+  ...family("yarn test", "yarn build"),
+  ...family("vitest run", "jest", "playwright test"),
+  ...family("cargo check", "cargo test", "cargo build", "cargo clippy", "cargo fmt --check", "cargo --version"),
+  ...family("go build ./...", "go test ./...", "go vet ./...", "go version"),
+  ...family("pytest", "python3 -m pytest", "python -m pytest"),
+  ...family("ruff check", "mypy", "pyright"),
+  ...family("mvn test", "mvn verify", "gradle test", "gradle check", "./gradlew test", "./gradlew check"),
+  ...family("make test", "make check", "make build", "make --version"),
+  ...family("just --list")
+];
+var GIT_READONLY_COMMANDS = [
+  ...family("git status", "git status --short", "git status --short --branch", "git status --porcelain", "git status --porcelain=v1 --branch"),
+  ...family("git diff", "git diff --stat", "git diff --cached", "git diff --check"),
+  ...family("git log", "git show"),
+  ...family("git rev-parse", "git rev-list", "git show-ref", "git cat-file"),
+  ...exactOnly("git symbolic-ref HEAD", "git symbolic-ref --short HEAD"),
+  ...family("git ls-files", "git ls-remote", "git grep"),
+  ...exactOnly("git branch", "git tag", "git remote", "git reflog"),
+  ...family("git branch --list", "git branch -l", "git branch -a", "git branch -r", "git branch -v", "git branch -vv", "git branch --all", "git branch --remotes", "git branch --show-current", "git branch --contains"),
+  ...family("git tag --list", "git tag -l", "git tag -n"),
+  ...family("git remote -v", "git remote --verbose", "git remote show", "git remote get-url"),
+  ...family("git reflog show"),
+  ...family("git stash list", "git describe", "git worktree list"),
+  ...family("git config --get", "git config --get-regexp")
+];
+var GIT_MUTATING_COMMANDS = [
+  ...family("git add", "git rm --cached"),
+  ...family("git commit", "git merge --ff-only", "git merge --no-ff"),
+  ...family("git push", "git fetch", "git pull --ff-only"),
+  ...family("git stash", "git cherry-pick", "git revert"),
+  ...family("git switch", "git checkout -b", "git worktree add"),
+  ...exactOnly("git branch *", "git tag *", "git remote *", "git symbolic-ref *", "git reflog *")
+];
+
+// src/permissions-rpc.ts
 var GvozdPermissions = Rpc.define({
   id: "gvozd-permissions",
   events: {},
@@ -358,9 +423,9 @@ function useSessionInsights(sessionID) {
   });
   const [resource] = createResource(() => {
     const id = sessionID();
-    version();
-    return id;
-  }, async (id) => {
+    return { id, revision: version() };
+  }, async (key) => {
+    const id = key.id;
     if (!id)
       return EMPTY_INSIGHTS;
     const [messages, pending] = await Promise.allSettled([
@@ -429,38 +494,114 @@ async function evaluatePermissions(agent, checks) {
 function splitCommandPipeline(input) {
   const segments = [];
   let current = "";
-  let quote;
   let escaped = false;
+  const contexts = [{ parenDepth: 0 }];
+  let heredoc;
   const flush = () => {
     const trimmed = current.trim();
     if (trimmed)
       segments.push(trimmed);
     current = "";
   };
+  const at = (index) => input[index] ?? "";
   for (let index = 0;index < input.length; index++) {
     const character = input[index];
+    if (heredoc) {
+      if (character === `
+`) {
+        const line = current.slice(current.lastIndexOf(`
+`) + 1).replace(/\r$/, "");
+        const candidate = heredoc.stripTabs ? line.replace(/^\t+/, "") : line;
+        if (candidate === heredoc.marker) {
+          heredoc = undefined;
+          current += character;
+          flush();
+          continue;
+        }
+      }
+      current += character;
+      continue;
+    }
+    const context = contexts[contexts.length - 1];
     if (escaped) {
       current += character;
       escaped = false;
       continue;
     }
-    if (character === "\\" && quote !== "'") {
+    if (character === "\\" && context.quote !== "'") {
       current += character;
       escaped = true;
       continue;
     }
     if (character === '"' || character === "'") {
-      if (quote === character)
-        quote = undefined;
-      else if (!quote)
-        quote = character;
+      if (context.quote === character)
+        context.quote = undefined;
+      else if (!context.quote)
+        context.quote = character;
+      current += character;
+      continue;
+    }
+    if (context.quote === "'") {
+      current += character;
+      continue;
+    }
+    if (character === "$" && at(index + 1) === "(") {
+      contexts.push({ closer: ")", parenDepth: 0 });
+      current += "$(";
+      index++;
+      continue;
+    }
+    if (character === "`") {
+      if (context.closer === "`")
+        contexts.pop();
+      else
+        contexts.push({ closer: "`", parenDepth: 0 });
+      current += character;
+      continue;
+    }
+    if (context.closer === ")" && character === "(") {
+      context.parenDepth++;
+      current += character;
+      continue;
+    }
+    if (context.closer === ")" && character === ")") {
+      if (context.parenDepth > 0)
+        context.parenDepth--;
+      else
+        contexts.pop();
       current += character;
       continue;
     }
-    if (quote) {
+    if (contexts.length > 1 || context.quote) {
       current += character;
       continue;
     }
+    if (character === "<" && at(index - 1) !== "<" && at(index + 1) === "<" && at(index + 2) !== "<") {
+      let cursor = index + 2;
+      const stripTabs = input[cursor] === "-";
+      if (stripTabs)
+        cursor++;
+      let marker = "";
+      while (cursor < input.length && /[ \t]/.test(input[cursor]))
+        cursor++;
+      if (input[cursor] === '"' || input[cursor] === "'") {
+        const closeQuote = input[cursor];
+        cursor++;
+        while (cursor < input.length && input[cursor] !== closeQuote)
+          marker += input[cursor++];
+        if (input[cursor] === closeQuote)
+          cursor++;
+      } else {
+        while (cursor < input.length && !/[\s;|&<>()]/.test(input[cursor]))
+          marker += input[cursor++];
+      }
+      if (marker) {
+        heredoc = { marker, stripTabs };
+        current += input.slice(index, cursor);
+        index = cursor - 1;
+        continue;
+      }
+    }
     if (character === ";" || character === `
 `) {
       flush();
@@ -624,7 +765,7 @@ function SessionInsightsSlot(props) {
 function DryRunPanel() {
   const context = usePlugin2();
   const [input, setInput] = createSignal2("");
-  const [agent, setAgent] = createSignal2("master");
+  const [agent] = createSignal2("master");
   const [rows, setRows] = createSignal2([]);
   const [busy, setBusy] = createSignal2(false);
   const run = async () => {
@@ -861,6 +1002,29 @@ var MODE_HINTS = {
   trusted: "allow all shell and edits; destructive git still denied",
   strict: "ask for every shell command and edit"
 };
+function KeymapCommands() {
+  const context = usePlugin2();
+  context.keymap.layer(() => ({
+    mode: "global",
+    commands: GVOZD_COMMANDS.map((command) => ({
+      id: command.id,
+      title: command.title,
+      group: "Gvozd",
+      palette: true,
+      slash: { name: command.slash },
+      run: () => {
+        context.ui.panel.open(command.panel, { presentation: "fullscreen" });
+      }
+    }))
+  }));
+  return null;
+}
+var GVOZD_COMMANDS = [
+  { id: "gvozd.insights", title: "Gvozd session insights", panel: "gvozd.insights", slash: "gvozd" },
+  { id: "gvozd.dryrun", title: "Gvozd permission dry-run", panel: "gvozd.dryrun", slash: "gvozd-dryrun" },
+  { id: "gvozd.leases", title: "Gvozd file leases", panel: "gvozd.leases", slash: "gvozd-leases" },
+  { id: "gvozd.mode", title: "Gvozd permission mode", panel: "gvozd.mode", slash: "gvozd-mode" }
+];
 var tui_default = Plugin.define({
   id: "agent-gvozd",
   setup(context) {
@@ -876,6 +1040,10 @@ var tui_default = Plugin.define({
         sessionID
       }, undefined, false, undefined, this) : null
     });
+    const unregisterKeymapHost = context.ui.slot({
+      append: "app",
+      render: () => /* @__PURE__ */ jsxDEV(KeymapCommands, {}, undefined, false, undefined, this)
+    });
     const unregisterPanelSlot = context.ui.slot({
       append: "session.panel",
       render: (panel) => /* @__PURE__ */ jsxDEV(Fragment, {
@@ -899,55 +1067,11 @@ var tui_default = Plugin.define({
         ]
       }, undefined, true, undefined, this)
     });
-    const unregisterKeymap = context.keymap.layer(() => ({
-      mode: "global",
-      commands: [
-        {
-          id: "gvozd.insights",
-          title: "Gvozd session insights",
-          group: "Gvozd",
-          palette: true,
-          slash: { name: "gvozd" },
-          run: () => {
-            context.ui.panel.open("gvozd.insights", { presentation: "fullscreen" });
-          }
-        },
-        {
-          id: "gvozd.dryrun",
-          title: "Gvozd permission dry-run",
-          group: "Gvozd",
-          palette: true,
-          slash: { name: "gvozd-dryrun" },
-          run: () => {
-            context.ui.panel.open("gvozd.dryrun", { presentation: "fullscreen" });
-          }
-        },
-        {
-          id: "gvozd.leases",
-          title: "Gvozd file leases",
-          group: "Gvozd",
-          palette: true,
-          slash: { name: "gvozd-leases" },
-          run: () => {
-            context.ui.panel.open("gvozd.leases", { presentation: "fullscreen" });
-          }
-        },
-        {
-          id: "gvozd.mode",
-          title: "Gvozd permission mode",
-          group: "Gvozd",
-          palette: true,
-          slash: { name: "gvozd-mode" },
-          run: () => {
-            context.ui.panel.open("gvozd.mode", { presentation: "fullscreen" });
-          }
-        }
-      ]
-    }));
     return () => {
       unregisterSidebar();
       unregisterFooter();
       unregisterPanelSlot();
+      unregisterKeymapHost();
     };
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nail00749/agent-gvozd",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A globally configured, permission-aware agent team for OpenCode V2",
   "license": "MIT",
   "keywords": [
@@ -48,10 +48,10 @@
     "verify:sync": "bun run ./scripts/verify-sync.ts",
     "verify:package": "bun run ./scripts/verify-package.ts",
     "verify:live": "bun run ./scripts/live-opencode-compat.ts",
-    "prepublishOnly": "bun run test:unit && bun run test:e2e && bun run typecheck && bun run build && bun run verify:sync && bun run verify:package",
+    "prepublishOnly": "bun run test:unit && bun run typecheck && bun run build && bun run verify:sync && bun run verify:package && bun run test:e2e",
     "test:unit": "bun test --path-ignore-patterns \"**/package-smoke.test.ts\"",
     "test:e2e": "bun test src/cli/package-smoke.test.ts",
-    "publish:fast": "bun run typecheck && bun run build && bun run verify:package && npm publish --ignore-scripts"
+    "publish:fast": "bun run test:unit && bun run typecheck && bun run build && bun run verify:package && npm publish --ignore-scripts"
   },
   "dependencies": {
     "@clack/prompts": "1.8.0",