@iowarp/clio-coder 0.3.7 → 0.3.9

package/dist/{chunk-ZWLZP4ZT.js → chunk-5QKCQQ3E.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getVersionInfo
+} from "./chunk-XPLRXC72.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -16,8 +19,222 @@ import {
 // src/domains/extensions/discovery.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
+
+// src/domains/extensions/compatibility.ts
+init_esm_shims();
+var MAX_RANGE_CHARS = 256;
+var NUMERIC = "(?:0|[1-9]\\d*)";
+var IDENTIFIER = "[0-9A-Za-z-]+";
+var VERSION_RE = new RegExp(
+  `^v?(${NUMERIC})\\.(${NUMERIC})\\.(${NUMERIC})(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
+);
+var PARTIAL_RE = new RegExp(
+  `^v?(${NUMERIC}|[xX*])(?:\\.(${NUMERIC}|[xX*]))?(?:\\.(${NUMERIC}|[xX*]))?(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
+);
+function prerelease(value) {
+  if (value === void 0) return [];
+  const out = [];
+  for (const identifier of value.split(".")) {
+    if (identifier.length === 0) return null;
+    if (/^\d+$/u.test(identifier)) {
+      if (identifier.length > 1 && identifier.startsWith("0")) return null;
+      const parsed = Number(identifier);
+      if (!Number.isSafeInteger(parsed)) return null;
+      out.push(parsed);
+    } else {
+      out.push(identifier);
+    }
+  }
+  return out;
+}
+function parseSemVer(value) {
+  const match = VERSION_RE.exec(value);
+  if (match === null) return null;
+  const parsedPrerelease = prerelease(match[4]);
+  if (parsedPrerelease === null) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (![major, minor, patch].every(Number.isSafeInteger)) return null;
+  return { major, minor, patch, prerelease: parsedPrerelease };
+}
+function parsePart(value) {
+  if (value === void 0 || value === "x" || value === "X" || value === "*") return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function parsePartial(value) {
+  const match = PARTIAL_RE.exec(value);
+  if (match === null) return null;
+  for (const part of match.slice(1, 4)) {
+    if (part === void 0 || part === "x" || part === "X" || part === "*") continue;
+    if (!Number.isSafeInteger(Number(part))) return null;
+  }
+  const major = parsePart(match[1]);
+  const minor = parsePart(match[2]);
+  const patch = parsePart(match[3]);
+  if (major === null && (match[2] !== void 0 || match[3] !== void 0) || minor === null && match[3] !== void 0) {
+    return null;
+  }
+  const parsedPrerelease = prerelease(match[4]);
+  if (parsedPrerelease === null) return null;
+  if (parsedPrerelease.length > 0 && (major === null || minor === null || patch === null)) return null;
+  return { major, minor, patch, prerelease: parsedPrerelease };
+}
+function compareIdentifiers(left, right) {
+  if (left === right) return 0;
+  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
+  if (typeof left === "number") return -1;
+  if (typeof right === "number") return 1;
+  return left < right ? -1 : 1;
+}
+function compare(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1;
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+    if (left.prerelease.length === right.prerelease.length) return 0;
+    return left.prerelease.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      if (leftPart === rightPart) return 0;
+      return leftPart === void 0 ? -1 : 1;
+    }
+    const order = compareIdentifiers(leftPart, rightPart);
+    if (order !== 0) return order;
+  }
+  return 0;
+}
+function floor(partial) {
+  return {
+    major: partial.major ?? 0,
+    minor: partial.minor ?? 0,
+    patch: partial.patch ?? 0,
+    prerelease: partial.prerelease
+  };
+}
+function nextWildcard(partial) {
+  if (partial.major === null) return null;
+  if (partial.minor === null) return { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] };
+  if (partial.patch === null) return { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
+  return null;
+}
+function lowerBound(version, inclusive) {
+  return (candidate) => inclusive ? compare(candidate, version) >= 0 : compare(candidate, version) > 0;
+}
+function upperBound(version, inclusive) {
+  return (candidate) => inclusive ? compare(candidate, version) <= 0 : compare(candidate, version) < 0;
+}
+function core(version) {
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+function predicatesForToken(token) {
+  const match = /^(<=|>=|<|>|=|~|\^)?(.+)$/u.exec(token);
+  if (match === null) return null;
+  const operator = match[1] ?? "";
+  const partial = parsePartial(match[2] ?? "");
+  if (partial === null) return null;
+  const base = floor(partial);
+  const wildcardUpper = nextWildcard(partial);
+  const prereleaseCore = partial.prerelease.length > 0 ? core(base) : null;
+  if (operator === "" || operator === "=") {
+    if (partial.major === null) return { predicates: [], prereleaseCore };
+    if (wildcardUpper !== null) {
+      return { predicates: [lowerBound(base, true), upperBound(wildcardUpper, false)], prereleaseCore };
+    }
+    return { predicates: [(candidate) => compare(candidate, base) === 0], prereleaseCore };
+  }
+  if (operator === ">=") return { predicates: [lowerBound(base, true)], prereleaseCore };
+  if (operator === "<") return { predicates: [upperBound(base, false)], prereleaseCore };
+  if (operator === ">") {
+    return {
+      predicates: [wildcardUpper === null ? lowerBound(base, false) : lowerBound(wildcardUpper, true)],
+      prereleaseCore
+    };
+  }
+  if (operator === "<=") {
+    return {
+      predicates: [wildcardUpper === null ? upperBound(base, true) : upperBound(wildcardUpper, false)],
+      prereleaseCore
+    };
+  }
+  if (partial.major === null) return { predicates: [], prereleaseCore };
+  if (operator === "~") {
+    const upper2 = partial.minor === null ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
+    return { predicates: [lowerBound(base, true), upperBound(upper2, false)], prereleaseCore };
+  }
+  const upper = partial.major > 0 ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : partial.minor === null ? { major: 1, minor: 0, patch: 0, prerelease: [] } : (partial.minor ?? 0) > 0 ? { major: 0, minor: (partial.minor ?? 0) + 1, patch: 0, prerelease: [] } : partial.patch === null ? { major: 0, minor: 1, patch: 0, prerelease: [] } : { major: 0, minor: 0, patch: (partial.patch ?? 0) + 1, prerelease: [] };
+  return { predicates: [lowerBound(base, true), upperBound(upper, false)], prereleaseCore };
+}
+function predicatesForSet(raw) {
+  const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(raw);
+  if (hyphen !== null) {
+    const left = parsePartial(hyphen[1] ?? "");
+    const right = parsePartial(hyphen[2] ?? "");
+    if (left === null || right === null || left.major === null || right.major === null) return null;
+    const rightUpper = nextWildcard(right);
+    return {
+      predicates: [
+        lowerBound(floor(left), true),
+        rightUpper === null ? upperBound(floor(right), true) : upperBound(rightUpper, false)
+      ],
+      prereleaseCores: new Set(
+        [
+          left.prerelease.length > 0 ? core(floor(left)) : null,
+          right.prerelease.length > 0 ? core(floor(right)) : null
+        ].filter((entry) => entry !== null)
+      )
+    };
+  }
+  const normalized = raw.replace(/(<=|>=|<|>|=|~|\^)\s+/gu, "$1");
+  const tokens = normalized.split(/\s+/u).filter((entry) => entry.length > 0);
+  if (tokens.length === 0) return null;
+  const predicates = [];
+  const prereleaseCores = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const parsed = predicatesForToken(token);
+    if (parsed === null) return null;
+    predicates.push(...parsed.predicates);
+    if (parsed.prereleaseCore !== null) prereleaseCores.add(parsed.prereleaseCore);
+  }
+  return { predicates, prereleaseCores };
+}
+function parseRange(range) {
+  const trimmed = range.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_RANGE_CHARS) return null;
+  const sets = trimmed.split("||");
+  if (sets.some((set) => set.trim().length === 0)) return null;
+  const parsed = sets.map((set) => predicatesForSet(set.trim()));
+  return parsed.every((set) => set !== null) ? parsed : null;
+}
+function isValidSemVerRange(range) {
+  return parseRange(range) !== null;
+}
+function satisfiesSemVerRange(version, range) {
+  const candidate = parseSemVer(version);
+  const sets = parseRange(range);
+  if (candidate === null || sets === null) return false;
+  return sets.some((set) => {
+    if (candidate.prerelease.length > 0 && !set.prereleaseCores.has(core(candidate))) return false;
+    return set.predicates.every((predicate) => predicate(candidate));
+  });
+}
+function evaluateClioCompatibility(range, runningVersion = getVersionInfo().clio) {
+  const rangeValid = isValidSemVerRange(range);
+  return {
+    rangeValid,
+    satisfied: rangeValid && satisfiesSemVerRange(runningVersion, range),
+    runningVersion
+  };
+}
+
+// src/domains/extensions/discovery.ts
 var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -44,12 +261,85 @@ function normalizeResources(value) {
   const out = {};
   const skills = trimString(value.skills);
   const prompts = trimString(value.prompts);
+  const agents = trimString(value.agents);
+  const fleets = trimString(value.fleets);
   const themes = trimString(value.themes);
   if (skills) out.skills = skills;
   if (prompts) out.prompts = prompts;
+  if (agents) out.agents = agents;
+  if (fleets) out.fleets = fleets;
   if (themes) out.themes = themes;
   return out;
 }
+function contained(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function validateResourceTree(root, resourcePath, kind, diagnostics) {
+  if (path.isAbsolute(resourcePath)) {
+    diagnostics.push({ type: "error", message: `resources.${kind} must be relative`, path: resourcePath });
+    return;
+  }
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(resolvedRoot, resourcePath);
+  if (!contained(resolvedRoot, resolved) || resolved === resolvedRoot) {
+    diagnostics.push({ type: "error", message: `resources.${kind} escapes the extension root`, path: resourcePath });
+    return;
+  }
+  let canonicalRoot;
+  let canonicalResource;
+  try {
+    canonicalRoot = realpathSync(resolvedRoot);
+    canonicalResource = realpathSync(resolved);
+    if (!lstatSync(resolved).isDirectory()) {
+      diagnostics.push({ type: "error", message: `resources.${kind} is not a directory`, path: resolved });
+      return;
+    }
+  } catch (error) {
+    diagnostics.push({
+      type: "error",
+      message: `resources.${kind} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`,
+      path: resolved
+    });
+    return;
+  }
+  if (!contained(canonicalRoot, canonicalResource)) {
+    diagnostics.push({ type: "error", message: `resources.${kind} escapes through a symbolic link`, path: resolved });
+    return;
+  }
+  const pending = [resolved];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (!directory) continue;
+    for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const candidate = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        try {
+          if (!contained(canonicalRoot, realpathSync(candidate))) {
+            diagnostics.push({
+              type: "error",
+              message: `resources.${kind} contains an escaping symbolic link`,
+              path: candidate
+            });
+          }
+        } catch (error) {
+          diagnostics.push({
+            type: "error",
+            message: `resources.${kind} contains an unresolved symbolic link: ${error instanceof Error ? error.message : String(error)}`,
+            path: candidate
+          });
+        }
+      } else if (entry.isDirectory()) {
+        pending.push(candidate);
+      }
+    }
+  }
+}
+function validateResourceRoots(root, resources, diagnostics) {
+  for (const [kind, resourcePath] of Object.entries(resources)) {
+    if (resourcePath) validateResourceTree(root, resourcePath, kind, diagnostics);
+  }
+}
 function stringArray(value) {
   if (!Array.isArray(value)) return void 0;
   const out = value.map((entry) => trimString(entry)).filter((entry) => entry !== void 0);
@@ -77,7 +367,32 @@ function parseExtensionManifest(value, manifestPath) {
   const resources = normalizeResources(value.resources);
   const tools = stringArray(value.tools);
   const settings = stringArray(value.settings);
-  const compatibility = isRecord(value.compatibility) ? { ...trimString(value.compatibility.clio) ? { clio: trimString(value.compatibility.clio) } : {} } : void 0;
+  let compatibility;
+  if (value.compatibility !== void 0) {
+    if (!isRecord(value.compatibility)) {
+      diagnostics.push({ type: "error", message: "compatibility must be an object", path: manifestPath });
+    } else if ("clio" in value.compatibility) {
+      const range = trimString(value.compatibility.clio);
+      if (range === void 0) {
+        diagnostics.push({
+          type: "error",
+          message: "compatibility.clio must be a non-empty semver range",
+          path: manifestPath
+        });
+      } else {
+        const evaluation = evaluateClioCompatibility(range);
+        if (!evaluation.rangeValid) {
+          diagnostics.push({
+            type: "error",
+            message: `extension ${id ?? "<unknown>"} declares malformed compatibility.clio range '${range}'`,
+            path: manifestPath
+          });
+        } else {
+          compatibility = { clio: range };
+        }
+      }
+    }
+  }
   if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
     return { diagnostics };
   }
@@ -92,6 +407,17 @@ function parseExtensionManifest(value, manifestPath) {
   if (tools) manifest.tools = tools;
   if (settings) manifest.settings = settings;
   if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
+  const clioRange = manifest.compatibility?.clio;
+  if (clioRange !== void 0) {
+    const evaluation = evaluateClioCompatibility(clioRange);
+    if (!evaluation.satisfied) {
+      diagnostics.push({
+        type: "error",
+        message: `extension ${manifest.id} requires Clio '${clioRange}', but running Clio version is '${evaluation.runningVersion}'`,
+        path: manifestPath
+      });
+    }
+  }
   return { manifest, diagnostics };
 }
 function findExtensionManifestPath(root) {
@@ -115,6 +441,7 @@ function loadManifestFromRoot(root) {
   }
   try {
     const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
+    if (parsed.manifest) validateResourceRoots(root, parsed.manifest.resources, parsed.diagnostics);
     return {
       path: root,
       manifestPath,
@@ -222,6 +549,8 @@ function installedFromRoot(root, scope, state) {
   const candidate = loadManifestFromRoot(root);
   const manifest = candidate.manifest;
   if (!manifest || !candidate.manifestPath) return null;
+  const clioRange = manifest.compatibility?.clio;
+  const compatible = clioRange === void 0 || evaluateClioCompatibility(clioRange).satisfied;
   return {
     id: manifest.id,
     name: manifest.name,
@@ -231,6 +560,7 @@ function installedFromRoot(root, scope, state) {
     rootPath: root,
     manifestPath: candidate.manifestPath,
     enabled: !state.disabled.includes(manifest.id),
+    compatible,
     effective: false,
     resources: manifest.resources,
     diagnostics: candidate.diagnostics
@@ -259,13 +589,13 @@ function listInstalledExtensions(cwd = process.cwd(), options = {}) {
     byId.set(entry.id, list);
   }
   for (const group of byId.values()) {
-    const winner = [...group].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1);
+    const winner = group.filter((entry) => entry.compatible).sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1);
     for (const entry of group) {
       entry.effective = entry === winner;
-      if (!entry.effective && winner) entry.overriddenBy = winner.scope;
+      if (entry.compatible && !entry.effective && winner) entry.overriddenBy = winner.scope;
     }
   }
-  const all = options.all === true ? entries : entries.filter((entry) => entry.effective);
+  const all = options.all === true ? entries : entries.filter((entry) => entry.effective || !entry.compatible);
   return all.sort((a, b) => {
     const id = a.id.localeCompare(b.id);
     if (id !== 0) return id;
@@ -284,7 +614,7 @@ function installExtension(sourcePath, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const source = path2.resolve(sourcePath);
   const candidate = loadManifestFromRoot(source);
-  if (!candidate.manifest) return { diagnostics: candidate.diagnostics };
+  if (!candidate.manifest || !candidate.valid) return { diagnostics: candidate.diagnostics };
   const targetRoot = path2.join(extensionBaseDir(scope, cwd), candidate.manifest.id);
   if (existsSync2(targetRoot)) {
     if (!options.force) {
@@ -307,7 +637,11 @@ function installExtension(sourcePath, options = {}) {
     rmSync(backupRoot, { recursive: true, force: true });
     cpSync(source, stagingRoot, {
       recursive: true,
-      filter: (src) => path2.basename(src) !== "state.json"
+      // `state.json` beside the installed extension directories belongs to
+      // Clio's extension manager. An extension may legitimately ship nested
+      // resources with the same basename (for example a project-state JSON
+      // template), so exclude only a bookkeeping file at the package root.
+      filter: (src) => path2.relative(source, src) !== "state.json"
     });
     if (existsSync2(targetRoot)) {
       renameSync(targetRoot, backupRoot);
@@ -379,32 +713,40 @@ init_esm_shims();
 
 // src/domains/extensions/resources.ts
 init_esm_shims();
-import { statSync as statSync2 } from "node:fs";
+import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
 import path3 from "node:path";
 function extensionResourcePath(rootPath, resourcePath) {
   const root = path3.resolve(rootPath);
   const full = path3.resolve(root, resourcePath);
   const relative = path3.relative(root, full);
-  if (relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative)) return full;
-  return null;
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative))
+    return null;
+  try {
+    const rootReal = realpathSync2(root);
+    const fullReal = realpathSync2(full);
+    const canonicalRelative = path3.relative(rootReal, fullReal);
+    if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${path3.sep}`) || path3.isAbsolute(canonicalRelative)) {
+      return null;
+    }
+    if (!lstatSync2(full).isDirectory()) return null;
+    return full;
+  } catch {
+    return null;
+  }
 }
 function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
   const roots = [];
   for (const entry of listInstalledExtensions(cwd)) {
-    if (!entry.enabled || !entry.effective) continue;
+    if (!entry.enabled || !entry.compatible || !entry.effective) continue;
     const rel = entry.resources[kind];
     if (!rel) continue;
     const full = extensionResourcePath(entry.rootPath, rel);
     if (!full) continue;
-    try {
-      if (!statSync2(full).isDirectory()) continue;
-    } catch {
-      continue;
-    }
     roots.push({
       id: entry.id,
       scope: entry.scope,
       path: full,
+      rootPath: entry.rootPath,
       source: `extension:${entry.scope}:${entry.id}`
     });
   }
@@ -474,4 +816,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-ZWLZP4ZT.js.map
+//# sourceMappingURL=chunk-5QKCQQ3E.js.map

package/dist/{chunk-6M7VS3J3.js → chunk-5T7RBWN2.js}

@@ -1,12 +1,14 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   inspectEvidence
-} from "./chunk-UUANF5CR.js";
+} from "./chunk-TEO2TLVN.js";
 import {
   TASK_MEMORY_CONTENT_MAX_CHARS,
   TASK_MEMORY_DEFAULT_KNOWLEDGE_CAP,
-  TASK_MEMORY_DEFAULT_PROCEDURAL_CAP
-} from "./chunk-WHGPSPT5.js";
+  TASK_MEMORY_DEFAULT_PROCEDURAL_CAP,
+  TASK_MEMORY_TELEMETRY_FILE,
+  parseTaskMemoryTelemetryRecord
+} from "./chunk-O6I4CIEU.js";
 import {
   createRedactionTally,
   redactSecretsText
@@ -16,7 +18,10 @@ import {
 } from "./chunk-ECH6PKUQ.js";
 import {
   ceilChars
-} from "./chunk-GEYXPTRF.js";
+} from "./chunk-AEYBF3TB.js";
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -1116,6 +1121,30 @@ function compareStrings3(a, b) {
   return a.localeCompare(b);
 }
 
+// src/domains/memory/task-bank-promotion.ts
+init_esm_shims();
+async function proposeInjectedTaskMemory(dataDir, input) {
+  const result = { records: [], errors: [] };
+  const sessionId = input.sessionId;
+  const repository = canonicalMemoryRepositoryIdentity(input.cwd);
+  if (sessionId === null || sessionId.length === 0 || repository === null) return result;
+  for (const entry of input.entries) {
+    if (entry.kind === "status") continue;
+    try {
+      const proposal = await proposeMemoryPromotion(
+        dataDir,
+        { kind: "task-bank-entry", sessionId, evidenceRefs: [`session:${sessionId}`], entry },
+        { scope: "repo", repository },
+        input.now ?? /* @__PURE__ */ new Date()
+      );
+      result.records.push(proposal.record);
+    } catch (error) {
+      result.errors.push(`${entry.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return result;
+}
+
 // src/domains/memory/task-memory-handoff.ts
 init_esm_shims();
 import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
@@ -1367,6 +1396,80 @@ function compareStrings4(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+// src/domains/memory/task-memory-spend.ts
+init_esm_shims();
+import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function taskMemoryStepsPath(stateDir = clioStateDir()) {
+  return join3(stateDir, "memory", TASK_MEMORY_TELEMETRY_FILE);
+}
+function emptyTaskMemorySpendSummary() {
+  return {
+    llmSteps: 0,
+    injections: 0,
+    hitRate: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    modelMs: 0,
+    slowestStepMs: 0,
+    timeouts: 0,
+    endpointBusySkips: 0,
+    firstAt: null,
+    lastAt: null
+  };
+}
+function foldTaskMemorySpend(lines) {
+  const summary = emptyTaskMemorySpendSummary();
+  for (const line of lines) {
+    if (line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = parseTaskMemoryTelemetryRecord(parsed);
+    if (record === null) continue;
+    if (summary.firstAt === null || record.at < summary.firstAt) summary.firstAt = record.at;
+    if (summary.lastAt === null || record.at > summary.lastAt) summary.lastAt = record.at;
+    if (record.reason === "endpoint_busy") summary.endpointBusySkips += 1;
+    if (record.tier !== "llm") continue;
+    summary.llmSteps += 1;
+    if (record.decision === "injected") summary.injections += 1;
+    if (record.decision === "timeout") summary.timeouts += 1;
+    summary.inputTokens += record.tokenCost.input;
+    summary.outputTokens += record.tokenCost.output;
+    summary.totalTokens += record.tokenCost.total;
+    summary.modelMs += record.latencyMs;
+    summary.slowestStepMs = Math.max(summary.slowestStepMs, record.latencyMs);
+  }
+  summary.hitRate = summary.llmSteps === 0 ? 0 : summary.injections / summary.llmSteps;
+  return summary;
+}
+var spendCache = /* @__PURE__ */ new Map();
+function readTaskMemorySpendSummary(stateDir = clioStateDir()) {
+  const path = taskMemoryStepsPath(stateDir);
+  try {
+    const info = statSync2(path);
+    const cached = spendCache.get(path);
+    if (cached !== void 0 && cached.mtimeMs === info.mtimeMs && cached.size === info.size) return cached.summary;
+    const summary = foldTaskMemorySpend(readFileSync3(path, "utf8").split("\n"));
+    spendCache.set(path, { mtimeMs: info.mtimeMs, size: info.size, summary });
+    return summary;
+  } catch {
+    return emptyTaskMemorySpendSummary();
+  }
+}
+function formatTaskMemorySpend(summary) {
+  if (summary.llmSteps === 0) return "";
+  const tokens = summary.totalTokens >= 1e3 ? `${(summary.totalTokens / 1e3).toFixed(1)}k tok` : `${summary.totalTokens} tok`;
+  const seconds = summary.modelMs / 1e3;
+  const time = seconds >= 60 ? `${(seconds / 60).toFixed(1)}m` : `${seconds.toFixed(1)}s`;
+  const rate = `${Math.round(summary.hitRate * 100)}%`;
+  return `spend ${summary.llmSteps} steps \xB7 ${tokens} \xB7 ${time} \xB7 hit ${summary.injections}/${summary.llmSteps} (${rate})`;
+}
+
 // src/domains/memory/task-memory-status.ts
 init_esm_shims();
 function describeTaskMemoryActivity(event) {
@@ -1441,13 +1544,16 @@ export {
   proposeMemoryPromotion,
   buildMemoryPromptSection,
   proposeMemoryFromEvidence,
+  proposeInjectedTaskMemory,
   renderTaskMemoryHandoffSource,
   parseTaskMemoryHandoffSnapshot,
   taskMemoryHandoffSeedOffer,
   seedTaskMemoryFromNewestHandoff,
+  readTaskMemorySpendSummary,
+  formatTaskMemorySpend,
   describeTaskMemoryActivity,
   taskMemoryBankSize,
   taskMemoryTracePath,
   createTaskMemoryTrace
 };
-//# sourceMappingURL=chunk-6M7VS3J3.js.map
+//# sourceMappingURL=chunk-5T7RBWN2.js.map