@iowarp/clio-coder 0.3.2 → 0.3.4

package/dist/chunk-CFGTUFWB.js

@@ -0,0 +1,67 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/engine/strip-tokenizer-sentinels.ts
+init_esm_shims();
+var KNOWN_SENTINELS = [
+  "<|endoftext|>",
+  "<|im_start|>",
+  "<|im_end|>",
+  "<|eot_id|>",
+  "<|end_of_turn|>",
+  "<|fim_prefix|>",
+  "<|fim_middle|>",
+  "<|fim_suffix|>",
+  "<|file_separator|>",
+  "<s>",
+  "</s>"
+];
+var SENTINEL_RE = new RegExp(KNOWN_SENTINELS.map((s) => s.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")).join("|"), "g");
+var MAX_SENTINEL_LEN = KNOWN_SENTINELS.reduce((max, s) => s.length > max ? s.length : max, 0);
+function stripTokenizerSentinels(text) {
+  if (text.length === 0) return text;
+  return text.replace(SENTINEL_RE, "");
+}
+function isSentinelPrefix(tail) {
+  if (tail.length === 0) return false;
+  for (const sentinel of KNOWN_SENTINELS) {
+    if (sentinel.length > tail.length && sentinel.startsWith(tail)) return true;
+  }
+  return false;
+}
+function createSentinelStripper() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      if (chunk.length === 0) return "";
+      buffer += chunk;
+      const stripped = buffer.replace(SENTINEL_RE, "");
+      const holdMax = Math.min(stripped.length, MAX_SENTINEL_LEN - 1);
+      let hold = 0;
+      for (let take = holdMax; take > 0; take--) {
+        const tail = stripped.slice(stripped.length - take);
+        if (isSentinelPrefix(tail)) {
+          hold = take;
+          break;
+        }
+      }
+      const safe = hold === 0 ? stripped : stripped.slice(0, stripped.length - hold);
+      buffer = hold === 0 ? "" : stripped.slice(stripped.length - hold);
+      return safe;
+    },
+    flush() {
+      if (buffer.length === 0) return "";
+      const remainder = buffer.replace(SENTINEL_RE, "");
+      buffer = "";
+      return remainder;
+    }
+  };
+}
+
+export {
+  stripTokenizerSentinels,
+  createSentinelStripper
+};
+//# sourceMappingURL=chunk-CFGTUFWB.js.map

package/dist/{chunk-CBCAPZAA.js → chunk-E25LMLRW.js}

@@ -5,7 +5,7 @@ import {
   settingsPath,
   updateSavedSettingsDocument,
   validateSettings
-} from "./chunk-A3CYT5EX.js";
+} from "./chunk-AD2SYQYC.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -226,4 +226,4 @@ export {
   updateLayeredSettings,
   settingsSourceFor
 };
-//# sourceMappingURL=chunk-CBCAPZAA.js.map
+//# sourceMappingURL=chunk-E25LMLRW.js.map

package/dist/{chunk-G2DE3C7R.js → chunk-EDRHSCIE.js}

@@ -6,7 +6,7 @@ import {
   cloneApprovedAssignmentRoute,
   isApprovedAssignmentRoute,
   isToolProfileName
-} from "./chunk-MQSRRFWA.js";
+} from "./chunk-ZYKPLLNQ.js";
 import {
   ROUTE_POLICY_VERSION,
   isExecutionRole,
@@ -14,10 +14,10 @@ import {
   isRoutingIntent,
   parseRoutingIntent,
   requestExecutionRole
-} from "./chunk-GGXXDWE4.js";
+} from "./chunk-22NAGB7X.js";
 import {
   AGENT_AUTOMATION_AUTHORITIES
-} from "./chunk-5UUP6MWO.js";
+} from "./chunk-AOCYTWAV.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -641,4 +641,4 @@ export {
   withResolvedDispatchPlan,
   describeDispatchPlan
 };
-//# sourceMappingURL=chunk-G2DE3C7R.js.map
+//# sourceMappingURL=chunk-EDRHSCIE.js.map

package/dist/{chunk-4KLWL3UC.js → chunk-EFADSJET.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   durableAssistantTextFromEvent
-} from "./chunk-6EJV5X2W.js";
+} from "./chunk-QQL5RT5M.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -15,4 +15,4 @@ function assistantTextFromEvent(event) {
 export {
   assistantTextFromEvent
 };
-//# sourceMappingURL=chunk-4KLWL3UC.js.map
+//# sourceMappingURL=chunk-EFADSJET.js.map

package/dist/{chunk-M6SHUN7Q.js → chunk-FO5ZOVUY.js}

@@ -38,7 +38,7 @@ import {
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
-var CURRENT_SESSION_FORMAT_VERSION = 3;
+var CURRENT_SESSION_FORMAT_VERSION = 4;
 function cwdHash(cwd) {
   const normalized = resolve(cwd);
   return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -567,4 +567,4 @@ export {
   openSession,
   resumeSession
 };
-//# sourceMappingURL=chunk-M6SHUN7Q.js.map
+//# sourceMappingURL=chunk-FO5ZOVUY.js.map

package/dist/chunk-FYYLNIL5.js

@@ -0,0 +1,313 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  isProjectVerifierCheckId
+} from "./chunk-UL3WSD3F.js";
+import {
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  resolveSafeCwd
+} from "./chunk-VEZEGCGW.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/verify/catalog.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+
+// src/domains/evidence/ordering.ts
+init_esm_shims();
+function compareCodepoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/tools/verify/catalog.ts
+var PROJECT_VERIFIER_CATALOG_RELATIVE_PATH = ".clio-coder/verifiers.yaml";
+var PROJECT_VERIFIER_CATALOG_VERSION = 1;
+var PROJECT_VERIFIER_CATALOG_CAPS = Object.freeze({
+  fileBytes: 256 * 1024,
+  checks: 128,
+  idBytes: 64,
+  descriptionBytes: 512,
+  argvEntries: 64,
+  argumentBytes: 4096,
+  cwdBytes: 512,
+  timeoutMs: 9e5,
+  tags: 16,
+  tagBytes: 32
+});
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "checks"]);
+var CHECK_FIELDS = /* @__PURE__ */ new Set(["id", "description", "command", "cwd", "timeoutMs", "tags"]);
+var TAG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+var SHELL_EXECUTABLES = /* @__PURE__ */ new Set([
+  "bash",
+  "cmd",
+  "command.com",
+  "dash",
+  "fish",
+  "ksh",
+  "powershell",
+  "pwsh",
+  "sh",
+  "tcsh",
+  "zsh"
+]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function utf8Bytes(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+function catalogDiagnostic(message) {
+  return { ok: false, reason: `${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}: ${message}` };
+}
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key)).sort(compareCodepoints);
+}
+function relativeCwd(workspaceRoot, resolved) {
+  const relative = path.relative(workspaceRoot, resolved);
+  return relative.length === 0 ? "." : relative.split(path.sep).join("/");
+}
+function safelyResolveCatalogCwd(rawCwd, workspaceRoot, location) {
+  if (path.isAbsolute(rawCwd) || path.win32.isAbsolute(rawCwd)) {
+    return new Error(`${location} must be repository-relative; absolute cwd '${rawCwd}' is not allowed`);
+  }
+  let resolved;
+  try {
+    resolved = resolveSafeCwd(rawCwd, workspaceRoot);
+  } catch {
+    return new Error(`${location} escapes the workspace root: '${rawCwd}'`);
+  }
+  let realCwd;
+  try {
+    const cwdStat = statSync(resolved);
+    if (!cwdStat.isDirectory()) return new Error(`${location} is not a directory: '${rawCwd}'`);
+    const realRoot = realpathSync(workspaceRoot);
+    realCwd = realpathSync(resolved);
+    resolveSafeCwd(realCwd, realRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("escapes workspace root")) {
+      return new Error(`${location} escapes the workspace root through a symbolic link: '${rawCwd}'`);
+    }
+    return new Error(`${location} cannot be resolved as a repository directory: '${rawCwd}' (${message})`);
+  }
+  return { declared: relativeCwd(workspaceRoot, resolved), execution: realCwd };
+}
+function resolveProjectVerifierExecutionCwd(rawCwd, workspaceRoot) {
+  const resolution = safelyResolveCatalogCwd(rawCwd, workspaceRoot, "project check cwd");
+  return resolution instanceof Error ? resolution : resolution.execution;
+}
+function validateId(value, location) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (utf8Bytes(value) > PROJECT_VERIFIER_CATALOG_CAPS.idBytes) {
+    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.idBytes}-byte cap`);
+  }
+  if (!isProjectVerifierCheckId(value)) {
+    return new Error(`${location} must match /^[a-z0-9][a-z0-9._:-]*$/`);
+  }
+  if (value === "frontend") return new Error(`${location} uses reserved built-in check id 'frontend'`);
+  return value;
+}
+function validateDescription(value, location) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.trim() !== value || hasControlCharacter(value)) {
+    return new Error(`${location} must be trimmed, single-line text without control characters`);
+  }
+  if (utf8Bytes(value) > PROJECT_VERIFIER_CATALOG_CAPS.descriptionBytes) {
+    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.descriptionBytes}-byte cap`);
+  }
+  return value;
+}
+function validateCommand(value, location) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return new Error(`${location} must be a non-empty argv string array; shell command strings are not allowed`);
+  }
+  if (value.length > PROJECT_VERIFIER_CATALOG_CAPS.argvEntries) {
+    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.argvEntries}-entry cap`);
+  }
+  const command = [];
+  for (const [index, entry] of value.entries()) {
+    const entryLocation = `${location}[${index}]`;
+    if (typeof entry !== "string" || entry.length === 0) {
+      return new Error(`${entryLocation} must be a non-empty string`);
+    }
+    if (entry.includes("\0")) return new Error(`${entryLocation} must not contain a NUL byte`);
+    if (utf8Bytes(entry) > PROJECT_VERIFIER_CATALOG_CAPS.argumentBytes) {
+      return new Error(`${entryLocation} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.argumentBytes}-byte cap`);
+    }
+    command.push(entry);
+  }
+  const executable = command[0] ?? "";
+  if (/\s/u.test(executable)) {
+    return new Error(`${location}[0] must be one executable token, not a shell command string`);
+  }
+  const executableName = path.basename(executable).toLowerCase().replace(/\.exe$/u, "");
+  if (SHELL_EXECUTABLES.has(executableName)) {
+    return new Error(`${location}[0] may not invoke shell executable '${executable}'`);
+  }
+  return command;
+}
+function validateTimeout(value, location) {
+  if (!Number.isInteger(value) || typeof value !== "number" || value <= 0) {
+    return new Error(`${location} must be a positive integer number of milliseconds`);
+  }
+  if (value > PROJECT_VERIFIER_CATALOG_CAPS.timeoutMs) {
+    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.timeoutMs}ms cap`);
+  }
+  return value;
+}
+function validateTags(value, location) {
+  if (!Array.isArray(value)) return new Error(`${location} must be an array of bounded tag strings`);
+  if (value.length > PROJECT_VERIFIER_CATALOG_CAPS.tags) {
+    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.tags}-tag cap`);
+  }
+  const tags = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, entry] of value.entries()) {
+    const entryLocation = `${location}[${index}]`;
+    if (typeof entry !== "string" || entry.length === 0) {
+      return new Error(`${entryLocation} must be a non-empty string`);
+    }
+    if (utf8Bytes(entry) > PROJECT_VERIFIER_CATALOG_CAPS.tagBytes) {
+      return new Error(`${entryLocation} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.tagBytes}-byte cap`);
+    }
+    if (!TAG_PATTERN.test(entry)) return new Error(`${entryLocation} must match /^[a-z0-9][a-z0-9._-]*$/`);
+    if (seen.has(entry)) return new Error(`${location} contains duplicate tag '${entry}'`);
+    seen.add(entry);
+    tags.push(entry);
+  }
+  return tags;
+}
+function sourcePathInsideWorkspace(catalogPath, workspaceRoot) {
+  try {
+    const realRoot = realpathSync(workspaceRoot);
+    const realCatalogPath = realpathSync(catalogPath);
+    resolveSafeCwd(realCatalogPath, realRoot);
+    return realCatalogPath;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`catalog file must resolve inside the workspace root (${message})`);
+  }
+}
+function loadProjectVerifierCatalog(workspaceRoot) {
+  const catalogPath = path.join(workspaceRoot, PROJECT_VERIFIER_CATALOG_RELATIVE_PATH);
+  if (!existsSync(catalogPath)) return { ok: true, source: null };
+  const safeSourcePath = sourcePathInsideWorkspace(catalogPath, workspaceRoot);
+  if (safeSourcePath instanceof Error) return catalogDiagnostic(safeSourcePath.message);
+  let text;
+  try {
+    const stats = statSync(safeSourcePath);
+    if (!stats.isFile()) return catalogDiagnostic("catalog path must be a regular file");
+    if (stats.size > PROJECT_VERIFIER_CATALOG_CAPS.fileBytes) {
+      return catalogDiagnostic(`file exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.fileBytes}-byte cap`);
+    }
+    text = readFileSync(safeSourcePath, "utf8");
+  } catch (error) {
+    return catalogDiagnostic(`cannot read catalog (${error instanceof Error ? error.message : String(error)})`);
+  }
+  return parseProjectVerifierCatalogText(text, workspaceRoot, catalogPath);
+}
+function parseProjectVerifierCatalogText(text, workspaceRoot, catalogPath = path.join(workspaceRoot, PROJECT_VERIFIER_CATALOG_RELATIVE_PATH)) {
+  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+  if (document.errors.length > 0) {
+    return catalogDiagnostic(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
+  }
+  let parsed;
+  try {
+    parsed = document.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    return catalogDiagnostic(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) return catalogDiagnostic("root must be an object with version and checks fields");
+  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
+  if (rootUnknown.length > 0) return catalogDiagnostic(`root has unknown field(s): ${rootUnknown.join(", ")}`);
+  if (!Object.hasOwn(parsed, "version")) return catalogDiagnostic("root.version is required");
+  if (parsed.version !== PROJECT_VERIFIER_CATALOG_VERSION) {
+    return catalogDiagnostic(
+      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${PROJECT_VERIFIER_CATALOG_VERSION}`
+    );
+  }
+  if (!Object.hasOwn(parsed, "checks")) return catalogDiagnostic("root.checks is required");
+  if (!Array.isArray(parsed.checks)) return catalogDiagnostic("root.checks must be an array");
+  if (parsed.checks.length > PROJECT_VERIFIER_CATALOG_CAPS.checks) {
+    return catalogDiagnostic(`root.checks exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.checks}-check cap`);
+  }
+  const sourceRef = { kind: "project-catalog", path: catalogPath };
+  const checks = [];
+  const ids = /* @__PURE__ */ new Map();
+  for (const [index, value] of parsed.checks.entries()) {
+    const location = `checks[${index}]`;
+    if (!isRecord(value)) return catalogDiagnostic(`${location} must be an object`);
+    const checkUnknown = unknownFields(value, CHECK_FIELDS);
+    if (checkUnknown.length > 0) {
+      return catalogDiagnostic(`${location} has unknown field(s): ${checkUnknown.join(", ")}`);
+    }
+    for (const field of CHECK_FIELDS) {
+      if (!Object.hasOwn(value, field)) return catalogDiagnostic(`${location}.${field} is required`);
+    }
+    const id = validateId(value.id, `${location}.id`);
+    if (id instanceof Error) return catalogDiagnostic(id.message);
+    const duplicateIndex = ids.get(id);
+    if (duplicateIndex !== void 0) {
+      return catalogDiagnostic(`${location}.id duplicates '${id}' from checks[${duplicateIndex}].id`);
+    }
+    const description = validateDescription(value.description, `${location}.description`);
+    if (description instanceof Error) return catalogDiagnostic(description.message);
+    const command = validateCommand(value.command, `${location}.command`);
+    if (command instanceof Error) return catalogDiagnostic(command.message);
+    if (typeof value.cwd !== "string" || value.cwd.length === 0) {
+      return catalogDiagnostic(`${location}.cwd must be a non-empty repository-relative string`);
+    }
+    if (value.cwd.includes("\0")) return catalogDiagnostic(`${location}.cwd must not contain a NUL byte`);
+    if (utf8Bytes(value.cwd) > PROJECT_VERIFIER_CATALOG_CAPS.cwdBytes) {
+      return catalogDiagnostic(`${location}.cwd exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.cwdBytes}-byte cap`);
+    }
+    const cwdResolution = safelyResolveCatalogCwd(value.cwd, workspaceRoot, `${location}.cwd`);
+    if (cwdResolution instanceof Error) return catalogDiagnostic(cwdResolution.message);
+    const cwd = cwdResolution.declared;
+    const timeoutMs = validateTimeout(value.timeoutMs, `${location}.timeoutMs`);
+    if (timeoutMs instanceof Error) return catalogDiagnostic(timeoutMs.message);
+    const tags = validateTags(value.tags, `${location}.tags`);
+    if (tags instanceof Error) return catalogDiagnostic(tags.message);
+    ids.set(id, index);
+    checks.push({ id, description, command, cwd, timeoutMs, tags, source: { ...sourceRef } });
+  }
+  checks.sort((left, right) => compareCodepoints(left.id, right.id));
+  return { ok: true, source: { ...sourceRef, checks } };
+}
+function packageDeclaredCheck(id, packagePath, cwd, tags) {
+  return {
+    id,
+    description: `Run package.json script '${id}'.`,
+    command: ["npm", "run", id],
+    cwd,
+    timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+    tags,
+    source: { kind: "package.json", path: packagePath }
+  };
+}
+
+export {
+  compareCodepoints,
+  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+  PROJECT_VERIFIER_CATALOG_VERSION,
+  PROJECT_VERIFIER_CATALOG_CAPS,
+  resolveProjectVerifierExecutionCwd,
+  loadProjectVerifierCatalog,
+  parseProjectVerifierCatalogText,
+  packageDeclaredCheck
+};
+//# sourceMappingURL=chunk-FYYLNIL5.js.map

package/dist/{chunk-EPVUXGXG.js → chunk-HV5X7OR2.js}

@@ -5,44 +5,46 @@ import {
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-LBNRH5WM.js";
+} from "./chunk-3HZ5RWN2.js";
 import {
   AgentsDomainModule,
   SafetyDomainModule
-} from "./chunk-3ZXDFGR5.js";
+} from "./chunk-X6COSD2O.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-V4RXGQ5Q.js";
+} from "./chunk-KRPY7NTG.js";
 import {
   createObservabilityDomainModule
-} from "./chunk-WVO7V2QY.js";
+} from "./chunk-35MKKU5R.js";
 import {
   fallbackBootstrapOutput
-} from "./chunk-7EYHLWU7.js";
+} from "./chunk-UZHIZC5S.js";
 import {
   renderCodewikiDigest
 } from "./chunk-5WIGXA4T.js";
 import {
-  DispatchDomainModule,
+  DispatchDomainModule
+} from "./chunk-QQL5RT5M.js";
+import {
   SessionDomainModule
-} from "./chunk-6EJV5X2W.js";
+} from "./chunk-QQK64KLB.js";
 import {
   ResourcesDomainModule
 } from "./chunk-MFFY33HR.js";
 import {
   MiddlewareDomainModule
-} from "./chunk-WMSVI4G2.js";
+} from "./chunk-2LZI5CAG.js";
 import {
   UnsupportedResponseSchemaError,
   isResponseSchemaRejection
-} from "./chunk-MQSRRFWA.js";
+} from "./chunk-ZYKPLLNQ.js";
 import {
   parseJsonObjectPayload
-} from "./chunk-STBPMHSX.js";
+} from "./chunk-7RXG6QRZ.js";
 import {
   ProvidersDomainModule
-} from "./chunk-LZSJBIVT.js";
+} from "./chunk-QWU7ZBO7.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -671,4 +673,4 @@ export {
   validateInitOptions,
   bootstrapInputFromInitOptions
 };
-//# sourceMappingURL=chunk-EPVUXGXG.js.map
+//# sourceMappingURL=chunk-HV5X7OR2.js.map

package/dist/{chunk-TZTZS7QK.js → chunk-HXG4IURW.js}

@@ -1,8 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  BusChannels,
   getSharedBus
-} from "./chunk-OQ33BKR3.js";
+} from "./chunk-ZGVHUX3M.js";
+import {
+  BusChannels
+} from "./chunk-TTNYS3EA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -224,4 +226,4 @@ export {
   runWithBudget,
   getTerminationCoordinator
 };
-//# sourceMappingURL=chunk-TZTZS7QK.js.map
+//# sourceMappingURL=chunk-HXG4IURW.js.map

package/dist/{chunk-IGLFWIYI.js → chunk-K6WL7QZT.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   readStateInfo,
   runDoctor
-} from "./chunk-QTYWRVRA.js";
+} from "./chunk-VAWWTKDP.js";
 import {
   getVersionInfo
 } from "./chunk-XPLRXC72.js";
@@ -10,7 +10,7 @@ import {
   readSettings,
   settingsPath,
   updateSettings
-} from "./chunk-A3CYT5EX.js";
+} from "./chunk-AD2SYQYC.js";
 import {
   authStoragePath,
   openAuthStorage
@@ -158,4 +158,4 @@ export {
   describeUpgradeNotice,
   LifecycleDomainModule
 };
-//# sourceMappingURL=chunk-IGLFWIYI.js.map
+//# sourceMappingURL=chunk-K6WL7QZT.js.map

package/dist/chunk-K7VKOLQQ.js

@@ -0,0 +1,15 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/headless-permission.ts
+init_esm_shims();
+var HEADLESS_PERMISSION_DENIED_REASON = "clio-coder run cannot confirm permission requests; rerun interactively to approve this action.";
+var HEADLESS_PERMISSION_DENIED_MARKER = "clio-coder run cannot confirm permission requests";
+
+export {
+  HEADLESS_PERMISSION_DENIED_REASON,
+  HEADLESS_PERMISSION_DENIED_MARKER
+};
+//# sourceMappingURL=chunk-K7VKOLQQ.js.map

package/dist/{chunk-BMEMKKIT.js → chunk-KOHPCX4K.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   DEFAULT_SETTINGS_YAML
-} from "./chunk-ZDOOVTXZ.js";
+} from "./chunk-4OC57DA6.js";
 import {
   clioCacheDir,
   clioConfigDir,
@@ -143,4 +143,4 @@ function enforceHomePrefixGuard() {
 export {
   initializeClioHome
 };
-//# sourceMappingURL=chunk-BMEMKKIT.js.map
+//# sourceMappingURL=chunk-KOHPCX4K.js.map

package/dist/{chunk-V4RXGQ5Q.js → chunk-KRPY7NTG.js}

@@ -2,23 +2,25 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   readStrictLayeredSettings,
   updateLayeredSettings
-} from "./chunk-CBCAPZAA.js";
+} from "./chunk-E25LMLRW.js";
 import {
   formatSettingsFailure,
   settingsPath
-} from "./chunk-A3CYT5EX.js";
+} from "./chunk-AD2SYQYC.js";
 import {
   setGitCommitAttributionEnabled
-} from "./chunk-X75S7HFS.js";
+} from "./chunk-VEZEGCGW.js";
 import {
   resolveShutdownHookBudgetMs,
   runWithBudget,
   writeShutdownNotice
-} from "./chunk-TZTZS7QK.js";
+} from "./chunk-HXG4IURW.js";
 import {
-  BusChannels,
   getSharedBus
-} from "./chunk-OQ33BKR3.js";
+} from "./chunk-ZGVHUX3M.js";
+import {
+  BusChannels
+} from "./chunk-TTNYS3EA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -184,6 +186,7 @@ var NEXT_TURN_FIELDS = /* @__PURE__ */ new Set([
   "skills",
   "delegation",
   "compaction",
+  "context",
   "retry"
 ]);
 var RESTART_REQUIRED_FIELDS = /* @__PURE__ */ new Set([
@@ -381,4 +384,4 @@ export {
   ConfigDomainModule,
   createConfigDomainModule
 };
-//# sourceMappingURL=chunk-V4RXGQ5Q.js.map
+//# sourceMappingURL=chunk-KRPY7NTG.js.map

package/dist/chunk-LL4KHSZI.js

@@ -0,0 +1,22 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/working-set/defaults.ts
+init_esm_shims();
+var DEFAULT_WORKING_SET_SETTINGS = {
+  enabled: true,
+  policy: "structural-v1",
+  target: 0.6,
+  protectLastTurns: 6,
+  // The procedural floor sweep found marker break-even near 50 tokens. A zero
+  // floor saved only 0.167 summaries at 64k and none at 128k while reducing
+  // covered retention by 0.0076 and 0.0237. Keep 200 as the churn guard.
+  minEvictableTokens: 200
+};
+
+export {
+  DEFAULT_WORKING_SET_SETTINGS
+};
+//# sourceMappingURL=chunk-LL4KHSZI.js.map