@iowarp/clio-coder 0.4.5 → 0.4.7

package/dist/{chunk-DZK63TZJ.js → chunk-24S3DN22.js}

@@ -1,7 +1,9 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  getVersionInfo
-} from "./chunk-GD55RTIW.js";
+  evaluateClioCompatibility,
+  extensionContentDigest,
+  extensionContentDigestWithCapture
+} from "./chunk-XW2UZICE.js";
 import {
   require_dist
 } from "./chunk-B5GGDIHT.js";
@@ -19,236 +21,277 @@ import {
 // src/domains/extensions/discovery.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
-import path from "node:path";
+import { existsSync, readdirSync, readFileSync, realpathSync as realpathSync2, statSync } from "node:fs";
+import path2 from "node:path";
 
-// src/domains/extensions/compatibility.ts
+// src/domains/extensions/command-schema.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);
+import { lstatSync, realpathSync } from "node:fs";
+import path from "node:path";
+var TOOL_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "runtime",
+  "entrypoint",
+  "inputSchema",
+  "timeoutMs",
+  "maxOutputBytes"
+]);
+var SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "description",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "enum",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems"
+]);
+var TYPES = /* @__PURE__ */ new Set(["object", "array", "string", "number", "integer", "boolean", "null"]);
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function extensionToolName(id, name) {
+  return `extension_${id}__${name}`;
+}
+function validateSchema(value, depth = 0) {
+  if (depth > 12 || !record(value))
+    throw new Error("inputSchema must be a JSON schema object with at most 12 nesting levels");
+  for (const key of Object.keys(value)) {
+    if (!SCHEMA_KEYS.has(key)) throw new Error(`unsupported inputSchema keyword '${key}'`);
+  }
+  if (typeof value.type !== "string" || !TYPES.has(value.type))
+    throw new Error("inputSchema.type must be a supported JSON type");
+  if (value.description !== void 0 && typeof value.description !== "string")
+    throw new Error("inputSchema.description must be a string");
+  if (value.enum !== void 0 && (!Array.isArray(value.enum) || value.enum.length === 0 || value.enum.some((item) => item !== null && typeof item === "object"))) {
+    throw new Error("inputSchema.enum must contain JSON scalar values");
+  }
+  for (const key of ["minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"]) {
+    if (value[key] !== void 0 && (typeof value[key] !== "number" || !Number.isFinite(value[key])))
+      throw new Error(`inputSchema.${key} must be finite`);
+  }
+  if (value.type === "object") {
+    if (!record(value.properties) || value.additionalProperties !== false)
+      throw new Error("object inputSchema requires properties and additionalProperties: false");
+    for (const [key, child] of Object.entries(value.properties)) {
+      if (["__proto__", "constructor", "prototype"].includes(key)) throw new Error("unsafe inputSchema property name");
+      validateSchema(child, depth + 1);
     }
+    if (value.required !== void 0 && (!Array.isArray(value.required) || value.required.some((key) => typeof key !== "string" || !Object.hasOwn(value.properties, key)))) {
+      throw new Error("inputSchema.required must name declared properties");
+    }
+  } else if (value.type === "array") {
+    validateSchema(value.items, depth + 1);
   }
-  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 parseExtensionCapabilities(value, id) {
+  if (!record(value) || Object.keys(value).some((key) => key !== "tools") || !Array.isArray(value.tools) || value.tools.length === 0 || value.tools.length > 32) {
+    throw new Error("capabilities must contain tools with between 1 and 32 command declarations");
+  }
+  if (id.includes("__")) throw new Error("v2 extension id cannot contain double underscores");
+  const names = /* @__PURE__ */ new Set();
+  const tools = value.tools.map((tool) => {
+    if (!record(tool)) throw new Error("capabilities.tools entries must be objects");
+    for (const key of Object.keys(tool)) if (!TOOL_KEYS.has(key)) throw new Error(`unknown command tool key '${key}'`);
+    if (typeof tool.name !== "string" || !/^[a-z][a-z0-9_]*$/.test(tool.name) || tool.name.includes("__"))
+      throw new Error("command tool name must use lowercase letters, digits, and single underscores");
+    const name = extensionToolName(id, tool.name);
+    if (name.length > 64 || !/^[a-zA-Z0-9_-]+$/.test(name))
+      throw new Error("qualified command tool name must use provider-safe characters and fit 64 characters");
+    if (names.has(name)) throw new Error(`duplicate command tool name '${name}'`);
+    names.add(name);
+    if (typeof tool.description !== "string" || tool.description.trim().length === 0 || tool.description.length > 2e3)
+      throw new Error("command tool description must contain 1 to 2000 characters");
+    if (tool.runtime !== "node" && tool.runtime !== "python3")
+      throw new Error("command tool runtime must be node or python3");
+    if (typeof tool.entrypoint !== "string" || tool.entrypoint.includes("\0") || tool.entrypoint.includes("\\") || path.isAbsolute(tool.entrypoint) || tool.entrypoint.split("/").some((part) => part === ".." || part === "." || part === ""))
+      throw new Error("command tool entrypoint must be a contained relative file path");
+    validateSchema(tool.inputSchema);
+    if (tool.inputSchema.type !== "object") throw new Error("command tool inputSchema root must be object");
+    for (const [key, maximum] of [
+      ["timeoutMs", 3e5],
+      ["maxOutputBytes", 1048576]
+    ]) {
+      const limit = tool[key];
+      if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > maximum))
+        throw new Error(`command tool ${key} must be between 1 and ${maximum}`);
+    }
+    return structuredClone(tool);
+  });
+  return { tools };
 }
-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 resolveExtensionEntrypoint(root, entrypoint) {
+  const canonicalRoot = realpathSync(root);
+  let cursor = canonicalRoot;
+  for (const segment of entrypoint.split("/")) {
+    if (segment === ".." || segment === "." || segment.length === 0)
+      throw new Error("invalid command entrypoint segment");
+    cursor = path.join(cursor, segment);
+    if (lstatSync(cursor).isSymbolicLink()) throw new Error("command entrypoint cannot contain symbolic links");
+  }
+  const stat = lstatSync(cursor);
+  if (!stat.isFile() || stat.nlink !== 1) throw new Error("command entrypoint must be an ordinary file with one link");
+  const relative = path.relative(canonicalRoot, realpathSync(cursor));
+  if (relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+    throw new Error("command entrypoint escapes extension root");
+  return cursor;
 }
-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 };
+
+// src/domains/extensions/runtime-schema.ts
+init_esm_shims();
+import { stripVTControlCharacters } from "node:util";
+var RUNTIME_LIMITS = {
+  processes: 4,
+  messageBytes: 96 * 1024,
+  outputBytes: 64 * 1024,
+  argumentBytes: 16 * 1024,
+  startupMs: 5e3,
+  commandMs: 3e4,
+  observationMs: 2e3,
+  disposeMs: 250,
+  diagnosticsBytes: 64 * 1024
+};
+function record2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("expected an object");
+  return value;
 }
-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 keys(value, allowed) {
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`unknown runtime field '${key}'`);
 }
-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 string(value, max) {
+  if (typeof value !== "string" || value.length === 0 || value.length > max)
+    throw new Error(`expected text of 1-${max} characters`);
+  return value;
 }
-function floor(partial) {
-  return {
-    major: partial.major ?? 0,
-    minor: partial.minor ?? 0,
-    patch: partial.patch ?? 0,
-    prerelease: partial.prerelease
-  };
+function array(value, max) {
+  if (!Array.isArray(value) || value.length > max) throw new Error(`expected an array of at most ${max} entries`);
+  return value;
 }
-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 choices(value, allowed) {
+  const entries = array(value ?? [], allowed.length).map((item) => {
+    if (!allowed.includes(item)) throw new Error(`unsupported runtime capability '${String(item)}'`);
+    return item;
+  });
+  if (new Set(entries).size !== entries.length) throw new Error("duplicate runtime capability");
+  return entries;
 }
-function lowerBound(version, inclusive) {
-  return (candidate) => inclusive ? compare(candidate, version) >= 0 : compare(candidate, version) > 0;
+function parseExtensionRuntime(value) {
+  const raw = record2(value);
+  keys(raw, ["api", "entrypoint", "commands", "events", "ui"]);
+  if (raw.api !== 1) throw new Error("runtime.api must be 1");
+  const entrypoint = string(raw.entrypoint, 240);
+  if (!entrypoint.endsWith(".mjs")) throw new Error("runtime.entrypoint must be a shipped .mjs file");
+  const names = /* @__PURE__ */ new Set();
+  const commands = array(raw.commands ?? [], 32).map((value2) => {
+    const command = record2(value2);
+    keys(command, ["name", "description", "timeoutMs"]);
+    const name = string(command.name, 40);
+    if (!/^[a-z][a-z0-9_]*$/.test(name) || names.has(name))
+      throw new Error(`invalid or duplicate runtime command '${name}'`);
+    names.add(name);
+    const description = string(command.description, 240);
+    const timeoutMs = command.timeoutMs ?? RUNTIME_LIMITS.commandMs;
+    if (!Number.isInteger(timeoutMs) || Number(timeoutMs) < 100 || Number(timeoutMs) > 3e5)
+      throw new Error("runtime command timeoutMs must be 100-300000");
+    return { name, description, timeoutMs: Number(timeoutMs) };
+  });
+  return {
+    api: 1,
+    entrypoint,
+    commands,
+    events: choices(raw.events, ["session_open", "turn_end"]),
+    ui: choices(raw.ui, ["status", "panel"])
+  };
 }
-function upperBound(version, inclusive) {
-  return (candidate) => inclusive ? compare(candidate, version) <= 0 : compare(candidate, version) < 0;
+function extensionPlainText(value) {
+  return stripVTControlCharacters(value).replace(
+    /[\p{Cc}\p{Cf}]/gu,
+    (char) => char === "\n" || char === "	" ? char : ""
+  );
 }
-function core(version) {
-  return `${version.major}.${version.minor}.${version.patch}`;
+function text(value, max) {
+  if (value === "") return "";
+  return extensionPlainText(string(value, max));
 }
-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 };
+function parseExtensionOutput(value, declaration) {
+  if (Buffer.byteLength(JSON.stringify(value) ?? "") > RUNTIME_LIMITS.outputBytes)
+    throw new Error("runtime output exceeds 64 KiB");
+  const raw = record2(value);
+  keys(raw, ["text", "status", "panel"]);
+  const output = { text: text(raw.text, 32768) };
+  if (raw.status !== void 0) {
+    if (!declaration.ui.includes("status")) throw new Error("runtime did not declare status UI");
+    if (raw.status === null) output.status = null;
+    else {
+      const status = record2(raw.status);
+      keys(status, ["text", "tone"]);
+      const parsed = { text: text(status.text, 160).replaceAll("\n", " ").replaceAll("	", " ") };
+      if (status.tone !== void 0) {
+        const [tone] = choices([status.tone], ["neutral", "positive", "warning", "error"]);
+        if (tone) parsed.tone = tone;
+      }
+      output.status = parsed;
     }
-    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);
+  if (raw.panel !== void 0) {
+    if (!declaration.ui.includes("panel")) throw new Error("runtime did not declare panel UI");
+    const panel = record2(raw.panel);
+    keys(panel, ["title", "sections"]);
+    const parsed = { title: text(panel.title, 120), sections: [] };
+    for (const value2 of array(panel.sections, 16)) {
+      const section = record2(value2);
+      if (section.kind === "text") {
+        keys(section, ["kind", "text"]);
+        parsed.sections.push({ kind: "text", text: text(section.text, 8192) });
+      } else if (section.kind === "metrics") {
+        keys(section, ["kind", "items"]);
+        parsed.sections.push({
+          kind: "metrics",
+          items: array(section.items, 32).map((value3) => {
+            const item = record2(value3);
+            keys(item, ["label", "value"]);
+            return { label: text(item.label, 120), value: text(item.value, 240) };
+          })
+        });
+      } else if (section.kind === "table") {
+        keys(section, ["kind", "columns", "rows"]);
+        const columns = array(section.columns, 8).map((value3) => text(value3, 80));
+        if (columns.length === 0) throw new Error("table needs columns");
+        const rows = array(section.rows, 100).map((row) => {
+          const cells = array(row, columns.length);
+          if (cells.length !== columns.length) throw new Error("table row width differs from columns");
+          return cells.map((value3) => text(value3, 240));
+        });
+        parsed.sections.push({ kind: "table", columns, rows });
+      } else throw new Error("unsupported panel section");
+    }
+    output.panel = parsed;
   }
-  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;
+  return output;
 }
-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
-  };
+function extensionPanelText(panel) {
+  return [
+    panel.title,
+    ...panel.sections.flatMap((section) => {
+      if (section.kind === "text") return [section.text];
+      if (section.kind === "metrics") return section.items.map((item) => `${item.label}: ${item.value}`);
+      return [section.columns.join(" | "), ...section.rows.map((row) => row.join(" | "))];
+    })
+  ].join("\n\n");
 }
 
 // src/domains/extensions/discovery.ts
 var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
-var MANIFEST_KEYS = /* @__PURE__ */ new Set([
-  "manifestVersion",
-  "id",
-  "name",
-  "version",
-  "description",
-  "resources",
-  "tools",
-  "settings",
-  "compatibility"
-]);
-var RESOURCE_KEYS = /* @__PURE__ */ new Set(["skills", "prompts", "agents", "fleets", "themes"]);
+var MANIFEST_KEYS = /* @__PURE__ */ new Set(["id", "name", "version", "description", "compatibility", "capabilities", "runtime"]);
 var COMPATIBILITY_KEYS = /* @__PURE__ */ new Set(["clio"]);
+var PLUGIN_OWNED_KEYS = /* @__PURE__ */ new Set(["resources", "skills", "prompts", "agents", "fleets", "themes"]);
+var PLUGIN_GUIDANCE = "domain resources belong in a plugin: clio-coder library install <path>";
 function compareNames(a, b) {
   return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
 }
@@ -279,168 +322,22 @@ function rejectUnknownKeys(value, allowed, label, manifestPath, diagnostics) {
     }
   }
 }
-function normalizeResources(value, manifestPath, diagnostics) {
-  if (value === void 0) return {};
-  if (!isRecord(value)) {
-    diagnostics.push({ type: "error", message: "resources must be an object", path: manifestPath });
-    return {};
-  }
-  rejectUnknownKeys(value, RESOURCE_KEYS, "resources", manifestPath, diagnostics);
-  const out = {};
-  for (const kind of RESOURCE_KEYS) {
-    if (value[kind] === void 0) continue;
-    const resourcePath = trimString(value[kind]);
-    if (!resourcePath) {
-      diagnostics.push({
-        type: "error",
-        message: `resources.${kind} must be a non-empty string`,
-        path: manifestPath
-      });
-      continue;
-    }
-    out[kind] = resourcePath;
-  }
-  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 (!statSync(resolved).isDirectory()) {
-      diagnostics.push({ type: "error", message: `resources.${kind} is not a directory`, path: resolved });
-      return;
-    }
-  } catch (error) {
+function rejectManifestKeys(value, manifestPath, diagnostics) {
+  for (const key of Object.keys(value).sort()) {
+    if (MANIFEST_KEYS.has(key)) continue;
     diagnostics.push({
       type: "error",
-      message: `resources.${kind} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`,
-      path: resolved
+      message: PLUGIN_OWNED_KEYS.has(key) ? `harness extensions cannot declare '${key}'; ${PLUGIN_GUIDANCE}` : `unknown manifest key '${key}'`,
+      path: manifestPath
     });
-    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(compareNames)) {
-      const candidate = path.join(directory, entry.name);
-      if (entry.isSymbolicLink()) {
-        try {
-          const canonicalTarget = realpathSync(candidate);
-          if (!contained(canonicalRoot, canonicalTarget)) {
-            diagnostics.push({
-              type: "error",
-              message: `resources.${kind} contains an escaping symbolic link`,
-              path: candidate
-            });
-            continue;
-          }
-          const targetStat = statSync(candidate);
-          if (!targetStat.isDirectory() && !targetStat.isFile()) {
-            diagnostics.push({
-              type: "error",
-              message: `resources.${kind} contains a symbolic link to an unsupported filesystem entry`,
-              path: candidate
-            });
-          } else if (targetStat.isFile() && targetStat.nlink !== 1) {
-            diagnostics.push({
-              type: "error",
-              message: `resources.${kind} contains a symbolic link to a hard-linked file`,
-              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);
-      } else if (entry.isFile()) {
-        try {
-          if (lstatSync(candidate).nlink !== 1) {
-            diagnostics.push({
-              type: "error",
-              message: `resources.${kind} contains a hard-linked file`,
-              path: candidate
-            });
-          }
-        } catch (error) {
-          diagnostics.push({
-            type: "error",
-            message: `resources.${kind} entry could not be inspected: ${error instanceof Error ? error.message : String(error)}`,
-            path: candidate
-          });
-        }
-      } else {
-        diagnostics.push({
-          type: "error",
-          message: `resources.${kind} contains an unsupported filesystem entry`,
-          path: candidate
-        });
-      }
-    }
-  }
-}
-function validateResourceRoots(root, resources, diagnostics) {
-  for (const [kind, resourcePath] of Object.entries(resources)) {
-    if (resourcePath) validateResourceTree(root, resourcePath, kind, diagnostics);
-  }
-}
-function stringArray(value, field, manifestPath, diagnostics) {
-  if (value === void 0) return void 0;
-  if (!Array.isArray(value)) {
-    diagnostics.push({ type: "error", message: `${field} must be an array of non-empty strings`, path: manifestPath });
-    return void 0;
-  }
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of value) {
-    const parsed = trimString(entry);
-    if (!parsed) {
-      diagnostics.push({ type: "error", message: `${field} must contain only non-empty strings`, path: manifestPath });
-      continue;
-    }
-    if (seen.has(parsed)) {
-      diagnostics.push({ type: "error", message: `${field} contains duplicate entry '${parsed}'`, path: manifestPath });
-      continue;
-    }
-    seen.add(parsed);
-    out.push(parsed);
-  }
-  return out.length > 0 ? out : void 0;
 }
 function parseExtensionManifest(value, manifestPath) {
   const diagnostics = [];
   if (!isRecord(value)) {
     return { diagnostics: [{ type: "error", message: "extension manifest must be an object", path: manifestPath }] };
   }
-  rejectUnknownKeys(value, MANIFEST_KEYS, "manifest", manifestPath, diagnostics);
-  if (value.manifestVersion !== 1) {
-    diagnostics.push({ type: "error", message: "manifestVersion must be 1", path: manifestPath });
-  }
+  rejectManifestKeys(value, manifestPath, diagnostics);
   const id = trimString(value.id);
   const name = trimString(value.name) ?? id;
   const version = trimString(value.version);
@@ -452,9 +349,30 @@ function parseExtensionManifest(value, manifestPath) {
   }
   if (!version) diagnostics.push({ type: "error", message: "version is required", path: manifestPath });
   if (!description) diagnostics.push({ type: "error", message: "description is required", path: manifestPath });
-  const resources = normalizeResources(value.resources, manifestPath, diagnostics);
-  const tools = stringArray(value.tools, "tools", manifestPath, diagnostics);
-  const settings = stringArray(value.settings, "settings", manifestPath, diagnostics);
+  let capabilities;
+  let runtime;
+  if (value.runtime !== void 0) {
+    try {
+      runtime = parseExtensionRuntime(value.runtime);
+    } catch (error) {
+      diagnostics.push({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        path: manifestPath
+      });
+    }
+  }
+  if (value.capabilities !== void 0) {
+    try {
+      capabilities = parseExtensionCapabilities(value.capabilities, id ?? "");
+    } catch (error) {
+      diagnostics.push({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        path: manifestPath
+      });
+    }
+  }
   let compatibility;
   if (value.compatibility !== void 0) {
     if (!isRecord(value.compatibility)) {
@@ -489,16 +407,9 @@ function parseExtensionManifest(value, manifestPath) {
   if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
     return { diagnostics };
   }
-  const manifest = {
-    manifestVersion: 1,
-    id,
-    name,
-    version,
-    description,
-    resources
-  };
-  if (tools) manifest.tools = tools;
-  if (settings) manifest.settings = settings;
+  const manifest = { id, name, version, description };
+  if (runtime) manifest.runtime = runtime;
+  if (capabilities) manifest.capabilities = capabilities;
   if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
   const clioRange = manifest.compatibility?.clio;
   if (clioRange !== void 0) {
@@ -515,7 +426,7 @@ function parseExtensionManifest(value, manifestPath) {
 }
 function findExtensionManifestPath(root) {
   for (const name of MANIFEST_NAMES) {
-    const candidate = path.join(root, name);
+    const candidate = path2.join(root, name);
     try {
       if (statSync(candidate).isFile()) return candidate;
     } catch {
@@ -534,7 +445,28 @@ function loadManifestFromRoot(root) {
   }
   try {
     const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
-    if (parsed.manifest) validateResourceRoots(root, parsed.manifest.resources, parsed.diagnostics);
+    if (parsed.manifest?.runtime) {
+      try {
+        resolveExtensionEntrypoint(root, parsed.manifest.runtime.entrypoint);
+      } catch (error) {
+        parsed.diagnostics.push({
+          type: "error",
+          message: `runtime: ${error instanceof Error ? error.message : String(error)}`,
+          path: manifestPath
+        });
+      }
+    }
+    for (const tool of parsed.manifest?.capabilities?.tools ?? []) {
+      try {
+        resolveExtensionEntrypoint(root, tool.entrypoint);
+      } catch (error) {
+        parsed.diagnostics.push({
+          type: "error",
+          message: `command tool ${tool.name}: ${error instanceof Error ? error.message : String(error)}`,
+          path: manifestPath
+        });
+      }
+    }
     return {
       path: root,
       manifestPath,
@@ -553,7 +485,7 @@ function loadManifestFromRoot(root) {
   }
 }
 function discoverExtensionPackages(root) {
-  const full = path.resolve(root);
+  const full = path2.resolve(root);
   if (!existsSync(full)) {
     return [{ path: full, valid: false, diagnostics: [{ type: "error", message: "path does not exist", path: full }] }];
   }
@@ -586,7 +518,7 @@ function discoverExtensionPackages(root) {
   }
   let canonicalFull;
   try {
-    canonicalFull = realpathSync(full);
+    canonicalFull = realpathSync2(full);
   } catch (error) {
     return [
       {
@@ -627,10 +559,10 @@ function discoverExtensionPackages(root) {
   }
   for (const entry of entries.sort(compareNames)) {
     if (entry.name.startsWith(".")) continue;
-    const child = path.join(canonicalFull, entry.name);
+    const child = path2.join(canonicalFull, entry.name);
     try {
       if (!entry.isDirectory() && !(entry.isSymbolicLink() && statSync(child).isDirectory())) continue;
-      const canonicalChild = realpathSync(child);
+      const canonicalChild = realpathSync2(child);
       const spellings = spellingsByCanonicalRoot.get(canonicalChild) ?? [];
       spellings.push(child);
       spellingsByCanonicalRoot.set(canonicalChild, spellings);
@@ -688,163 +620,9 @@ function discoverExtensionPackages(root) {
 
 // src/domains/extensions/state.ts
 init_esm_shims();
-import { createHash as createHash2 } from "node:crypto";
-import {
-  cpSync,
-  existsSync as existsSync2,
-  lstatSync as lstatSync3,
-  mkdirSync,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync3,
-  realpathSync as realpathSync3,
-  renameSync,
-  rmSync
-} from "node:fs";
-import path3 from "node:path";
-
-// src/domains/extensions/integrity.ts
-init_esm_shims();
 import { createHash } from "node:crypto";
-import {
-  closeSync,
-  constants,
-  fstatSync,
-  lstatSync as lstatSync2,
-  openSync,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync2,
-  readlinkSync,
-  realpathSync as realpathSync2
-} from "node:fs";
-import path2 from "node:path";
-function contained2(root, candidate) {
-  const relative = path2.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
-}
-function digestFrame(hash, kind, relativePath, payload) {
-  const header = Buffer.from(
-    `${kind}\0${relativePath.replaceAll(path2.sep, "/")}\0${payload?.byteLength ?? 0}\0`,
-    "utf8"
-  );
-  hash.update(header);
-  if (payload) hash.update(payload);
-  hash.update("\0");
-}
-function sameFileState(left, right) {
-  return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.nlink === right.nlink && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
-}
-function readStableRegularFile(filePath, inspected) {
-  const fd = openSync(filePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-  try {
-    const opened = fstatSync(fd);
-    if (!opened.isFile() || opened.nlink !== 1 || !sameFileState(inspected, opened)) {
-      throw new Error(`extension file changed while being opened: ${filePath}`);
-    }
-    const payload = readFileSync2(fd);
-    if (!sameFileState(opened, fstatSync(fd))) {
-      throw new Error(`extension file changed while being hashed: ${filePath}`);
-    }
-    return payload;
-  } finally {
-    closeSync(fd);
-  }
-}
-function readStableContainedLink(linkPath, inspected, canonicalRoot) {
-  const canonicalTarget = realpathSync2(linkPath);
-  if (!contained2(canonicalRoot, canonicalTarget)) {
-    throw new Error(`symbolic link escapes the extension root: ${linkPath}`);
-  }
-  const target = readlinkSync(linkPath);
-  const after = lstatSync2(linkPath);
-  if (!after.isSymbolicLink() || !sameFileState(inspected, after)) {
-    throw new Error(`symbolic link changed while being hashed: ${linkPath}`);
-  }
-  const canonicalAfter = realpathSync2(linkPath);
-  if (canonicalAfter !== canonicalTarget || !contained2(canonicalRoot, canonicalAfter)) {
-    throw new Error(`symbolic link changed or escapes the extension root: ${linkPath}`);
-  }
-  return Buffer.from(target, "utf8");
-}
-function assertStableDirectory(directoryPath, inspected, canonicalDirectory, canonicalRoot, expectedEntries) {
-  const after = lstatSync2(directoryPath);
-  if (!after.isDirectory() || !sameFileState(inspected, after)) {
-    throw new Error(`extension directory changed while being hashed: ${directoryPath}`);
-  }
-  const canonicalAfter = realpathSync2(directoryPath);
-  if (canonicalAfter !== canonicalDirectory || !contained2(canonicalRoot, canonicalAfter)) {
-    throw new Error(`extension directory changed or escapes the extension root: ${directoryPath}`);
-  }
-  if (expectedEntries !== void 0) {
-    const currentEntries = readdirSync2(directoryPath).sort();
-    if (currentEntries.length !== expectedEntries.length || currentEntries.some((entry, index) => entry !== expectedEntries[index])) {
-      throw new Error(`extension directory entries changed while being hashed: ${directoryPath}`);
-    }
-  }
-}
-function readStableDirectory(directoryPath, inspected, canonicalRoot) {
-  const canonicalDirectory = realpathSync2(directoryPath);
-  if (!contained2(canonicalRoot, canonicalDirectory)) {
-    throw new Error(`extension directory escapes the extension root: ${directoryPath}`);
-  }
-  const entries = readdirSync2(directoryPath).sort();
-  assertStableDirectory(directoryPath, inspected, canonicalDirectory, canonicalRoot);
-  return { canonicalDirectory, entries };
-}
-function extensionContentDigestWithCapture(root, options = {}) {
-  const resolvedRoot = path2.resolve(root);
-  const rootStat = lstatSync2(resolvedRoot);
-  if (rootStat.isSymbolicLink()) {
-    throw new Error(`extension root must be a directory, not a symbolic link: ${resolvedRoot}`);
-  }
-  if (!rootStat.isDirectory()) {
-    throw new Error(`extension root must be a directory: ${resolvedRoot}`);
-  }
-  const canonicalRoot = realpathSync2(resolvedRoot);
-  const canonicalizedRootStat = lstatSync2(resolvedRoot);
-  if (!canonicalizedRootStat.isDirectory() || !sameFileState(rootStat, canonicalizedRootStat)) {
-    throw new Error(`extension root changed while being canonicalized: ${resolvedRoot}`);
-  }
-  const hash = createHash("sha256");
-  const requested = new Set((options.capture ?? []).map((entry) => entry.replaceAll(path2.sep, "/")));
-  const captured = /* @__PURE__ */ new Map();
-  const visit = (absolutePath, relativePath) => {
-    const stat = lstatSync2(absolutePath);
-    if (stat.isSymbolicLink()) {
-      if (relativePath === "") {
-        throw new Error(`extension root changed to a symbolic link while being hashed: ${absolutePath}`);
-      }
-      digestFrame(hash, "link", relativePath, readStableContainedLink(absolutePath, stat, canonicalRoot));
-      return;
-    }
-    if (stat.isDirectory()) {
-      digestFrame(hash, "directory", relativePath);
-      const { canonicalDirectory, entries } = readStableDirectory(absolutePath, stat, canonicalRoot);
-      for (const entry of entries) {
-        visit(path2.join(absolutePath, entry), relativePath ? path2.join(relativePath, entry) : entry);
-      }
-      assertStableDirectory(absolutePath, stat, canonicalDirectory, canonicalRoot, entries);
-      return;
-    }
-    if (stat.isFile()) {
-      if (stat.nlink !== 1) {
-        throw new Error(`hard-linked file is unsupported in an extension: ${absolutePath}`);
-      }
-      const payload = readStableRegularFile(absolutePath, stat);
-      digestFrame(hash, "file", relativePath, payload);
-      const key = relativePath.replaceAll(path2.sep, "/");
-      if (requested.has(key)) captured.set(key, payload);
-      return;
-    }
-    throw new Error(`unsupported filesystem entry in extension: ${absolutePath}`);
-  };
-  visit(resolvedRoot, "");
-  return { digest: hash.digest("hex"), captured };
-}
-function extensionContentDigest(root) {
-  return extensionContentDigestWithCapture(root).digest;
-}
-
-// src/domains/extensions/state.ts
+import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync as realpathSync3, renameSync, rmSync } from "node:fs";
+import path3 from "node:path";
 var DEFAULT_STATE = { version: 1, disabled: [], installed: {} };
 function extensionBaseDir(scope, cwd = process.cwd()) {
   return scope === "user" ? path3.join(clioConfigDir(), "extensions") : path3.join(path3.resolve(cwd), ".clio-coder", "extensions");
@@ -861,7 +639,7 @@ function packageRecoveryPath(root, label) {
 function preserveFile(filePath, label) {
   if (!existsSync2(filePath)) return void 0;
   const backupPath = recoveryPath(filePath, label);
-  safeResourceWrite(backupPath, readFileSync3(filePath));
+  safeResourceWrite(backupPath, readFileSync2(filePath));
   return backupPath;
 }
 function scopeRank(scope) {
@@ -871,7 +649,7 @@ function readState(scope, cwd = process.cwd()) {
   const filePath = statePath(scope, cwd);
   if (!existsSync2(filePath)) return { status: "absent", state: structuredClone(DEFAULT_STATE) };
   try {
-    const parsed = JSON.parse(readFileSync3(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
     if (!isRecord(parsed) || parsed.version !== 1) throw new Error("state must be a version 1 object");
     if (!Array.isArray(parsed.disabled) || !parsed.disabled.every((entry) => typeof entry === "string")) {
       throw new Error("state.disabled must be an array of strings");
@@ -941,7 +719,7 @@ function installedFromRoot(root, scope, stateResult, cwd, fallbackId) {
   } else if (!expectedDigest) {
     diagnostics.push({
       type: "error",
-      message: `extension ${id} install provenance has no content digest; run clio-coder upgrade, then reinstall with --force if it remains unverifiable`,
+      message: `extension ${id} install provenance has no content digest; reinstall with --force`,
       path: statePath(scope, cwd)
     });
   } else {
@@ -977,7 +755,7 @@ function installedFromRoot(root, scope, stateResult, cwd, fallbackId) {
     scope,
     ...provenance?.source ? { sourcePath: provenance.source } : {},
     canonicalRoot: realpathSync3(root),
-    manifestDigest: createHash2("sha256").update(manifestBytes).digest("hex"),
+    manifestDigest: createHash("sha256").update(manifestBytes).digest("hex"),
     contentDigest: expectedDigest
   } : void 0;
   const entry = {
@@ -985,6 +763,8 @@ function installedFromRoot(root, scope, stateResult, cwd, fallbackId) {
     name: manifest?.name ?? id,
     version: manifest?.version ?? "unknown",
     description: manifest?.description ?? "Installed extension has an invalid manifest.",
+    ...manifest?.capabilities ? { capabilities: manifest.capabilities } : {},
+    ...manifest?.runtime ? { runtime: manifest.runtime } : {},
     scope,
     rootPath: root,
     manifestPath: candidate.manifestPath ?? root,
@@ -995,7 +775,6 @@ function installedFromRoot(root, scope, stateResult, cwd, fallbackId) {
     loadable: false,
     ...extensionProvenance ? { provenance: extensionProvenance } : {},
     ...observedDigest ? { observedContentDigest: observedDigest } : {},
-    resources: manifest?.resources ?? {},
     diagnostics
   };
   return { entry, ...extensionProvenance && captured ? { captured } : {} };
@@ -1005,7 +784,7 @@ function listScope(scope, cwd = process.cwd()) {
   if (!existsSync2(base)) return [];
   const state = readState(scope, cwd);
   const out = [];
-  for (const entry of readdirSync3(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of readdirSync2(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
     const root = path3.join(base, entry.name);
     const installed = installedFromRoot(root, scope, state, cwd, entry.name);
@@ -1013,84 +792,24 @@ function listScope(scope, cwd = process.cwd()) {
   }
   return out;
 }
-function upgradeLegacyExtensionInstallState(cwd = process.cwd(), scopes = ["user", "project"]) {
-  const reports = [];
-  for (const scope of scopes) {
-    const filePath = statePath(scope, cwd);
-    const report = { scope, statePath: filePath, upgraded: [], refused: [] };
-    const stateResult = readState(scope, cwd);
-    if (stateResult.status === "absent") {
-      reports.push(report);
-      continue;
-    }
-    if (stateResult.status === "corrupt") {
-      report.refused.push({ id: "<state>", reason: `install state is corrupt: ${stateResult.message}` });
-      reports.push(report);
-      continue;
-    }
-    const next = structuredClone(stateResult.state);
-    const verified = /* @__PURE__ */ new Map();
-    for (const [id, record] of Object.entries(next.installed)) {
-      if (record.contentDigest) continue;
-      const root = path3.join(extensionBaseDir(scope, cwd), id);
-      try {
-        if (!lstatSync3(root).isDirectory()) throw new Error("installed path is not a directory");
-        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 !== id) {
-          throw new Error(`manifest id ${candidate.manifest.id} does not match install record ${id}`);
-        }
-        const digest = extensionContentDigest(root);
-        record.contentDigest = digest;
-        verified.set(id, { root, digest });
-        report.upgraded.push(id);
-      } catch (error) {
-        report.refused.push({ id, reason: error instanceof Error ? error.message : String(error) });
-      }
-    }
-    if (report.upgraded.length > 0) {
-      const backupPath = `${filePath}.pre-digest.bak`;
-      safeResourceWrite(filePath, `${JSON.stringify(next, null, 2)}
-`, {
-        encoding: "utf8",
-        backup: { path: backupPath },
-        beforeRename: () => {
-          for (const [id, expected] of verified) {
-            const candidate = loadManifestFromRoot(expected.root);
-            if (!candidate.valid || candidate.manifest?.id !== id) {
-              throw new Error(`extension ${id} became invalid during digest migration`);
-            }
-            const observed = extensionContentDigest(expected.root);
-            if (observed !== expected.digest) throw new Error(`extension ${id} changed during digest migration`);
-          }
-        }
-      });
-      report.backupPath = backupPath;
-    }
-    reports.push(report);
-  }
-  return reports;
-}
 function listInstalledExtensions(cwd = process.cwd(), options = {}) {
-  return listInstalledExtensionRecords(cwd, options).map((record) => record.entry);
+  return listInstalledExtensionRecords(cwd, options).map((record3) => record3.entry);
 }
 function listInstalledExtensionRecords(cwd = process.cwd(), options = {}) {
   const scopes = options.scope ? [options.scope] : ["user", "project"];
   const records = scopes.flatMap((scope) => listScope(scope, cwd));
   const byId = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const entry = record.entry;
+  for (const record3 of records) {
+    const entry = record3.entry;
     const list = byId.get(entry.id) ?? [];
-    list.push(record);
+    list.push(record3);
     byId.set(entry.id, list);
   }
   for (const group of byId.values()) {
-    const winner = group.filter((record) => record.entry.valid && record.entry.compatible).sort((a, b) => scopeRank(a.entry.scope) - scopeRank(b.entry.scope)).at(-1);
-    for (const record of group) {
-      const entry = record.entry;
-      entry.effective = record === winner;
+    const winner = group.filter((record3) => record3.entry.valid && record3.entry.compatible).sort((a, b) => scopeRank(a.entry.scope) - scopeRank(b.entry.scope)).at(-1);
+    for (const record3 of group) {
+      const entry = record3.entry;
+      entry.effective = record3 === winner;
       entry.loadable = entry.valid && entry.compatible && entry.enabled && entry.effective;
       if (entry.valid && entry.compatible && !entry.effective && winner) entry.overriddenBy = winner.entry.scope;
     }
@@ -1319,11 +1038,16 @@ function removeExtension(id, options = {}) {
 }
 
 export {
+  extensionToolName,
+  resolveExtensionEntrypoint,
+  RUNTIME_LIMITS,
+  extensionPlainText,
+  parseExtensionOutput,
+  extensionPanelText,
+  parseExtensionManifest,
   loadManifestFromRoot,
   discoverExtensionPackages,
-  extensionContentDigest,
   extensionBaseDir,
-  upgradeLegacyExtensionInstallState,
   listInstalledExtensions,
   listInstalledExtensionRecords,
   installExtension,
@@ -1331,4 +1055,4 @@ export {
   disableExtension,
   removeExtension
 };
-//# sourceMappingURL=chunk-DZK63TZJ.js.map
+//# sourceMappingURL=chunk-24S3DN22.js.map