@nail00749/agent-gvozd 0.1.2 → 0.1.3

package/dist/cli.js

@@ -2462,6 +2462,14 @@ function cleanRegex(source) {
   const end = source.endsWith("$") ? source.length - 1 : source.length;
   return source.slice(start, end);
 }
+function floatSafeRemainder(val, step) {
+  const ratio = val / step;
+  const roundedRatio = Math.round(ratio);
+  const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
+  if (Math.abs(ratio - roundedRatio) < tolerance)
+    return 0;
+  return ratio - roundedRatio;
+}
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
 function defineLazy(object, key, getter) {
   let value = undefined;
@@ -3020,6 +3028,7 @@ var string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
+var integer = /^-?\d+$/;
 var number = /^-?\d+(?:\.\d+)?$/;
 var boolean = /^(?:true|false)$/i;
 var lowercase = /^[^A-Z]*$/;
@@ -3032,6 +3041,168 @@ var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
   inst._zod.def = def;
   (_a = inst._zod).onattach ?? (_a.onattach = []);
 });
+var numericOriginMap = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+};
+var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+    if (def.value < curr) {
+      if (def.inclusive)
+        bag.maximum = def.value;
+      else
+        bag.exclusiveMaximum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    if (def.value > curr) {
+      if (def.inclusive)
+        bag.minimum = def.value;
+      else
+        bag.exclusiveMinimum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    var _a;
+    (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
+  });
+  inst._zod.check = (payload) => {
+    if (typeof payload.value !== typeof def.value)
+      throw new Error("Cannot mix number and bigint in multiple_of check.");
+    const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
+    if (isMultiple)
+      return;
+    payload.issues.push({
+      origin: typeof payload.value,
+      code: "not_multiple_of",
+      divisor: def.value,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  def.format = def.format || "float64";
+  const isInt = def.format?.includes("int");
+  const origin = isInt ? "int" : "number";
+  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    bag.minimum = minimum;
+    bag.maximum = maximum;
+    if (isInt)
+      bag.pattern = integer;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    if (isInt) {
+      if (!Number.isInteger(input)) {
+        payload.issues.push({
+          expected: origin,
+          format: def.format,
+          code: "invalid_type",
+          continue: false,
+          input,
+          inst
+        });
+        return;
+      }
+      if (!Number.isSafeInteger(input)) {
+        if (input > 0) {
+          payload.issues.push({
+            input,
+            code: "too_big",
+            maximum: Number.MAX_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        } else {
+          payload.issues.push({
+            input,
+            code: "too_small",
+            minimum: Number.MIN_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        }
+        return;
+      }
+    }
+    if (input < minimum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_small",
+        minimum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+    if (input > maximum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_big",
+        maximum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
 var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
   var _a;
   $ZodCheck.init(inst, def);
@@ -3714,6 +3885,33 @@ var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
     });
   };
 });
+var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = inst._zod.bag.pattern ?? number;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Number(payload.value);
+      } catch (_) {}
+    const input = payload.value;
+    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
+      return payload;
+    }
+    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : undefined : undefined;
+    payload.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input,
+      inst,
+      ...received ? { received } : {}
+    });
+    return payload;
+  };
+});
+var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
+  $ZodCheckNumberFormat.init(inst, def);
+  $ZodNumber.init(inst, def);
+});
 var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = boolean;
@@ -4928,6 +5126,22 @@ function _isoDuration(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _number(Class, params) {
+  return new Class({
+    type: "number",
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
+function _int(Class, params) {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "safeint",
+    ...normalizeParams(params)
+  });
+}
 function _boolean(Class, params) {
   return new Class({
     type: "boolean",
@@ -4945,6 +5159,45 @@ function _never(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _lt(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+function _lte(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+function _gt(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+function _gte(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+function _multipleOf(value, params) {
+  return new $ZodCheckMultipleOf({
+    check: "multiple_of",
+    ...normalizeParams(params),
+    value
+  });
+}
 function _maxLength(maximum, params) {
   const ch = new $ZodCheckMaxLength({
     check: "max_length",
@@ -5470,6 +5723,39 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
+var numberProcessor = (schema, ctx, _json, _params) => {
+  const json = _json;
+  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  if (typeof format === "string" && format.includes("int"))
+    json.type = "integer";
+  else
+    json.type = "number";
+  const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
+  const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
+  const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+  if (exMin) {
+    if (legacy) {
+      json.minimum = exclusiveMinimum;
+      json.exclusiveMinimum = true;
+    } else {
+      json.exclusiveMinimum = exclusiveMinimum;
+    }
+  } else if (typeof minimum === "number") {
+    json.minimum = minimum;
+  }
+  if (exMax) {
+    if (legacy) {
+      json.maximum = exclusiveMaximum;
+      json.exclusiveMaximum = true;
+    } else {
+      json.exclusiveMaximum = exclusiveMaximum;
+    }
+  } else if (typeof maximum === "number") {
+    json.maximum = maximum;
+  }
+  if (typeof multipleOf === "number")
+    json.multipleOf = multipleOf;
+};
 var booleanProcessor = (_schema, _ctx, json, _params) => {
   json.type = "boolean";
 };
@@ -6093,6 +6379,74 @@ var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
   $ZodJWT.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
+  $ZodNumber.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
+  _installLazyMethods(inst, "ZodNumber", {
+    gt(value, params) {
+      return this.check(_gt(value, params));
+    },
+    gte(value, params) {
+      return this.check(_gte(value, params));
+    },
+    min(value, params) {
+      return this.check(_gte(value, params));
+    },
+    lt(value, params) {
+      return this.check(_lt(value, params));
+    },
+    lte(value, params) {
+      return this.check(_lte(value, params));
+    },
+    max(value, params) {
+      return this.check(_lte(value, params));
+    },
+    int(params) {
+      return this.check(int(params));
+    },
+    safe(params) {
+      return this.check(int(params));
+    },
+    positive(params) {
+      return this.check(_gt(0, params));
+    },
+    nonnegative(params) {
+      return this.check(_gte(0, params));
+    },
+    negative(params) {
+      return this.check(_lt(0, params));
+    },
+    nonpositive(params) {
+      return this.check(_lte(0, params));
+    },
+    multipleOf(value, params) {
+      return this.check(_multipleOf(value, params));
+    },
+    step(value, params) {
+      return this.check(_multipleOf(value, params));
+    },
+    finite() {
+      return this;
+    }
+  });
+  const bag = inst._zod.bag;
+  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
+  inst.isFinite = true;
+  inst.format = bag.format ?? null;
+});
+function number2(params) {
+  return _number(ZodNumber, params);
+}
+var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
+  $ZodNumberFormat.init(inst, def);
+  ZodNumber.init(inst, def);
+});
+function int(params) {
+  return _int(ZodNumberFormat, params);
+}
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
@@ -6633,6 +6987,10 @@ function computeProjectTrustToken(projectDirectory) {
   return `sha256:${hash.digest("hex")}`;
 }
 
+// src/file-leases.ts
+var DEFAULT_RESERVATION_TTL_MS = 5 * 60 * 1000;
+var DEFAULT_ACTIVE_TTL_MS = 30 * 60 * 1000;
+
 // src/config.ts
 var permissionSchema = object({
   action: string2().min(1),
@@ -6653,11 +7011,16 @@ var agentPatchSchema = object({
   fileLease: fileLeaseRoleSchema.optional(),
   disabled: boolean2().optional()
 }).strict();
+var leaseSchema = object({
+  reservationTtlMinutes: number2().int().positive().max(24 * 60).optional(),
+  activeTtlMinutes: number2().int().positive().max(24 * 60).optional()
+}).strict();
 var rootPatchSchema = object({
   $schema: string2().min(1).optional(),
   defaultAgent: agentIdSchema.optional(),
   agentsDirectory: string2().min(1).optional(),
-  agents: record(agentIdSchema, agentPatchSchema).optional()
+  agents: record(agentIdSchema, agentPatchSchema).optional(),
+  lease: leaseSchema.optional()
 }).strict();
 var resolvedAgentSchema = agentPatchSchema.extend({
   description: string2().min(1),
@@ -6721,7 +7084,7 @@ function loadLayer(directory, rootFileName, required, projectPolicy) {
   }
   const root = rootPatchSchema.parse(readJsonc2(rootPath));
   if (projectPolicy && !projectPolicy.trusted) {
-    const restricted = ["defaultAgent", "agentsDirectory"].filter((field) => Object.prototype.hasOwnProperty.call(root, field));
+    const restricted = ["defaultAgent", "agentsDirectory", "lease"].filter((field) => Object.prototype.hasOwnProperty.call(root, field));
     if (restricted.length > 0)
       throw new Error(`Untrusted project config ${rootPath} cannot override ${restricted.join(", ")}`);
   }
@@ -6754,6 +7117,7 @@ function loadLayer(directory, rootFileName, required, projectPolicy) {
   return {
     defaultAgent: root.defaultAgent,
     agents,
+    lease: root.lease,
     sources: [rootPath]
   };
 }
@@ -6815,6 +7179,20 @@ function loadConfig(projectDirectory, options = {}) {
     throw new Error("Project configuration changed while its trust token was being validated; review it and compute a new token");
   }
   const layers = [...baseLayers, ...projectLayer ? [projectLayer] : []];
+  const lease = {
+    reservationTtlMs: DEFAULT_RESERVATION_TTL_MS,
+    activeTtlMs: DEFAULT_ACTIVE_TTL_MS
+  };
+  for (const layer of layers) {
+    if (!layer.lease)
+      continue;
+    if (layer.lease.reservationTtlMinutes !== undefined) {
+      lease.reservationTtlMs = layer.lease.reservationTtlMinutes * 60000;
+    }
+    if (layer.lease.activeTtlMinutes !== undefined) {
+      lease.activeTtlMs = layer.lease.activeTtlMinutes * 60000;
+    }
+  }
   let defaultAgent;
   const agents = {};
   for (const layer of layers) {
@@ -6841,6 +7219,7 @@ function loadConfig(projectDirectory, options = {}) {
   return {
     defaultAgent,
     agents: resolvedAgents,
+    lease,
     packageRoot,
     projectRoot,
     projectConfigDirectory,
@@ -6853,6 +7232,69 @@ function loadConfig(projectDirectory, options = {}) {
 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";
 
+// src/tool-permissions.ts
+function family(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", "git reflog"),
+  ...family("git rev-parse", "git rev-list", "git show-ref", "git cat-file", "git symbolic-ref"),
+  ...family("git ls-files", "git ls-remote", "git grep"),
+  ...family("git branch", "git remote", "git stash list", "git tag", "git describe"),
+  ...family("git config --get", "git config --get-regexp"),
+  ...family("git -C")
+];
+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 tag -a", "git tag -v", "git tag --list"),
+  ...family("git stash", "git cherry-pick", "git revert"),
+  ...family("git switch", "git checkout -b", "git worktree list", "git worktree add")
+];
+var GIT_ENV_PREFIXES = ["GIT_OPTIONAL_LOCKS=0"];
+function withEnvPrefixes(rule, prefixes = GIT_ENV_PREFIXES) {
+  return prefixes.map((prefix) => ({
+    action: rule.action,
+    resource: `${prefix} ${rule.resource}`,
+    effect: rule.effect
+  }));
+}
+
 // src/agent-permissions.ts
 function normalizeMcpName(name) {
   return name.replaceAll(/[^A-Za-z0-9_-]/g, "_");
@@ -6872,15 +7314,24 @@ function buildAgentPermissions(agent, mcpServers) {
     });
     result.push(...agent.permissions.filter((rule) => rule.action.startsWith(prefix)));
   }
+  for (const rule of agent.permissions) {
+    if (rule.action !== "shell")
+      continue;
+    if (!/(^|\s|["'])git(?:$|\s)/.test(rule.resource))
+      continue;
+    if (rule.resource.startsWith("GIT_"))
+      continue;
+    result.push(...withEnvPrefixes(rule));
+  }
   return result;
 }
 
 // src/release-metadata.ts
 var PACKAGE_NAME = "@nail00749/agent-gvozd";
-var PACKAGE_VERSION = "0.1.2";
+var PACKAGE_VERSION = "0.1.3";
 var PACKAGE_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
 var SUPPORTED_OPENCODE_VERSION = "0.0.0-beta-19425";
-var CONFIG_SCHEMA_VERSION = 1;
+var CONFIG_SCHEMA_VERSION = 2;
 
 // src/constants.ts
 var GENERATED_MARKER = "# Generated by agent-gvozd sync. Do not edit this file directly.";
@@ -6897,7 +7348,13 @@ function hasGeneratedPluginMarker(content) {
 function hasGeneratedSchemaMarker(content) {
   const errors = [];
   const value = parse2(content, errors, { allowTrailingComma: true, disallowComments: false });
-  return errors.length === 0 && value !== null && typeof value === "object" && !Array.isArray(value) && value.$comment === GENERATED_PLUGIN_MARKER && value["x-agent-gvozd-schema-version"] === CONFIG_SCHEMA_VERSION;
+  if (errors.length > 0 || value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  if (value.$comment !== GENERATED_PLUGIN_MARKER)
+    return false;
+  const version = value["x-agent-gvozd-schema-version"];
+  return typeof version === "number" && Number.isSafeInteger(version) && version >= 1 && version <= CONFIG_SCHEMA_VERSION;
 }
 function stable(value) {
   if (Array.isArray(value))
@@ -7363,7 +7820,7 @@ async function runDoctor(input) {
     checks.push({ id: "runtime-agents", status: "fail", summary: `runtime agent check failed: ${redactDiagnostic(error)}`, remediation: `${input.client.executable} service restart` });
   }
   checks.push(config ? checkLegacy(config) : { id: "legacy-local", status: "warn", summary: "legacy duplicates could not be checked" });
-  return { schemaVersion: 1, status: aggregate(checks), checks };
+  return { schemaVersion: CONFIG_SCHEMA_VERSION, status: aggregate(checks), checks };
 }
 function doctorExitCode(report) {
   return report.status === "fail" ? 1 : 0;
@@ -7388,7 +7845,7 @@ function doctorOperationalFailure(error) {
     summary: `OpenCode discovery failed: ${redactDiagnostic(error)}`,
     remediation: `Install OpenCode ${SUPPORTED_OPENCODE_VERSION} and run gvozd doctor again`
   }];
-  return { schemaVersion: 1, status: "fail", checks };
+  return { schemaVersion: CONFIG_SCHEMA_VERSION, status: "fail", checks };
 }
 
 // src/cli/setup.ts
@@ -7550,8 +8007,10 @@ function assertWriteable(path, label) {
 function legacySchemaMatches(source, generated) {
   try {
     const previous = JSON.parse(source);
-    if (previous.$comment !== undefined || ![undefined, 1].includes(previous["x-agent-gvozd-schema-version"]))
+    const previousVersion = previous["x-agent-gvozd-schema-version"];
+    if (previous.$comment !== undefined || previousVersion !== undefined && previousVersion !== CONFIG_SCHEMA_VERSION) {
       return false;
+    }
     if (previous.$id !== "https://example.invalid/agent-gvozd.schema.json")
       return false;
     return generated ? isEquivalentLegacySchema(source, generated) : true;