@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/{chunk-ZW55JB7N.js → chunk-PUVDKJ2Y.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-5TSRNF4G.js";
 import {
   authStoragePath
-} from "./chunk-WNP7O5WZ.js";
+} from "./chunk-ID64D7PE.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -35,4 +35,4 @@ export {
   printPlaintextCredentialWarning,
   credentialWriteFailed
 };
-//# sourceMappingURL=chunk-ZW55JB7N.js.map
+//# sourceMappingURL=chunk-PUVDKJ2Y.js.map

package/dist/{chunk-BTGG6BG2.js → chunk-QWGDJJYJ.js}

@@ -1,43 +1,50 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   migrateSettingsV1Document
-} from "./chunk-AP73CFDC.js";
+} from "./chunk-5ICU3EUH.js";
 import {
   parseAgentRecipeSchema
-} from "./chunk-ZJLUDYFY.js";
+} from "./chunk-RRNP2ANY.js";
 import {
   parseFleetContract
-} from "./chunk-CTJ4RNAA.js";
+} from "./chunk-2VIKGWFZ.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
+import {
+  extensionBaseDir,
+  extensionContentDigest,
+  installExtension,
+  listInstalledExtensions,
+  loadManifestFromRoot
+} from "./chunk-5MEZN6CB.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-IG7BCQBA.js";
+} from "./chunk-B4OAX3SI.js";
 import {
   readSettings,
   settingsPath,
   updateSettings,
   validateSettings
-} from "./chunk-EIMVLWB3.js";
+} from "./chunk-GHS5EBTQ.js";
 import {
   readClioVersion
 } from "./chunk-IWHMRKLL.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-BWW4HLO4.js";
+} from "./chunk-UXCU4E3T.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
-import {
-  clioConfigDir,
-  resolveClioDirs
-} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceBackupPath,
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
+import {
+  clioConfigDir,
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
 import {
   __toESM,
   init_esm_shims
@@ -47,7 +54,18 @@ import {
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync
+} from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
 var PROJECT_CONTEXT_FILES = ["CLIO-CODER.md", "AGENTS.md", "CODEX.md", "GEMINI.md", "CLAUDE.md"];
 var SETTINGS_FRAGMENT_PATH = "settings.fragment.yaml";
@@ -218,7 +236,14 @@ function createShareArchive(options = {}) {
   if (includes.includeExtensions) {
     for (const scope of scopes) {
       const root = scope === "user" ? path.join(clioConfigDir(), "extensions") : path.join(cwd, ".clio-coder", "extensions");
-      addTree(files, "extension", scope, root, `${scope}/extensions`, (rel) => path.basename(rel) !== "state.json");
+      addTree(
+        files,
+        "extension",
+        scope,
+        root,
+        `${scope}/extensions`,
+        (relativePath) => !relativePath.split("/")[0]?.startsWith(".") && path.basename(relativePath) !== "state.json"
+      );
     }
   }
   if (includes.includeSettings) {
@@ -427,6 +452,79 @@ function preflightImportTargets(archive, options) {
   if (diagnostics.length > 0) return { targets: [], diagnostics };
   return { targets, diagnostics };
 }
+function withStagedExtensionPackage(input, fn) {
+  const stagingParent = mkdtempSync(path.join(tmpdir(), "clio-share-extension-"));
+  const root = path.join(stagingParent, input.id);
+  try {
+    mkdirSync(root, { recursive: true });
+    for (const file of input.files) safeResourceWrite(path.join(root, file.relativePath), file.buffer);
+    return fn(root);
+  } finally {
+    rmSync(stagingParent, { recursive: true, force: true });
+  }
+}
+function prepareExtensionPackages(targets, options) {
+  const diagnostics = [];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    if (target.entry.type !== "extension") continue;
+    const segments = relativePathSegments(target.entry.relativePath);
+    const id = segments?.[0];
+    const packagePath = segments?.slice(1).join("/");
+    if (!id || !packagePath) {
+      diagnostics.push({
+        type: "error",
+        message: `extension archive path must be <id>/<package-path>: ${pathDiagnostic(target.entry)}`,
+        path: target.entry.relativePath
+      });
+      continue;
+    }
+    const scope = target.scope;
+    const key = `${scope}\0${id}`;
+    const group = grouped.get(key) ?? { id, scope, files: [] };
+    if (group.files.some((file) => file.relativePath === packagePath)) {
+      diagnostics.push({ type: "error", message: `duplicate extension archive path ${target.entry.relativePath}` });
+      continue;
+    }
+    group.files.push({ relativePath: packagePath, buffer: target.buffer });
+    grouped.set(key, group);
+  }
+  const packages = [];
+  for (const group of [...grouped.values()].sort((a, b) => `${a.scope}/${a.id}`.localeCompare(`${b.scope}/${b.id}`))) {
+    try {
+      const contentDigest = withStagedExtensionPackage(group, (root) => {
+        const candidate = loadManifestFromRoot(root);
+        if (!candidate.valid || !candidate.manifest) {
+          throw new Error(candidate.diagnostics.map((diagnostic) => diagnostic.message).join("; ") || "manifest is invalid");
+        }
+        if (candidate.manifest.id !== group.id) {
+          throw new Error(`manifest id ${candidate.manifest.id} does not match archive package ${group.id}`);
+        }
+        return extensionContentDigest(root);
+      });
+      const cwd = path.resolve(options.cwd ?? process.cwd());
+      const targetRoot = path.join(extensionBaseDir(group.scope, cwd), group.id);
+      const existing = listInstalledExtensions(cwd, { scope: group.scope, all: true }).find(
+        (extension) => extension.id === group.id && extension.rootPath === targetRoot
+      );
+      const alreadyVerified = existing?.valid === true && existing.provenance?.contentDigest === contentDigest && existing.observedContentDigest === contentDigest;
+      if (existsSync(targetRoot) && !alreadyVerified && !options.force) {
+        diagnostics.push({
+          type: "conflict",
+          message: `extension ${group.id} is not already installed with the archive's verified digest; re-run with --force to use the canonical installer`,
+          path: targetRoot
+        });
+      }
+      packages.push({ ...group, contentDigest, install: !alreadyVerified });
+    } catch (error) {
+      diagnostics.push({
+        type: "error",
+        message: `extension ${group.id} in share archive is invalid: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  return { packages, diagnostics };
+}
 function versionDiagnostics(archive) {
   const current = readClioVersion();
   const [curMajor, curMinor] = current.split(".");
@@ -473,14 +571,21 @@ function prepareShareImport(filePath, options = {}) {
       archive: null,
       actions: [],
       diagnostics: [{ type: "error", message: err instanceof Error ? err.message : String(err), path: filePath }],
-      targets: []
+      targets: [],
+      extensionPackages: []
     };
   }
   const diagnostics = [...versionDiagnostics(archive)];
   const actions = [];
   const preflight = preflightImportTargets(archive, options);
   if (preflight.diagnostics.length > 0) {
-    return { archive, actions: [], diagnostics: [...diagnostics, ...preflight.diagnostics], targets: [] };
+    return {
+      archive,
+      actions: [],
+      diagnostics: [...diagnostics, ...preflight.diagnostics],
+      targets: [],
+      extensionPackages: []
+    };
   }
   for (const targetInfo of preflight.targets) {
     const { entry, target, scope, buffer } = targetInfo;
@@ -523,7 +628,9 @@ function prepareShareImport(filePath, options = {}) {
     }
     actions.push({ action: "write", type: entry.type, scope, path: target });
   }
-  return { archive, actions, diagnostics, targets: preflight.targets };
+  const extensions = prepareExtensionPackages(preflight.targets, options);
+  diagnostics.push(...extensions.diagnostics);
+  return { archive, actions, diagnostics, targets: preflight.targets, extensionPackages: extensions.packages };
 }
 function publicImportPlan(prepared, recovery) {
   return {
@@ -559,10 +666,42 @@ function importShareArchive(filePath, options = {}) {
   };
   let failed;
   try {
+    for (const extensionPackage of prepared.extensionPackages) {
+      if (!extensionPackage.install) continue;
+      const cwd = path.resolve(options.cwd ?? process.cwd());
+      failed = path.join(extensionBaseDir(extensionPackage.scope, cwd), extensionPackage.id);
+      const result = withStagedExtensionPackage(
+        extensionPackage,
+        (root) => installExtension(root, {
+          cwd,
+          scope: extensionPackage.scope,
+          ...options.force !== void 0 ? { force: options.force } : {}
+        })
+      );
+      for (const backup of [result.recovery?.stateBackup, result.recovery?.packageBackup]) {
+        if (backup && !backups.includes(backup)) backups.push(backup);
+      }
+      const errors = result.diagnostics.filter((diagnostic) => diagnostic.type === "error");
+      if (!result.extension || errors.length > 0) {
+        throw new Error(errors.map((diagnostic) => diagnostic.message).join("; ") || "canonical install failed");
+      }
+      if (result.extension.provenance?.contentDigest !== extensionPackage.contentDigest) {
+        throw new Error(`canonical install digest mismatch for extension ${extensionPackage.id}`);
+      }
+      for (const diagnostic of result.diagnostics) {
+        prepared.diagnostics.push({
+          type: "warning",
+          message: diagnostic.message,
+          ...diagnostic.path ? { path: diagnostic.path } : {}
+        });
+      }
+      if (!written.includes(result.extension.rootPath)) written.push(result.extension.rootPath);
+      failed = void 0;
+    }
     for (let index = 0; index < prepared.targets.length; index += 1) {
       const targetInfo = prepared.targets[index];
       const action = prepared.actions[index];
-      if (!targetInfo || !action || action.action === "skip") continue;
+      if (!targetInfo || !action || action.action === "skip" || targetInfo.entry.type === "extension") continue;
       failed = targetInfo.target;
       if (targetInfo.entry.type === "settings") {
         const path2 = mergeSettingsFragment(targetInfo.buffer);
@@ -577,7 +716,7 @@ function importShareArchive(filePath, options = {}) {
       );
       failed = void 0;
     }
-    return plan;
+    return publicImportPlan(prepared, backups.length > 0 ? { written, backups } : void 0);
   } catch (err) {
     if (failed) {
       const expectedBackup = safeResourceBackupPath(failed);
@@ -596,7 +735,7 @@ function importShareArchive(filePath, options = {}) {
           ...prepared.diagnostics,
           {
             type: "error",
-            message: `share import failed while writing${failed ? ` ${failed}` : ""}: ${reason}`,
+            message: `share import failed${failed ? ` while importing ${failed}` : ""}: ${reason}`,
             ...failed ? { path: failed } : {}
           }
         ]
@@ -653,4 +792,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-BTGG6BG2.js.map
+//# sourceMappingURL=chunk-QWGDJJYJ.js.map

package/dist/chunk-R6Q67RJH.js

@@ -0,0 +1,134 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/wiki/plan.ts
+init_esm_shims();
+var WIKI_DEPTH_STRATEGY = {
+  simple: { areaDepth: 1, areaShare: 0.08, minAreaLines: 400 },
+  medium: { areaDepth: 2, areaShare: 0.03, minAreaLines: 250 },
+  detailed: { areaDepth: 3, areaShare: 8e-3, minAreaLines: 150 }
+};
+var MAX_PAGE_SOURCES = 8;
+function areaForPath(path, maxDepth) {
+  const directories = path.split("/").filter(Boolean).slice(0, -1);
+  if (directories.length === 0) return ".";
+  return directories.slice(0, Math.max(1, maxDepth)).join("/");
+}
+function classifyDepth(sourceFiles, sourceLines) {
+  if (sourceFiles <= 150 && sourceLines <= 3e4) return "simple";
+  if (sourceFiles <= 800 && sourceLines <= 15e4) return "medium";
+  return "detailed";
+}
+function slugSegment(segment) {
+  const slug = segment.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : "section";
+}
+function areaSegments(area) {
+  const parts = area.split("/").filter((part) => part.length > 0 && part !== ".");
+  if (parts.length === 0) return ["root"];
+  if (parts[0] !== "src") return parts;
+  return parts.length === 1 ? ["source"] : parts.slice(1);
+}
+function pagePathForArea(area) {
+  return `${areaSegments(area).map(slugSegment).join("/")}.md`;
+}
+function titleForArea(area) {
+  const name = areaSegments(area).join(" ").replace(/[-_]+/g, " ").trim();
+  return name.length > 0 ? name.charAt(0).toUpperCase() + name.slice(1) : "Overview";
+}
+function rankedSources(files) {
+  return [...files].sort((a, b) => {
+    const roleRank = (file) => file.role === "entry" ? 0 : file.role === "test" ? 2 : 1;
+    return roleRank(a) - roleRank(b) || b.loc - a.loc || a.path.localeCompare(b.path);
+  }).slice(0, MAX_PAGE_SOURCES).map((file) => file.path);
+}
+function collectAreas(source, areaDepth) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const file of source) {
+    const key = areaForPath(file.path, areaDepth);
+    const area = byKey.get(key) ?? { key, files: [], lines: 0 };
+    area.files.push(file);
+    area.lines += Math.max(0, file.loc);
+    byKey.set(key, area);
+  }
+  return [...byKey.values()].sort((a, b) => b.lines - a.lines || a.key.localeCompare(b.key));
+}
+function overviewPage(source) {
+  const entries = source.filter((file) => file.role === "entry");
+  return {
+    path: "architecture.md",
+    title: "Architecture",
+    intent: "Explain what this repository is, its top-level composition, how a request or command flows through it, and where the boundaries between its major areas are.",
+    sources: rankedSources(entries.length > 0 ? entries : source),
+    status: "pending",
+    attempts: 0
+  };
+}
+function buildCandidatePlan(codewiki, depth) {
+  const source = codewiki.files.filter((file) => file.lang !== "config");
+  const totalLines = source.reduce((total, file) => total + Math.max(0, file.loc), 0);
+  const { areaDepth, areaShare, minAreaLines } = WIKI_DEPTH_STRATEGY[depth];
+  const threshold = Math.max(minAreaLines, Math.floor(totalLines * areaShare));
+  const areas = collectAreas(source, areaDepth);
+  const included = areas.filter((area) => area.lines >= threshold);
+  const selected = included.length > 0 ? included : areas.slice(0, 1);
+  const selectedKeys = new Set(selected.map((area) => area.key));
+  const extras = /* @__PURE__ */ new Map();
+  for (const area of areas) {
+    if (selectedKeys.has(area.key)) continue;
+    const ancestor = selected.find((candidate) => area.key.startsWith(`${candidate.key}/`));
+    const host = ancestor?.key ?? selected[0]?.key;
+    if (host === void 0) continue;
+    extras.set(host, [...extras.get(host) ?? [], ...area.files]);
+  }
+  const pages = selected.map((area) => {
+    const files = [...area.files, ...extras.get(area.key) ?? []];
+    return {
+      path: pagePathForArea(area.key),
+      title: titleForArea(area.key),
+      intent: `Document ${area.key} (${area.files.length} indexed files, ${area.lines} lines): what it owns, its entry points and important symbols, the state and lifecycle invariants it enforces, an upstream caller and a downstream dependency, the focused tests that prove its behavior, and what to watch when editing it.`,
+      sources: rankedSources(files),
+      status: "pending",
+      attempts: 0
+    };
+  });
+  return dedupePagePaths({
+    version: 1,
+    overview: "",
+    pages: [overviewPage(source), ...pages]
+  });
+}
+function dedupePagePaths(plan) {
+  const seen = /* @__PURE__ */ new Set();
+  const pages = [];
+  for (const page of plan.pages) {
+    let path = page.path;
+    let suffix = 2;
+    while (seen.has(path)) {
+      path = page.path.replace(/\.md$/, `-${suffix}.md`);
+      suffix += 1;
+    }
+    seen.add(path);
+    pages.push({ ...page, path });
+  }
+  return { ...plan, pages };
+}
+function planWikiGeneration(codewiki, requestedDepth = "auto") {
+  const source = codewiki.files.filter((file) => file.lang !== "config");
+  const sourceFiles = source.length;
+  const sourceLines = source.reduce((total, file) => total + Math.max(0, file.loc), 0);
+  const depth = requestedDepth === "auto" ? classifyDepth(sourceFiles, sourceLines) : requestedDepth;
+  return { requestedDepth, depth, sourceFiles, sourceLines, plan: buildCandidatePlan(codewiki, depth) };
+}
+
+export {
+  WIKI_DEPTH_STRATEGY,
+  areaForPath,
+  classifyDepth,
+  pagePathForArea,
+  buildCandidatePlan,
+  planWikiGeneration
+};
+//# sourceMappingURL=chunk-R6Q67RJH.js.map

package/dist/{chunk-ZJLUDYFY.js → chunk-RRNP2ANY.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  loadSkills
-} from "./chunk-HUAS7ITX.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
+import {
+  loadSkills
+} from "./chunk-LDJG7DW3.js";
 import {
   enabledExtensionResourceRoots
-} from "./chunk-SUW5DORT.js";
+} from "./chunk-7DRAWPTZ.js";
 import {
   assertAgentSpecPolicy,
   isAgentAudience,
@@ -19,7 +19,7 @@ import {
   isShadowAgent,
   normalizeAgentSpec,
   parseResultContract
-} from "./chunk-IG7BCQBA.js";
+} from "./chunk-B4OAX3SI.js";
 import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
@@ -396,4 +396,4 @@ export {
   parseAgentRecipeSchema,
   discoverAgentRecipes
 };
-//# sourceMappingURL=chunk-ZJLUDYFY.js.map
+//# sourceMappingURL=chunk-RRNP2ANY.js.map

package/dist/{chunk-PVAMAVBB.js → chunk-RSJ25QSL.js}

@@ -4,7 +4,7 @@ import {
   extractCommandDeleteTargets,
   extractCommandWriteTargets,
   toolMutationPaths
-} from "./chunk-GCSMB2KY.js";
+} from "./chunk-I7ZPNEJM.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
@@ -384,9 +384,109 @@ function asRecord(value) {
   return value !== null && typeof value === "object" ? value : null;
 }
 
+// src/domains/safety/loop-detector.ts
+init_esm_shims();
+var DEFAULT_WINDOW_MS = 3e4;
+var DEFAULT_MAX_REPEATS = 3;
+var DEFAULT_KEEP_LAST_ATTEMPTS = 48;
+function createLoopState(opts) {
+  const windowMs = opts?.windowMs ?? DEFAULT_WINDOW_MS;
+  const maxRepeats = opts?.maxRepeats ?? DEFAULT_MAX_REPEATS;
+  const keepLastAttempts = opts?.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
+  return { recent: [], windowMs, maxRepeats, keepLastAttempts };
+}
+function hashToolCall(tool, args) {
+  let argPart;
+  try {
+    argPart = canonicalSerialize(args ?? {}, /* @__PURE__ */ new WeakSet());
+  } catch {
+    argPart = "<unrepresentable>";
+  }
+  return `${tool}${argPart}`;
+}
+function canonicalSerialize(value, seen) {
+  if (value === null) return "null";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`canonicalSerialize: non-finite number ${String(value)} is not representable`);
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") {
+    throw new Error("canonicalSerialize: bigint is not representable");
+  }
+  if (typeof value === "symbol" || typeof value === "function" || value === void 0) {
+    throw new Error(`canonicalSerialize: ${typeof value} is not representable`);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
+    seen.add(value);
+    try {
+      const parts = [];
+      for (let i = 0; i < value.length; i++) {
+        if (!(i in value) || value[i] === void 0) {
+          parts.push("null");
+          continue;
+        }
+        parts.push(canonicalSerialize(value[i], seen));
+      }
+      return `[${parts.join(",")}]`;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  if (typeof value === "object") {
+    if (value instanceof Date) {
+      const jsonValue = value.toJSON();
+      return jsonValue === null ? "null" : JSON.stringify(jsonValue);
+    }
+    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
+    seen.add(value);
+    const obj = value;
+    try {
+      const keys = Object.keys(obj).sort();
+      const parts = [];
+      for (const key of keys) {
+        const child = obj[key];
+        if (child === void 0) continue;
+        parts.push(`${JSON.stringify(key)}:${canonicalSerialize(child, seen)}`);
+      }
+      return `{${parts.join(",")}}`;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  throw new Error(`canonicalSerialize: unsupported value of type ${typeof value}`);
+}
+function observe(state, key, now) {
+  const cutoff = now - state.windowMs;
+  const keepLast = state.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
+  const appended = [...state.recent, { key, at: now }];
+  const floorStart = Math.max(0, appended.length - keepLast);
+  const next = appended.filter((entry, index) => index >= floorStart || entry.at >= cutoff);
+  let count = 0;
+  for (const entry of next) {
+    if (entry.key === key) count += 1;
+  }
+  const looping = count >= state.maxRepeats;
+  const newState = {
+    recent: next,
+    windowMs: state.windowMs,
+    maxRepeats: state.maxRepeats,
+    keepLastAttempts: keepLast
+  };
+  return [newState, { looping, key, count }];
+}
+
 export {
+  createLoopState,
+  hashToolCall,
+  observe,
   DEFAULT_RECENT_ENTRY_LIMIT,
   assessFinishContract,
   typedValidationSummary
 };
-//# sourceMappingURL=chunk-PVAMAVBB.js.map
+//# sourceMappingURL=chunk-RSJ25QSL.js.map

package/dist/{chunk-NLFAQR7Z.js → chunk-S66XZJOF.js}

@@ -13,14 +13,6 @@ var GUARDRAIL_DEFAULTS = {
   observationTurnBudgetBytes: 192 * 1024,
   internalDispatchTimeoutMs: 15 * 60 * 1e3
 };
-var GUARDRAIL_ENV_VARS = {
-  turnToolCallBudget: "CLIO_CODER_TURN_TOOL_CALL_BUDGET",
-  workerToolCallCap: "CLIO_CODER_WORKER_TOOL_CALL_CAP",
-  maxDispatchRuns: "CLIO_CODER_MAX_DISPATCH_RUNS",
-  readMaxBytes: "CLIO_CODER_READ_MAX_BYTES",
-  observationTurnBudgetBytes: "CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES",
-  internalDispatchTimeoutMs: "CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS"
-};
 function guardrailValuesFromSettings(settings) {
   return {
     turnToolCallBudget: settings.safety.limits.chatToolCallsPerTurn,
@@ -31,9 +23,6 @@ function guardrailValuesFromSettings(settings) {
     internalDispatchTimeoutMs: settings.fleet.limits.internalRunTimeoutMs
   };
 }
-var GUARDRAIL_ENV_ALIASES = {
-  maxDispatchRuns: "CLIO_CODER_MAX_RUNS"
-};
 function workerSynthesisReserveDirective(remaining, cap) {
   return `budget reserve: only ${remaining} of your ${cap} tool calls remain, and they are reserved for verification reads and synthesis. Stop broad exploration now: re-read the locations you will cite, then answer in prose. Calls that are not reads will be blocked.`;
 }
@@ -59,21 +48,12 @@ var configured = {};
 function configureGuardrails(values) {
   configured = { ...values ?? {} };
 }
-function parsePositiveSafeInt(raw) {
-  if (raw === void 0) return void 0;
-  const normalized = raw.trim();
-  if (!/^[1-9]\d*$/.test(normalized)) return void 0;
-  const parsed = Number(normalized);
-  return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-function resolveGuardrail(key, env = process.env) {
-  const alias = GUARDRAIL_ENV_ALIASES[key];
-  return parsePositiveSafeInt(env[GUARDRAIL_ENV_VARS[key]]) ?? (alias ? parsePositiveSafeInt(env[alias]) : void 0) ?? configured[key] ?? GUARDRAIL_DEFAULTS[key];
+function resolveGuardrail(key) {
+  return configured[key] ?? GUARDRAIL_DEFAULTS[key];
 }
 
 export {
   GUARDRAIL_DEFAULTS,
-  GUARDRAIL_ENV_VARS,
   guardrailValuesFromSettings,
   workerSynthesisReserveDirective,
   workerSynthesisReserveBlockReason,
@@ -85,4 +65,4 @@ export {
   configureGuardrails,
   resolveGuardrail
 };
-//# sourceMappingURL=chunk-NLFAQR7Z.js.map
+//# sourceMappingURL=chunk-S66XZJOF.js.map