@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/chunk-GOXNB3AO.js

@@ -0,0 +1,261 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  AUTONOMY_EXPOSURES
+} from "./chunk-HWUFFB6L.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/skill-activation.ts
+init_esm_shims();
+var SKILL_SUGGESTION_ANCHOR = "Suggested skill: /skill <name>";
+var SKILL_SUGGESTION_PREFIX = SKILL_SUGGESTION_ANCHOR.slice(0, SKILL_SUGGESTION_ANCHOR.indexOf("<name>"));
+var SKILL_SURFACE_EXEMPT_TOOLS = /* @__PURE__ */ new Set(["context", "ask_user"]);
+function evaluateSkillToolSurface(policy, tool) {
+  if (!policy || policy.loadedSkillPolicies.size === 0) return null;
+  if (SKILL_SURFACE_EXEMPT_TOOLS.has(tool)) return null;
+  const entries = [...policy.loadedSkillPolicies.entries()];
+  const skills = entries.map(([name]) => name);
+  const disallowedBy = entries.filter(([, declared]) => declared.disallowedTools?.includes(tool) === true).map(([name]) => name);
+  if (disallowedBy.length > 0) return { skills, mergedAllowedTools: null, disallowedBy };
+  const allowLists = entries.map(([, declared]) => declared.allowedTools);
+  if (allowLists.some((list) => list === void 0 || list.length === 0)) return null;
+  const merged = [...new Set(allowLists.flatMap((list) => [...list ?? []]))];
+  if (merged.includes(tool)) return null;
+  return { skills, mergedAllowedTools: merged, disallowedBy: [] };
+}
+function agentSkillToolPolicy(skillNames) {
+  const allowedSkillNames = [...new Set(skillNames.map((name) => name.trim()).filter((name) => name.length > 0))];
+  if (allowedSkillNames.length === 0) return void 0;
+  return {
+    allowedSkillNames,
+    requests: allowedSkillNames.map((name) => ({ name, args: "", source: "recipe", installed: true })),
+    loadedSkillNames: /* @__PURE__ */ new Set(),
+    loadedSkillPolicies: /* @__PURE__ */ new Map()
+  };
+}
+function trimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function skillActivationFromSource(source, triggeredBy, turnId) {
+  const sourceOrigin = trimmedString(source.sourceOrigin) ?? trimmedString(source.sourceInfo?.source);
+  return {
+    name: source.name,
+    filePath: source.filePath,
+    hash: source.hash,
+    source: source.source,
+    ...sourceOrigin ? { sourceOrigin } : {},
+    triggeredBy,
+    ...turnId ? { turnId } : {}
+  };
+}
+function skillActivationFromToolDetails(details, turnId) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return null;
+  const record = details;
+  const name = trimmedString(record.name);
+  const filePath = trimmedString(record.filePath) ?? trimmedString(record.path);
+  const hash = trimmedString(record.hash);
+  const source = trimmedString(record.source);
+  const sourceOrigin = trimmedString(record.sourceOrigin) ?? trimmedString(record.origin);
+  if (!name || !filePath || !hash || !source) return null;
+  const activation = skillActivationFromSource(
+    { name, filePath, hash, source, ...sourceOrigin ? { sourceOrigin } : {} },
+    "tool",
+    turnId
+  );
+  if (record.drift === "match" || record.drift === "mismatch") activation.drift = record.drift;
+  return activation;
+}
+function isSkillActivation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.name === "string" && typeof record.filePath === "string" && typeof record.hash === "string" && typeof record.source === "string" && (record.sourceOrigin === void 0 || typeof record.sourceOrigin === "string") && (record.triggeredBy === "slash-command" || record.triggeredBy === "tool") && (record.turnId === void 0 || typeof record.turnId === "string") && (record.runId === void 0 || typeof record.runId === "string");
+}
+
+// src/domains/session/entries.ts
+init_esm_shims();
+var EVICTION_REASONS = [
+  "superseded_read",
+  "stale_after_mutation",
+  "listing_consumed",
+  "failure_resolved",
+  "thinking_turn_closed",
+  "age_horizon",
+  "operator"
+];
+var EVICTION_TRIGGERS = ["pressure", "operator"];
+var RECALL_TRIGGERS = ["tool", "operator"];
+var SESSION_ENTRY_KINDS = [
+  "message",
+  "bashExecution",
+  "custom",
+  "modelChange",
+  "thinkingLevelChange",
+  "fileEntry",
+  "branchSummary",
+  "compactionSummary",
+  "sessionInfo",
+  "label",
+  "protectedArtifact",
+  "skillActivation",
+  "taskLedger",
+  "decisionLedger",
+  "workerRun",
+  "contextEviction",
+  "contextRecall"
+];
+function isRecord(value) {
+  return !!value && typeof value === "object";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isOptionalBoolean(value) {
+  return value === void 0 || typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveInteger(value) {
+  return isNumber(value) && Number.isInteger(value) && value > 0;
+}
+function isOptionalNumber(value) {
+  return value === void 0 || isNumber(value);
+}
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isOneOf(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasBaseSessionEntryFields(v) {
+  return isString(v.turnId) && isNullableString(v.parentTurnId) && isString(v.timestamp);
+}
+var MESSAGE_ROLES = ["user", "assistant", "tool_call", "tool_result", "system", "checkpoint"];
+var FILE_OPERATIONS = ["read", "write", "edit", "create", "delete"];
+var COMPACTION_TRIGGERS = ["auto", "force", "overflow"];
+var PROTECTED_ARTIFACT_SOURCES = [
+  "validation",
+  "middleware",
+  "user",
+  "session"
+];
+var TASK_LEDGER_STATUSES = ["pending", "active", "completed", "blocked", "cancelled"];
+var TASK_LEDGER_EVIDENCE_STATUSES = [
+  "required",
+  "pending",
+  "passed",
+  "failed",
+  "missing"
+];
+var DECISION_STATUSES = ["active", "superseded"];
+var DECISION_INTERVIEW_STATUSES = ["complete", "cancelled"];
+var WORKER_RUN_ORIGINS = ["user", "agent"];
+var WORKER_RUN_RUNTIME_KINDS = ["clio", "acp", "claude-sdk", "claude-code"];
+function isWorkerRunRuntime(value) {
+  if (!isRecord(value)) return false;
+  return isOneOf(value.kind, WORKER_RUN_RUNTIME_KINDS) && isOptionalString(value.targetId) && isOptionalString(value.wireModelId) && isOptionalString(value.peerId);
+}
+function isTaskLedgerGoal(value) {
+  if (!isRecord(value)) return false;
+  if (!isString(value.id) || !isString(value.title)) return false;
+  if (!isOneOf(value.status, TASK_LEDGER_STATUSES)) return false;
+  if (value.parentGoalId !== void 0 && !isNullableString(value.parentGoalId)) return false;
+  const hasPairedProvenance = value.origin === "user" ? isString(value.userTaskId) && /^u[1-9]\d*$/.test(value.userTaskId) : (value.origin === void 0 || value.origin === "agent") && value.userTaskId === void 0;
+  return isOptionalString(value.description) && hasPairedProvenance;
+}
+function isTaskLedgerEvidence(value) {
+  if (!isRecord(value)) return false;
+  if (!isString(value.id) || !isString(value.description)) return false;
+  if (!isOneOf(value.status, TASK_LEDGER_EVIDENCE_STATUSES)) return false;
+  return isOptionalString(value.command) && isOptionalString(value.artifactPath) && isOptionalString(value.observedAt) && isOptionalString(value.notes);
+}
+function isDecisionRecord(value) {
+  if (!isRecord(value)) return false;
+  if (!isString(value.key) || !/^[a-z0-9]+(?:_[a-z0-9]+)*$/.test(value.key)) return false;
+  if (!isString(value.value) || !isOneOf(value.status, DECISION_STATUSES) || !isString(value.decidedAt)) return false;
+  if (!isOptionalString(value.label) || !isOptionalString(value.source_question)) return false;
+  if (!isOptionalString(value.revisedAt) || !isOptionalString(value.correction)) return false;
+  return value.status === "superseded" ? isString(value.revisedAt) : value.revisedAt === void 0 && value.correction === void 0;
+}
+function isOptionalCompactionUsage(value) {
+  if (value === void 0) return true;
+  if (!isRecord(value)) return false;
+  const cost = value.cost;
+  return isNumber(value.input) && isNumber(value.output) && isNumber(value.cacheRead) && isNumber(value.cacheWrite) && isNumber(value.reasoning) && isNumber(value.totalTokens) && isNumber(value.apiCalls) && isRecord(cost) && isNumber(cost.total);
+}
+function isProtectedArtifact(value) {
+  if (!isRecord(value)) return false;
+  return isString(value.path) && isString(value.protectedAt) && isString(value.reason) && isOneOf(value.source, PROTECTED_ARTIFACT_SOURCES) && isOptionalString(value.validationCommand) && isOptionalNumber(value.validationExitCode);
+}
+function isSessionHeader(value) {
+  if (!isRecord(value)) return false;
+  return value.type === "session" && isPositiveInteger(value.version) && isString(value.id) && isString(value.timestamp) && isString(value.cwd) && isOptionalString(value.parentSession) && isOptionalString(value.parentTurnId);
+}
+function isWorkingSetRef(value) {
+  return isRecord(value) && isString(value.entry);
+}
+function isEvictedItem(value) {
+  return isRecord(value) && isWorkingSetRef(value.ref) && isOneOf(value.reason, EVICTION_REASONS) && isNumber(value.tokensFreed) && isString(value.marker) && isOptionalString(value.by);
+}
+function isSessionEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (!hasBaseSessionEntryFields(v)) return false;
+  if (!isOneOf(v.kind, SESSION_ENTRY_KINDS)) return false;
+  switch (v.kind) {
+    case "message":
+      return Object.hasOwn(v, "payload") && isOneOf(v.role, MESSAGE_ROLES);
+    case "bashExecution":
+      return isString(v.command) && isString(v.output) && (v.exitCode === null || isNumber(v.exitCode)) && typeof v.cancelled === "boolean" && typeof v.truncated === "boolean" && isOptionalString(v.fullOutputPath) && isOptionalBoolean(v.excludeFromContext);
+    case "custom":
+      return isString(v.customType) && isOptionalBoolean(v.display);
+    case "modelChange":
+      return isString(v.provider) && isString(v.modelId) && isOptionalString(v.target);
+    case "thinkingLevelChange":
+      return isString(v.thinkingLevel);
+    case "fileEntry":
+      return isString(v.path) && isOneOf(v.operation, FILE_OPERATIONS) && isOptionalNumber(v.bytes) && isOptionalString(v.hash);
+    case "branchSummary":
+      return isString(v.fromTurnId) && isString(v.summary);
+    case "compactionSummary":
+      return isString(v.summary) && isNumber(v.tokensBefore) && isString(v.firstKeptTurnId) && isOptionalCompactionUsage(v.usage) && (v.trigger === void 0 || isOneOf(v.trigger, COMPACTION_TRIGGERS)) && isOptionalNumber(v.tokensAfter) && isOptionalNumber(v.messagesSummarized) && isOptionalBoolean(v.isSplitTurn);
+    case "sessionInfo":
+      return isOptionalString(v.name) && isOptionalString(v.targetTurnId) && isOptionalString(v.label);
+    case "label":
+      return isString(v.targetTurnId) && isOptionalString(v.label);
+    case "protectedArtifact":
+      return v.action === "protect" && isProtectedArtifact(v.artifact) && isOptionalString(v.toolName) && isOptionalString(v.toolCallId) && isOptionalString(v.runId) && isOptionalString(v.correlationId);
+    case "skillActivation":
+      return isSkillActivation(v.activation);
+    case "taskLedger":
+      return isOptionalString(v.boardId) && Array.isArray(v.goals) && v.goals.every(isTaskLedgerGoal) && Array.isArray(v.subgoals) && v.subgoals.every(isTaskLedgerGoal) && isStringArray(v.activeRunIds) && Array.isArray(v.requiredValidationEvidence) && v.requiredValidationEvidence.every(isTaskLedgerEvidence);
+    case "decisionLedger":
+      return isString(v.interviewId) && isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) && isString(v.startedAt) && isString(v.endedAt) && isNumber(v.roundCount) && Number.isInteger(v.roundCount) && v.roundCount >= 0 && isOptionalString(v.summary) && isOptionalString(v.transcriptPath) && (v.exposure === void 0 || isOneOf(v.exposure, AUTONOMY_EXPOSURES)) && Array.isArray(v.decisions) && v.decisions.every(isDecisionRecord);
+    case "workerRun":
+      return isString(v.assignmentId) && isString(v.runId) && isOneOf(v.origin, WORKER_RUN_ORIGINS) && isString(v.agentId) && isWorkerRunRuntime(v.runtime) && isOptionalString(v.parentToolCallId);
+    case "contextEviction":
+      return isString(v.policyId) && isOneOf(v.trigger, EVICTION_TRIGGERS) && Array.isArray(v.evicted) && v.evicted.every(isEvictedItem) && isNumber(v.tokensBefore) && isNumber(v.tokensAfter) && (v.pressureBefore === null || isNumber(v.pressureBefore)) && (v.snapshotIdBefore === null || isString(v.snapshotIdBefore));
+    case "contextRecall":
+      return isWorkingSetRef(v.ref) && isOneOf(v.trigger, RECALL_TRIGGERS) && isNumber(v.tokensReadmitted) && isOptionalString(v.toolCallId);
+  }
+  return false;
+}
+
+export {
+  SKILL_SUGGESTION_ANCHOR,
+  SKILL_SUGGESTION_PREFIX,
+  evaluateSkillToolSurface,
+  agentSkillToolPolicy,
+  skillActivationFromToolDetails,
+  isSkillActivation,
+  isSessionHeader,
+  isSessionEntry
+};
+//# sourceMappingURL=chunk-GOXNB3AO.js.map

package/dist/{chunk-G4BMMOKF.js → chunk-HVDIIIQW.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   detectProjectType
-} from "./chunk-YHZX5GEU.js";
+} from "./chunk-XAKHZX5N.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -179,4 +179,4 @@ export {
   probeWorkspace,
   probeWorkspaceAsync
 };
-//# sourceMappingURL=chunk-G4BMMOKF.js.map
+//# sourceMappingURL=chunk-HVDIIIQW.js.map

package/dist/chunk-HWUFFB6L.js

@@ -0,0 +1,83 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/autonomy.ts
+init_esm_shims();
+var AUTONOMY_LEVELS = ["read-only", "suggest", "auto-edit", "full-auto"];
+var DEFAULT_AUTONOMY_LEVEL = "auto-edit";
+function isAutonomyLevel(value) {
+  return typeof value === "string" && AUTONOMY_LEVELS.includes(value);
+}
+var AUTONOMY_EXPOSURES = ["local", "outward"];
+var DEFAULT_AUTONOMY_EXPOSURE = "local";
+function mapAutonomy(level, actionClass, options = {}) {
+  if (actionClass === "git_destructive") return "deny";
+  if ((level === "auto-edit" || level === "suggest") && options.exposure === "outward") return "ask";
+  if (actionClass === "read") return "allow";
+  if (level === "read-only") return "deny";
+  if (level === "suggest") return "ask";
+  switch (actionClass) {
+    case "write":
+      return "allow";
+    case "dispatch":
+      if (options.dispatchPlanScale === true && level !== "full-auto") return "ask";
+      return "allow";
+    case "execute": {
+      if (options.executeRecognized !== false) return "allow";
+      return level === "full-auto" ? "allow" : "ask";
+    }
+    case "unknown":
+      return "ask";
+    default:
+      return "ask";
+  }
+}
+function autonomyDenyRejection(level, tool, actionClass) {
+  return {
+    short: `${tool} denied: autonomy level is ${level}`,
+    detail: `Clio is at autonomy ${level}: ${actionClass} actions are denied without prompting. Describe the change you would make instead, so the operator can apply it or raise the autonomy level.`,
+    hints: ["Propose the exact edit or command as text.", "The operator can change the level in /settings."]
+  };
+}
+function autonomyAskRejection(level, tool, actionClass, exposure = DEFAULT_AUTONOMY_EXPOSURE) {
+  if (exposure === "outward") {
+    return {
+      short: `${tool} needs approval: outward-facing gate at autonomy ${level}`,
+      detail: `The call declared exposure=outward, so answering it publishes or sends something outside the workspace. Autonomy ${level} auto-answers local gates and parks outward-facing ones for the operator.`,
+      hints: [
+        "Approving resumes only this call.",
+        "Autonomy full-auto answers outward gates too; the safety net still applies there."
+      ]
+    };
+  }
+  return {
+    short: `${tool} needs approval (${actionClass}) at autonomy ${level}`,
+    detail: `Autonomy ${level} routes ${actionClass} actions through operator approval. The call is parked until the operator approves it once or cancels it.`,
+    hints: [
+      "Approving resumes only this call.",
+      "Recognized commands can be added to .clio-coder/safety.yaml.",
+      // The sanctioned pivots for a gated shell command: typed verification
+      // and read-class observe tools run without approval at this level,
+      // and models otherwise stall retrying denied bash for checks or
+      // directory listings.
+      ...actionClass === "execute" ? [
+        'A declared package or project-catalog check runs without approval through the verify tool: verify(check="<id>").',
+        "Read-only inspection runs without approval through the ls, read, grep, and find tools."
+      ] : []
+    ]
+  };
+}
+
+export {
+  AUTONOMY_LEVELS,
+  DEFAULT_AUTONOMY_LEVEL,
+  isAutonomyLevel,
+  AUTONOMY_EXPOSURES,
+  DEFAULT_AUTONOMY_EXPOSURE,
+  mapAutonomy,
+  autonomyDenyRejection,
+  autonomyAskRejection
+};
+//# sourceMappingURL=chunk-HWUFFB6L.js.map

package/dist/{chunk-4XUGQOHA.js → chunk-K7T3E2SR.js}

@@ -10,17 +10,17 @@ import {
 import {
   FAILURE_CAUSE_TAGS,
   buildEvidence
-} from "./chunk-SRDMMSEP.js";
+} from "./chunk-QM3F2GKX.js";
 import {
   normalizeCostProvenance
-} from "./chunk-LZSJBIVT.js";
+} from "./chunk-DJVECN66.js";
 import {
   clioDataDir,
   clioStateDir
 } from "./chunk-BNAZZHFG.js";
 import {
   BusChannels
-} from "./chunk-OQ33BKR3.js";
+} from "./chunk-G7MUEIGA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -71,7 +71,7 @@ function createCostTracker() {
   let total = 0;
   const totals = emptyBreakdown();
   return {
-    accumulate(providerId, modelId, tokens, usd, breakdown, costProvenance) {
+    accumulate(providerId, attributedModelId, tokens, usd, breakdown, costProvenance, modelIdFacts) {
       const resolvedUsd = usd ?? 0;
       const provenance = normalizeCostProvenance(costProvenance);
       const input = breakdown?.input ?? 0;
@@ -82,7 +82,14 @@ function createCostTracker() {
       const apiCalls = breakdown?.apiCalls;
       log.push({
         providerId,
-        modelId,
+        attributedModelId,
+        requestedModelIds: [...modelIdFacts?.requestedModelIds ?? [attributedModelId]],
+        responseModelIdObservationCounts: modelIdFacts ? { ...modelIdFacts.responseModelIdObservationCounts } : {
+          reportedCalls: 0,
+          notReportedCalls: 0,
+          notObservedCalls: apiCalls ?? 1,
+          legacyDifferenceOnlyCalls: 0
+        },
         tokens,
         usd: resolvedUsd,
         provenance,
@@ -742,9 +749,9 @@ function createObservabilityBundle(context, options = {}) {
       latestThroughput = null;
       projection.refresh();
     },
-    recordTokens(providerId, modelId, tokens, costUsd, breakdown, costProvenance) {
+    recordTokens(providerId, attributedModelId, tokens, costUsd, breakdown, costProvenance, modelIdFacts) {
       telemetry.record("counter", "tokens.total", tokens);
-      cost.accumulate(providerId, modelId, tokens, costUsd, breakdown, costProvenance);
+      cost.accumulate(providerId, attributedModelId, tokens, costUsd, breakdown, costProvenance, modelIdFacts);
       projection.refresh();
     },
     recordSessionTurn(sessionTurn) {
@@ -794,4 +801,4 @@ export {
   ObservabilityDomainModule,
   createObservabilityDomainModule
 };
-//# sourceMappingURL=chunk-4XUGQOHA.js.map
+//# sourceMappingURL=chunk-K7T3E2SR.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-UFIIWP2H.js → chunk-KHSFENX2.js}

@@ -9,24 +9,24 @@ import {
   detectInteropAgents,
   fingerprintNativeRuntime,
   resolveOnPath
-} from "./chunk-2TLUCQVG.js";
+} from "./chunk-RD5U66HV.js";
 import {
   initializeClioHome
-} from "./chunk-BMEMKKIT.js";
+} from "./chunk-KOHPCX4K.js";
 import {
   formatSettingsIssues,
   readSettings,
   validateSettingsFile
-} from "./chunk-A3CYT5EX.js";
+} from "./chunk-AD2SYQYC.js";
 import {
   openAuthStorage
 } from "./chunk-4VP4KH3K.js";
-import {
-  readSessionFileEntries
-} from "./chunk-M6SHUN7Q.js";
 import {
   interopAgentKind
 } from "./chunk-IHXBNWMM.js";
+import {
+  readSessionFileEntries
+} from "./chunk-FO5ZOVUY.js";
 import {
   clioStatePath,
   resolveClioDirs
@@ -337,7 +337,7 @@ async function runDoctorFleetChecks(projectRoot = process.cwd()) {
   }
   const nodes = settings.fleet?.nodes ?? [];
   if (nodes.length === 0) return [];
-  const { recordFleetPreflight, runFleetNodePreflight } = await import("./fleet-preflight-DDN536IT.js");
+  const { recordFleetPreflight, runFleetNodePreflight } = await import("./fleet-preflight-BHSNPBMH.js");
   const targets = (settings.targets ?? []).map((target) => ({
     id: target.id,
     runtimeId: target.runtime,
@@ -437,4 +437,4 @@ export {
   runDoctorInteropChecks,
   runDoctorRuntimeChecks
 };
-//# sourceMappingURL=chunk-UFIIWP2H.js.map
+//# sourceMappingURL=chunk-KHSFENX2.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-LCGCVYZ4.js

@@ -0,0 +1,57 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/toml.ts
+init_esm_shims();
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+var require2 = createRequire(import.meta.url);
+var parse;
+function parser() {
+  parse ??= require2("smol-toml").parse;
+  return parse;
+}
+function parseTomlDocument(raw) {
+  try {
+    return parser()(raw);
+  } catch {
+    return null;
+  }
+}
+function isTomlTable(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function tomlTableAt(document, path) {
+  let value = document;
+  for (const segment of path) {
+    if (!isTomlTable(value) || !Object.hasOwn(value, segment)) return null;
+    value = value[segment];
+  }
+  return isTomlTable(value) ? value : null;
+}
+function createTomlFileReader(root) {
+  const documents = /* @__PURE__ */ new Map();
+  return {
+    read(relativePath) {
+      if (documents.has(relativePath)) return documents.get(relativePath) ?? null;
+      let document = null;
+      try {
+        document = parseTomlDocument(readFileSync(join(root, relativePath), "utf8"));
+      } catch {
+        document = null;
+      }
+      documents.set(relativePath, document);
+      return document;
+    }
+  };
+}
+
+export {
+  parseTomlDocument,
+  tomlTableAt,
+  createTomlFileReader
+};
+//# sourceMappingURL=chunk-LCGCVYZ4.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