@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/context-EZZPT2ZV.js

@@ -0,0 +1,1074 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  buildRecallFields,
+  recallErrorMessage,
+  recallParentTurnId,
+  recallableRefListing,
+  resolveRecall
+} from "./chunk-QGIC5SX5.js";
+import {
+  foldWorkingSet
+} from "./chunk-DBREN25X.js";
+import {
+  checkSkillDrift
+} from "./chunk-H5DPSUBB.js";
+import "./chunk-JCVIL6TY.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-UB33F3YW.js";
+import "./chunk-ORRNGQDV.js";
+import "./chunk-OEMFEL26.js";
+import {
+  discoverMarketplaceSkills,
+  loadSkills,
+  modelVisibleSkills
+} from "./chunk-EXKUF426.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-YJCCMYYT.js";
+import "./chunk-7QQRPB2E.js";
+import "./chunk-6UJ7RDI7.js";
+import {
+  contextToolSurface
+} from "./chunk-LZCCBLRC.js";
+import {
+  OBSERVE_SELF_CAPS,
+  finalizeObservation,
+  observationBudgetExhausted,
+  reserveObservation,
+  truncateHead
+} from "./chunk-526ABLHD.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-OPC4DQD6.js";
+import "./chunk-RAUOKUZV.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-5C2OQHLR.js";
+import "./chunk-QLAGXTTV.js";
+import "./chunk-B6UM3OZC.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-ARRUMZ7X.js";
+import "./chunk-XW2UZICE.js";
+import "./chunk-PGEFOTJB.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-YXFKLMX2.js";
+import "./chunk-E2NSPYLC.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-M4KFUXS7.js";
+import {
+  ToolNames
+} from "./chunk-WLHX3MM5.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import {
+  SKILL_INSTALL_OFFER_OPTION_NEVER,
+  SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
+  SKILL_INSTALL_OFFER_OPTION_PROJECT,
+  SKILL_INSTALL_OFFER_OPTION_USER,
+  SKILL_SUGGESTION_ANCHOR
+} from "./chunk-6R5MBXBJ.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-EM2WNQS2.js";
+import "./chunk-36XSBPXL.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-GD55RTIW.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/context/index.ts
+init_esm_shims();
+import { readdirSync as readdirSync2 } from "node:fs";
+import path from "node:path";
+
+// src/tools/context/docs-engine.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join, relative, resolve } from "node:path";
+var DEFAULT_LIMIT = 5;
+var MAX_LIMIT = 12;
+var SNIPPET_MAX = 360;
+var SNIPPET_CONTEXT_LINES = 2;
+var BODY_K1 = 1.2;
+var BODY_B = 0.75;
+var HEADING_WEIGHT = 3.5;
+var TITLE_WEIGHT = 2;
+var PHRASE_BODY_BOOST = 3;
+var PHRASE_HEADING_BOOST = 7;
+var COVERAGE_BOOST = 4;
+var EXPANDED_TERM_WEIGHT = 0.45;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "can",
+  "for",
+  "from",
+  "how",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "what",
+  "when",
+  "where",
+  "with"
+]);
+var VOCABULARY_ALIASES = [
+  {
+    triggers: ["approval", "confirm", "confirmation", "deny", "permission", "permissions", "prompt"],
+    expansions: ["autonomy", "ask", "deny", "safety", "policy", "full-auto", "read-only"]
+  },
+  {
+    triggers: ["agent", "agents", "dispatch", "fleet", "worker", "workers", "run"],
+    expansions: ["agent", "dispatch", "fleet", "profile", "worker", "receipt", "run"]
+  },
+  {
+    triggers: ["model", "models", "provider", "runtime", "target", "targets", "endpoint"],
+    expansions: ["catalog", "model", "probe", "provider", "runtime", "target", "wireModels"]
+  },
+  {
+    triggers: ["auth", "credential", "credentials", "login", "oauth", "subscription"],
+    expansions: ["auth", "credential", "login", "oauth", "target", "runtime"]
+  },
+  {
+    triggers: ["memory", "evidence", "receipt", "receipts", "audit", "accountability", "provenance"],
+    expansions: ["accountability", "evidence", "findings", "memory", "receipt", "run", "audit"]
+  },
+  {
+    triggers: ["validate", "validated", "validation", "verify", "verified", "test", "tests", "rigor"],
+    expansions: ["validation", "verify", "evidence", "rigor", "finish", "contract", "check"]
+  },
+  {
+    triggers: ["bash", "command", "commands", "shell", "terminal", "tool", "tools"],
+    expansions: ["bash", "command", "tool", "registry", "safety", "result", "cap"]
+  },
+  {
+    triggers: ["context", "compact", "compaction", "token", "tokens", "cache", "prompt"],
+    expansions: ["context", "compaction", "prompt", "token", "cache", "window"]
+  },
+  {
+    triggers: ["hook", "hooks", "middleware", "component", "components", "budget"],
+    expansions: ["middleware", "hook", "effect", "component", "budget", "registration"]
+  },
+  {
+    triggers: ["install", "upgrade", "uninstall", "doctor", "lifecycle", "reset", "paths"],
+    expansions: ["install", "lifecycle", "doctor", "reset", "state", "config", "paths"]
+  },
+  {
+    triggers: ["skill", "skills", "marketplace"],
+    expansions: ["skill", "skills", "marketplace", "discovery", "context"]
+  },
+  {
+    triggers: ["docs", "documentation", "manual", "self"],
+    expansions: ["documentation", "docs", "context", "blueprint", "guide"]
+  }
+];
+var cachedIndex = null;
+function normalizeText(text) {
+  return text.toLowerCase().replace(/[`'"’]/g, "").replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function rawTokens(text) {
+  return normalizeText(text).split(" ").filter(Boolean);
+}
+function stemToken(token) {
+  if (token.length <= 3) return token;
+  if (token.endsWith("ies") && token.length > 4) return `${token.slice(0, -3)}y`;
+  if (token.endsWith("ing") && token.length > 5) return token.slice(0, -3);
+  if (token.endsWith("ed") && token.length > 4) return token.slice(0, -2);
+  if (token.endsWith("es") && token.length > 4) return token.slice(0, -2);
+  if (token.endsWith("s") && token.length > 4) return token.slice(0, -1);
+  return token;
+}
+function tokenize(text, options = {}) {
+  const tokens = rawTokens(text).map(stemToken);
+  return options.keepStopWords ? tokens : tokens.filter((token) => !STOP_WORDS.has(token));
+}
+function countTerms(tokens) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) counts.set(token, (counts.get(token) ?? 0) + 1);
+  return counts;
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+function slugify(heading) {
+  return normalizeText(heading).replace(/\s+/g, "-") || "section";
+}
+function titleFromFile(name) {
+  return basename(name, ".md").split(/[-_]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function parseSections(file, markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const sections = [];
+  let title = titleFromFile(file);
+  let heading = "(overview)";
+  let level = 0;
+  let headingLine = 1;
+  let bodyStartLine = 1;
+  let buffer = [];
+  let inFence = false;
+  const stack = [];
+  const breadcrumbFor = () => {
+    const parts = stack.map((entry) => entry.text);
+    if (heading === "(overview)") return title;
+    return parts.length > 0 ? parts.join(" > ") : heading;
+  };
+  const flush = (endLine) => {
+    const body = buffer.join("\n").trim();
+    if (body.length > 0 || heading !== "(overview)") {
+      sections.push({
+        file,
+        title,
+        heading,
+        breadcrumb: breadcrumbFor(),
+        level,
+        anchor: heading === "(overview)" ? "" : `#${slugify(heading)}`,
+        startLine: headingLine,
+        bodyStartLine,
+        endLine: Math.max(headingLine, endLine),
+        body,
+        bodyLines: [...buffer]
+      });
+    }
+    buffer = [];
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    if (/^\s*(```|~~~)/.test(line)) inFence = !inFence;
+    const headingMatch = inFence ? null : /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (headingMatch) {
+      flush(i);
+      level = (headingMatch[1] ?? "").length;
+      heading = (headingMatch[2] ?? "").trim();
+      if (level === 1) title = heading;
+      while (stack.length > 0 && (stack[stack.length - 1]?.level ?? 0) >= level) stack.pop();
+      stack.push({ level, text: heading });
+      headingLine = i + 1;
+      bodyStartLine = i + 2;
+      continue;
+    }
+    buffer.push(line);
+  }
+  flush(lines.length);
+  return sections;
+}
+function indexSection(section) {
+  const headingText = `${section.title} ${section.breadcrumb} ${section.heading}`;
+  const bodyTokens = tokenize(section.body);
+  const headingTokens = tokenize(headingText);
+  const titleTokens = tokenize(section.title);
+  const bodyCounts = countTerms(bodyTokens);
+  const headingCounts = countTerms(headingTokens);
+  const titleCounts = countTerms(titleTokens);
+  const terms = /* @__PURE__ */ new Set([...bodyCounts.keys(), ...headingCounts.keys(), ...titleCounts.keys()]);
+  return {
+    ...section,
+    bodyCounts,
+    headingCounts,
+    titleCounts,
+    bodyLength: Math.max(1, bodyTokens.length),
+    terms,
+    normalizedBody: normalizeText(section.body),
+    normalizedHeading: normalizeText(headingText)
+  };
+}
+function candidateDocFiles(root) {
+  const docsDir = join(root, "docs");
+  const htmlDir = join(docsDir, "html");
+  const files = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      const absolute = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (absolute !== htmlDir) walk(absolute);
+        continue;
+      }
+      if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+        files.push(relative(root, absolute).replaceAll("\\", "/"));
+      }
+    }
+  };
+  walk(docsDir);
+  for (const name of ["README.md", "CHANGELOG.md", "CLIO-CODER.md"]) {
+    if (existsSync(join(root, name))) files.push(name);
+  }
+  return files;
+}
+function buildDocumentFrequency(sections) {
+  const df = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    for (const term of section.terms) df.set(term, (df.get(term) ?? 0) + 1);
+  }
+  return df;
+}
+function loadDocsIndex() {
+  let root;
+  try {
+    const override = process.env.CLIO_CODER_PACKAGE_ROOT?.trim();
+    if (override) {
+      root = resolve(override);
+    } else {
+      root = resolvePackageRoot();
+    }
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+  const docsDir = join(root, "docs");
+  if (cachedIndex && cachedIndex.dir === docsDir) return { ok: true, index: cachedIndex };
+  const files = candidateDocFiles(root);
+  if (files.length === 0) return { ok: false, message: `bundled docs directory not found at ${docsDir}` };
+  const sections = [];
+  const indexedFiles = [];
+  let docCount = 0;
+  for (const file of files) {
+    let raw;
+    try {
+      raw = readFileSync(join(root, file), "utf8");
+    } catch {
+      continue;
+    }
+    docCount += 1;
+    indexedFiles.push(file);
+    for (const section of parseSections(file, raw)) sections.push(indexSection(section));
+  }
+  if (sections.length === 0) return { ok: false, message: `no markdown sections found under ${docsDir}` };
+  const totalLength = sections.reduce((sum, section) => sum + section.bodyLength, 0);
+  cachedIndex = {
+    dir: docsDir,
+    files: indexedFiles,
+    sections,
+    docCount,
+    avgBodyLength: totalLength / sections.length,
+    documentFrequency: buildDocumentFrequency(sections)
+  };
+  return { ok: true, index: cachedIndex };
+}
+function makeQueryPlan(query) {
+  const originalTokens = unique(tokenize(query));
+  const originalSet = new Set(originalTokens);
+  const expanded = [];
+  for (const rule of VOCABULARY_ALIASES) {
+    const triggerTokens = rule.triggers.flatMap((trigger) => tokenize(trigger));
+    if (!triggerTokens.some((token) => originalSet.has(token))) continue;
+    expanded.push(...rule.expansions.flatMap((term) => tokenize(term)));
+  }
+  const expandedTerms = unique(expanded).filter((term) => !originalSet.has(term));
+  const weightedTerms = [
+    ...originalTokens.map((term) => ({ term, source: "query", weight: 1 })),
+    ...expandedTerms.map((term) => ({ term, source: "alias", weight: EXPANDED_TERM_WEIGHT }))
+  ];
+  const normalizedQuery = normalizeText(query);
+  const phraseCandidates = [
+    normalizedQuery,
+    ...rawTokens(query).slice(0, -1).map((token, index, tokens) => `${token} ${tokens[index + 1] ?? ""}`.trim())
+  ];
+  const phrases = unique(phraseCandidates.filter((phrase) => phrase.includes(" ") && phrase.length >= 5));
+  return { query, originalTokens, weightedTerms, expandedTerms, phrases };
+}
+function idf(index, term) {
+  const df = index.documentFrequency.get(term) ?? 0;
+  return Math.log(1 + (index.sections.length - df + 0.5) / (df + 0.5));
+}
+function bm25(count, sectionLength, avgLength) {
+  if (count <= 0) return 0;
+  return count * (BODY_K1 + 1) / (count + BODY_K1 * (1 - BODY_B + BODY_B * (sectionLength / avgLength)));
+}
+function phraseSignals(section, phrases) {
+  let score = 0;
+  const signals = [];
+  for (const phrase of phrases) {
+    if (section.normalizedHeading.includes(phrase)) {
+      score += PHRASE_HEADING_BOOST;
+      signals.push(`heading phrase: ${phrase}`);
+    }
+    if (section.normalizedBody.includes(phrase)) {
+      score += PHRASE_BODY_BOOST;
+      signals.push(`body phrase: ${phrase}`);
+    }
+  }
+  return { score, signals };
+}
+function scoreSection(index, section, plan) {
+  let score = 0;
+  const matchedTerms = [];
+  const signals = [];
+  let originalHits = 0;
+  for (const weighted of plan.weightedTerms) {
+    const bodyCount = section.bodyCounts.get(weighted.term) ?? 0;
+    const headingCount = section.headingCounts.get(weighted.term) ?? 0;
+    const titleCount = section.titleCounts.get(weighted.term) ?? 0;
+    if (bodyCount + headingCount + titleCount === 0) continue;
+    const termIdf = idf(index, weighted.term);
+    const bodyScore = termIdf * bm25(bodyCount, section.bodyLength, index.avgBodyLength);
+    const headingScore = headingCount > 0 ? termIdf * HEADING_WEIGHT : 0;
+    const titleScore = titleCount > 0 ? termIdf * TITLE_WEIGHT : 0;
+    score += weighted.weight * (bodyScore + headingScore + titleScore);
+    matchedTerms.push(weighted.term);
+    if (weighted.source === "query") originalHits += 1;
+    if (headingCount > 0) signals.push(`heading: ${weighted.term}`);
+    else if (titleCount > 0) signals.push(`title: ${weighted.term}`);
+  }
+  const phrases = phraseSignals(section, plan.phrases);
+  score += phrases.score;
+  signals.push(...phrases.signals);
+  const coverage = plan.originalTokens.length === 0 ? 0 : originalHits / plan.originalTokens.length;
+  score += coverage * COVERAGE_BOOST;
+  if (score <= 0) return null;
+  return {
+    section,
+    score,
+    matchedTerms: unique(matchedTerms).slice(0, 12),
+    signals: unique(signals).slice(0, 6),
+    coverage
+  };
+}
+function cleanSnippet(text) {
+  return text.replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").trim();
+}
+function snippetFor(section, plan) {
+  const needles = unique([...plan.phrases, ...plan.originalTokens, ...plan.expandedTerms.slice(0, 8)]).filter(
+    (needle) => needle.length > 0
+  );
+  let hitLine = -1;
+  let bestNeedleCount = 0;
+  for (let i = 0; i < section.bodyLines.length; i += 1) {
+    const normalized = normalizeText(section.bodyLines[i] ?? "");
+    let needleCount = 0;
+    for (const needle of needles) {
+      if (normalized.includes(needle)) needleCount += 1;
+    }
+    if (needleCount > bestNeedleCount) {
+      bestNeedleCount = needleCount;
+      hitLine = i;
+    }
+  }
+  if (hitLine < 0) hitLine = section.bodyLines.findIndex((line) => line.trim().length > 0);
+  if (hitLine < 0) {
+    return {
+      text: section.heading === "(overview)" ? section.title : section.heading,
+      startLine: section.startLine,
+      endLine: section.startLine
+    };
+  }
+  const from = Math.max(0, hitLine - SNIPPET_CONTEXT_LINES);
+  const to = Math.min(section.bodyLines.length - 1, hitLine + SNIPPET_CONTEXT_LINES);
+  let snippet = cleanSnippet(section.bodyLines.slice(from, to + 1).join(" "));
+  if (snippet.length > SNIPPET_MAX) snippet = `${snippet.slice(0, SNIPPET_MAX - 3).trimEnd()}...`;
+  return {
+    text: snippet,
+    startLine: section.bodyStartLine + from,
+    endLine: section.bodyStartLine + to
+  };
+}
+function clampDocsLimit(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.min(Math.floor(value), MAX_LIMIT);
+  return DEFAULT_LIMIT;
+}
+function resultPayload(index, plan, scored) {
+  const results = scored.map((entry, i) => {
+    const snippet = snippetFor(entry.section, plan);
+    return {
+      rank: i + 1,
+      file: entry.section.file,
+      heading: entry.section.heading,
+      breadcrumb: entry.section.breadcrumb,
+      anchor: entry.section.anchor,
+      lines: { start: entry.section.startLine, end: entry.section.endLine },
+      snippetLines: { start: snippet.startLine, end: snippet.endLine },
+      snippet: snippet.text,
+      score: Number(entry.score.toFixed(3)),
+      coverage: Number(entry.coverage.toFixed(2)),
+      matchedTerms: entry.matchedTerms,
+      signals: entry.signals
+    };
+  });
+  return {
+    version: 2,
+    query: plan.query,
+    corpus: {
+      docs: index.docCount,
+      sections: index.sections.length,
+      files: index.files,
+      excludes: ["docs/html/**"]
+    },
+    terms: {
+      query: plan.originalTokens,
+      expanded: plan.expandedTerms,
+      phrases: plan.phrases
+    },
+    resultCount: results.length,
+    results,
+    followUp: results.length > 0 ? "Cited files are Clio's bundled docs: read them from the installed documentation path named in your prompt, never by searching the workspace for them. For more depth, run another context scope=docs query with more specific terms." : "Try Clio vocabulary such as target, autonomy, dispatch, evidence, middleware, context, validation, install, or model catalog."
+  };
+}
+function listDocsCorpus() {
+  const loaded = loadDocsIndex();
+  if (!loaded.ok) return { ok: false, message: loaded.message };
+  const index = loaded.index;
+  const payload = {
+    version: 2,
+    corpus: {
+      docs: index.docCount,
+      sections: index.sections.length,
+      files: index.files,
+      excludes: ["docs/html/**"]
+    },
+    followUp: "Pass query=<terms> to search these bundled docs; they ship with Clio and are not workspace files. Try Clio vocabulary such as target, autonomy, dispatch, evidence, middleware, context, validation, install, or model catalog."
+  };
+  return { ok: true, payload, fileCount: index.files.length };
+}
+function searchDocs(query, limitArg) {
+  const plan = makeQueryPlan(query);
+  if (plan.originalTokens.length === 0) return { ok: false, message: "query has no searchable terms" };
+  const loaded = loadDocsIndex();
+  if (!loaded.ok) return { ok: false, message: loaded.message };
+  const limit = clampDocsLimit(limitArg);
+  const ranked = loaded.index.sections.map((section) => scoreSection(loaded.index, section, plan)).filter((entry) => entry !== null).sort(
+    (a, b) => b.score - a.score || b.coverage - a.coverage || a.section.file.localeCompare(b.section.file) || a.section.startLine - b.section.startLine || a.section.heading.localeCompare(b.section.heading)
+  );
+  const shown = ranked.slice(0, limit);
+  const next = shown.length === 0 ? `query=${plan.expandedTerms[0] ?? "overview"}` : null;
+  const payload = {
+    ...resultPayload(loaded.index, plan, shown),
+    omitted: ranked.length - shown.length,
+    ...next !== null ? { next } : {}
+  };
+  return { ok: true, payload, resultCount: shown.length, rankedTotal: ranked.length, next };
+}
+
+// src/tools/context/index.ts
+var DEFAULT_TREE_ENTRIES = 50;
+function cwdFromDeps(deps) {
+  return deps?.getCwd?.() ?? process.cwd();
+}
+function buildResourceTree(baseDir, maxEntries) {
+  const out = [];
+  const walk = (dir) => {
+    if (out.length >= maxEntries) return;
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= maxEntries) return;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(baseDir, full).split(path.sep).join("/");
+      if (entry.isDirectory()) {
+        out.push(`${rel}/`);
+        walk(full);
+      } else if (entry.isFile()) {
+        out.push(rel);
+      }
+    }
+  };
+  walk(baseDir);
+  return out;
+}
+function skillSourceOrigin(skill) {
+  return skill.sourceInfo.source ?? `${skill.source}-${skill.scope}`;
+}
+function skillExecutionFrame(skill, workspaceRoot) {
+  return [
+    "How to read this skill:",
+    `- Workspace root: ${workspaceRoot}. Run every command and resolve every repository path there. ${skill.baseDir} holds only this skill's own resource files; it is never the working directory.`,
+    "- This skill may name tools, subagents, or commands from another harness. Use Clio's equivalent from your own tool list; if there is no equivalent, say so and continue without that step. Never invent one, and never substitute repeated calls to a different agent for an agent the skill named.",
+    "- The skill describes a workflow. Your safety policy, permissions, and tool surface still bind it.",
+    ""
+  ];
+}
+function renderSkillBody(skill, tree) {
+  const sourceOrigin = skillSourceOrigin(skill);
+  const lines = [
+    `<skill name="${skill.name}" scope="${skill.scope}" source="${skill.source}" origin="${sourceOrigin}" hash="${skill.hash}">`,
+    `path: ${skill.filePath}`,
+    `base_dir: ${skill.baseDir}`,
+    `source_origin: ${sourceOrigin}`,
+    `disable_model_invocation: ${skill.disableModelInvocation}`
+  ];
+  if (skill.allowedTools) lines.push(`allowed_tools: ${skill.allowedTools.join(", ")}`);
+  if (skill.disallowedTools) lines.push(`disallowed_tools: ${skill.disallowedTools.join(", ")}`);
+  if (skill.diagnostics.length > 0) {
+    lines.push(`diagnostics: ${skill.diagnostics.map((d) => d.message).join("; ")}`);
+  }
+  const metadataKeys = Object.keys(skill.metadata);
+  if (metadataKeys.length > 0) lines.push(`metadata: ${metadataKeys.join(", ")}`);
+  if (tree) {
+    lines.push("resources:");
+    for (const entry of tree) lines.push(`  ${entry}`);
+  }
+  lines.push("", skill.content, "</skill>");
+  return lines.join("\n");
+}
+function policyIsRecipeBound(policy) {
+  return policy.requests.length > 0 && policy.requests.every((request) => request.source === "recipe");
+}
+var NO_PENDING_SKILL_DENIAL = `context: no pending skill request is active this turn; only the operator can activate a skill, so do not retry this load. If a listed skill matches the task, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` and continue the task without it; only the operator can run it. Otherwise continue without skills.`;
+function pendingSkillPolicyError(name, options) {
+  const policy = options?.pendingSkillPolicy;
+  if (!policy) {
+    return NO_PENDING_SKILL_DENIAL;
+  }
+  const recipeBound = policyIsRecipeBound(policy);
+  if (policy.modelActivation === true && !recipeBound) {
+    if (!policy.loadedSkillNames.has(name)) return null;
+    const window = policy.carriedSurface === true ? "in this session" : "this turn";
+    return `context: skill ${name} already loaded ${window}; continue with the loaded workflow and call ask_user if an interview/choice is needed.`;
+  }
+  const allowed = [...new Set(policy.allowedSkillNames.map((entry) => entry.trim()).filter(Boolean))];
+  if (allowed.length === 0) {
+    return NO_PENDING_SKILL_DENIAL;
+  }
+  if (!allowed.includes(name)) {
+    if (recipeBound) return `context: this agent run may load only its declared skill(s): ${allowed.join(", ")}.`;
+    if (policy.carriedSurface === true) return NO_PENDING_SKILL_DENIAL;
+    return `context: this turn has pending skill request(s): ${allowed.join(", ")}. Load only those before doing anything else.`;
+  }
+  if (policy.loadedSkillNames.has(name)) {
+    if (recipeBound) return `context: skill ${name} is already loaded in this run; continue with its workflow.`;
+    const window = policy.carriedSurface === true ? "in this session" : "this turn";
+    return `context: pending skill ${name} already loaded ${window}; continue with the loaded workflow and call ask_user if an interview/choice is needed.`;
+  }
+  return null;
+}
+function pendingSkillRequestFor(name, options) {
+  return options?.pendingSkillPolicy?.requests.find((request) => request.name === name) ?? null;
+}
+function operatorRequestedManualSkill(skill, request) {
+  return skill.trusted && skill.disableModelInvocation && request?.installed === true && (request.source === "slash-command" || request.source === "selector");
+}
+function renderPendingSkillTask(name, options) {
+  const request = pendingSkillRequestFor(name, options);
+  if (!request) return [];
+  if (request.source === "recipe") return [];
+  const task = request.args.trim();
+  const lines = [
+    "Pending skill request",
+    `name: ${request.name}`,
+    `source: ${request.source}`,
+    `task: ${task.length > 0 ? task : "(none supplied)"}`
+  ];
+  if (task.length > 0) {
+    lines.push(
+      "",
+      "Treat task as the user's starting subject for this skill workflow. Do not ask what the subject is again; ask_user only for missing follow-up decisions."
+    );
+  }
+  lines.push("");
+  return lines;
+}
+function marketplaceRowsFor(deps, installed, options) {
+  if (deps.skillMarketplace === false) return [];
+  if (deps.getSkillLoaderOptions?.().disableDiscovery === true) return [];
+  const policy = options?.pendingSkillPolicy;
+  if (policy && policyIsRecipeBound(policy)) return [];
+  const installedNames = new Set(installed.map((skill) => skill.name));
+  try {
+    return discoverMarketplaceSkills({ cwd: cwdFromDeps(deps) }).skills.filter(
+      (entry) => !installedNames.has(entry.name)
+    );
+  } catch {
+    return [];
+  }
+}
+function renderSkillsList(skills, marketplace, marketplaceOffered, modelActivation) {
+  if (skills.length === 0 && marketplace.length === 0) {
+    return marketplaceOffered ? "No skills are installed and no marketplace is configured." : "No skills are installed.";
+  }
+  const lines = ["Available skills.", ""];
+  if (skills.length > 0) {
+    lines.push("Installed:");
+    for (const skill of skills) {
+      lines.push(`- ${skill.name} (${skill.scope}): ${skill.description}`);
+    }
+  } else {
+    lines.push("Installed: none.");
+  }
+  if (marketplace.length > 0) {
+    lines.push("", "Marketplace (not installed; /skill <name> offers to install):");
+    for (const entry of marketplace) {
+      const category = entry.category ? ` [${entry.category}]` : "";
+      lines.push(`- ${entry.name}${category}: ${entry.description}`);
+    }
+  }
+  lines.push(
+    "",
+    modelActivation ? `If one skill above matches the current task, load it now with context(scope="skills", name="<name>") and continue in the same turn; at this autonomy level you activate installed skills yourself and do not wait for the operator. Marketplace rows below are not installed and still need the operator. If none match, do not mention skills.` : `If one skill above matches the current task, begin your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose), then continue the task in the same turn without it; only the operator can run it. If none match, do not mention skills.`
+  );
+  if (marketplace.length > 0) {
+    lines.push(
+      `When no installed skill serves the task but a marketplace skill above genuinely does, you may instead ask the operator with ask_user (mode=single_question, header "Install skill") whether to install it, offering exactly: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". The harness handles the answer and any install; never install or load a skill yourself.`
+    );
+  }
+  return lines.join("\n");
+}
+function runWorkspaceScope(deps, reservation, options) {
+  const workspace = deps.workspace;
+  if (!workspace?.hasSession()) {
+    return { kind: "error", message: "context: workspace scope requires a bound session; none is active here" };
+  }
+  let snap = workspace.getSnapshot();
+  if (!snap) {
+    snap = workspace.probeWorkspace();
+    workspace.saveSnapshot(snap);
+  }
+  const payload = withSkillsPointer(deps, snap);
+  return finalizeObservation({
+    tool: ToolNames.Context,
+    unit: "results",
+    format: "json",
+    output: JSON.stringify(payload, null, 2),
+    shownCount: 1,
+    totalCount: 1,
+    truncated: false,
+    reservation,
+    ...options ? { options } : {}
+  });
+}
+function withSkillsPointer(deps, snap) {
+  let installed = 0;
+  let installable = 0;
+  try {
+    const list = loadSkills({ cwd: cwdFromDeps(deps), ...deps.getSkillLoaderOptions?.() ?? {} });
+    const visible = modelVisibleSkills(list.items);
+    installed = visible.length;
+    installable = marketplaceRowsFor(deps, visible, void 0).length;
+  } catch {
+    return { ...snap };
+  }
+  if (installed === 0 && installable === 0) return { ...snap };
+  return {
+    ...snap,
+    skills: `Skills: ${installed} installed, ${installable} installable from the marketplace. If one matches this task, or the operator names a skill, list them with context(scope="skills") and suggest /skill <name> to the operator; load only on operator request.`
+  };
+}
+function runDocsScope(args, reservation, options) {
+  const query = typeof args.query === "string" ? args.query.trim() : "";
+  if (query.length === 0) {
+    const corpus = listDocsCorpus();
+    if (!corpus.ok) return { kind: "error", message: `context: ${corpus.message}` };
+    return finalizeObservation({
+      tool: ToolNames.Context,
+      unit: "entries",
+      format: "json",
+      output: JSON.stringify(corpus.payload),
+      shownCount: corpus.fileCount,
+      totalCount: corpus.fileCount,
+      truncated: false,
+      reservation,
+      ...options ? { options } : {}
+    });
+  }
+  const outcome = searchDocs(query, args.limit);
+  if (!outcome.ok) return { kind: "error", message: `context: ${outcome.message}` };
+  return finalizeObservation({
+    tool: ToolNames.Context,
+    unit: "sections",
+    format: "json",
+    output: JSON.stringify(outcome.payload),
+    shownCount: outcome.resultCount,
+    totalCount: outcome.rankedTotal,
+    truncated: outcome.resultCount < outcome.rankedTotal,
+    ...outcome.next !== null ? { next: outcome.next } : {},
+    reservation,
+    ...options ? { options } : {}
+  });
+}
+function runSkillsScope(deps, args, reservation, options) {
+  const name = typeof args.name === "string" ? args.name.trim() : "";
+  if (name.length === 0) {
+    const list2 = loadSkills({ cwd: cwdFromDeps(deps), ...deps.getSkillLoaderOptions?.() ?? {} });
+    const visible2 = modelVisibleSkills(list2.items);
+    const marketplace = marketplaceRowsFor(deps, list2.items, options);
+    const rendered = renderSkillsList(
+      visible2,
+      marketplace,
+      deps.skillMarketplace !== false,
+      options?.pendingSkillPolicy?.modelActivation === true
+    );
+    const truncation2 = truncateHead(rendered, { maxBytes: reservation.callCapBytes, maxLines: Number.MAX_SAFE_INTEGER });
+    const total = visible2.length + marketplace.length;
+    return finalizeObservation({
+      tool: ToolNames.Context,
+      unit: "entries",
+      output: truncation2.content,
+      ...truncation2.truncated ? { fullOutput: rendered } : {},
+      shownCount: total,
+      totalCount: total,
+      truncated: truncation2.truncated,
+      details: {
+        skills: visible2.map((skill2) => ({ name: skill2.name, scope: skill2.scope })),
+        marketplace: marketplace.map((entry) => ({
+          name: entry.name,
+          ...entry.category ? { category: entry.category } : {}
+        }))
+      },
+      reservation,
+      ...options ? { options } : {}
+    });
+  }
+  const policyError = pendingSkillPolicyError(name, options);
+  if (policyError) return { kind: "error", message: policyError };
+  const list = loadSkills({ cwd: cwdFromDeps(deps), ...deps.getSkillLoaderOptions?.() ?? {} });
+  const visible = modelVisibleSkills(list.items);
+  const pendingRequest = pendingSkillRequestFor(name, options);
+  const skill = visible.find((item) => item.name === name) ?? list.items.find((item) => item.name === name && operatorRequestedManualSkill(item, pendingRequest));
+  if (!skill) {
+    const unavailable = list.items.find((item) => item.name === name);
+    if (unavailable) {
+      return {
+        kind: "error",
+        message: unavailable.trusted ? `context: skill "${name}" requires explicit operator activation with /skill ${name}; it disables model invocation. Do not retry this load.` : `context: skill "${name}" was discovered in an untrusted ${unavailable.source}/${unavailable.scope} source and cannot be activated. Open /library to inspect its source and trust or install a reviewed native package. Do not retry this load.`
+      };
+    }
+    const installable = marketplaceRowsFor(deps, list.items, options).some((entry) => entry.name === name);
+    if (installable) {
+      return {
+        kind: "error",
+        message: `context: skill "${name}" is not installed; it is available in the marketplace. Ask the operator to run /skill ${name}, which offers to install it, and wait. Do not retry this load.`
+      };
+    }
+    const available = visible.map((item) => item.name).join(", ");
+    const suffix = available.length > 0 ? ` Available skills: ${available}.` : " No skills are currently available.";
+    return { kind: "error", message: `context: unknown skill "${name}".${suffix}` };
+  }
+  const includeTree = args.include_tree === true;
+  const tree = includeTree ? buildResourceTree(skill.baseDir, DEFAULT_TREE_ENTRIES) : null;
+  const pendingTask = pendingRequest?.args.trim() ?? "";
+  const driftReport = checkSkillDrift(skill, cwdFromDeps(deps));
+  const drift = driftReport?.verdict ?? null;
+  const driftWarning = driftReport?.verdict === "mismatch" ? `WARNING skill_drift: '${skill.name}' content (sha256 ${skill.hash.slice(0, 12)}\u2026) no longer matches the hash recorded for it ${driftReport.authority === "pinned-manifest" ? "in the audited skill catalog" : "when it was installed on this machine"} (expected ${driftReport.expected.slice(0, 12)}\u2026); the installed skill drifted from the content it claims to be.` : null;
+  const body = [
+    ...driftWarning !== null ? [driftWarning] : [],
+    ...renderPendingSkillTask(name, options),
+    ...skillExecutionFrame(skill, cwdFromDeps(deps)),
+    renderSkillBody(skill, tree)
+  ].join("\n");
+  const pendingPolicy = options?.pendingSkillPolicy;
+  if (pendingPolicy) {
+    pendingPolicy.loadedSkillNames.add(name);
+    pendingPolicy.loadedSkillPolicies.set(name, {
+      ...skill.allowedTools ? { allowedTools: skill.allowedTools } : {},
+      ...skill.disallowedTools ? { disallowedTools: skill.disallowedTools } : {}
+    });
+  }
+  const truncation = truncateHead(body, { maxBytes: reservation.callCapBytes, maxLines: Number.MAX_SAFE_INTEGER });
+  return finalizeObservation({
+    tool: ToolNames.Context,
+    unit: "sections",
+    output: truncation.content,
+    ...truncation.truncated ? { fullOutput: body } : {},
+    shownCount: 1,
+    totalCount: 1,
+    truncated: truncation.truncated,
+    details: {
+      name: skill.name,
+      description: skill.description,
+      ...pendingTask.length > 0 ? { pendingTask } : {},
+      path: skill.filePath,
+      baseDir: skill.baseDir,
+      hash: skill.hash,
+      source: skill.source,
+      sourceOrigin: skillSourceOrigin(skill),
+      sourceInfo: skill.sourceInfo,
+      scope: skill.scope,
+      disableModelInvocation: skill.disableModelInvocation,
+      ...skill.allowedTools ? { allowedTools: skill.allowedTools } : {},
+      ...skill.disallowedTools ? { disallowedTools: skill.disallowedTools } : {},
+      diagnostics: skill.diagnostics.map((d) => d.message),
+      metadata: skill.metadata,
+      ...skill.provenance ? { provenance: skill.provenance } : {},
+      ...drift !== null ? { drift } : {},
+      ...tree ? { tree } : {}
+    },
+    reservation,
+    ...options ? { options } : {}
+  });
+}
+function runRecallScope(deps, args, reservation, options) {
+  if (deps.workerRecall) {
+    const result2 = deps.workerRecall(args);
+    if ("error" in result2) return { kind: "error", message: `context: ${result2.error}` };
+    const truncated = truncateHead(result2.body, {
+      maxBytes: reservation.callCapBytes,
+      maxLines: Number.MAX_SAFE_INTEGER
+    });
+    return finalizeObservation({
+      tool: ToolNames.Context,
+      unit: "results",
+      output: truncated.content,
+      ...truncated.truncated ? { fullOutput: result2.body } : {},
+      shownCount: result2.shown,
+      totalCount: result2.total,
+      truncated: truncated.truncated || result2.nextOffset !== void 0,
+      details: { workerRecall: { ref: args.ref ?? null, nextOffset: result2.nextOffset ?? null } },
+      reservation,
+      ...options ? { options } : {}
+    });
+  }
+  const session = deps.session;
+  if (!session?.hasSession()) {
+    return { kind: "error", message: "context: recall scope requires a bound session; none is active here" };
+  }
+  const ref = typeof args.ref === "string" ? args.ref.trim() : "";
+  const entries = session.readEntries();
+  const leaf = session.activeLeafTurnId();
+  const view = foldWorkingSet(entries, leaf);
+  if (args.ref === void 0) {
+    const listing = recallableRefListing(entries, view, {
+      ...leaf === void 0 ? {} : { activeLeafTurnId: leaf },
+      ...typeof args.query === "string" ? { query: args.query } : {},
+      ...typeof args.limit === "number" ? { limit: args.limit } : {},
+      ...typeof args.offset === "number" ? { offset: args.offset } : {}
+    });
+    const output = [
+      ...listing.refs,
+      listing.nextOffset === void 0 ? "End of matching recallable refs." : `More matches: repeat this query with offset=${listing.nextOffset}.`,
+      'Recall an exact persisted body with context(scope="recall", ref="<turnId>").'
+    ].join("\n");
+    const truncation2 = truncateHead(output, { maxBytes: reservation.callCapBytes, maxLines: Number.MAX_SAFE_INTEGER });
+    return finalizeObservation({
+      tool: ToolNames.Context,
+      unit: "results",
+      output: truncation2.content,
+      ...truncation2.truncated ? { fullOutput: output } : {},
+      shownCount: listing.refs.length,
+      totalCount: listing.total,
+      truncated: truncation2.truncated || listing.remaining > 0,
+      details: { recallDiscovery: listing },
+      reservation,
+      ...options ? { options } : {}
+    });
+  }
+  const resolved = resolveRecall(entries, view, ref, leaf);
+  if (!resolved.ok)
+    return { kind: "error", message: `context: ${recallErrorMessage(resolved.error, entries, view, leaf)}` };
+  const { result } = resolved;
+  const fields = buildRecallFields(result, {
+    trigger: "tool",
+    ...options?.toolCallId ? { toolCallId: options.toolCallId } : {}
+  });
+  const parentTurnId = recallParentTurnId(entries, leaf);
+  let recorded;
+  try {
+    recorded = session.appendEntry({ ...fields, parentTurnId });
+  } catch (err) {
+    return {
+      kind: "error",
+      message: `context: recall of ${result.ref.entry} could not be recorded: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  session.onRecalled?.({ ref: result.ref.entry, trigger: "tool", tokensReadmitted: result.tokens, at: Date.now() });
+  const evictedState = view.evicted.get(result.ref.entry);
+  const truncation = truncateHead(result.body, {
+    maxBytes: reservation.callCapBytes,
+    maxLines: Number.MAX_SAFE_INTEGER
+  });
+  return finalizeObservation({
+    tool: ToolNames.Context,
+    unit: "results",
+    output: truncation.content,
+    ...truncation.truncated ? { fullOutput: result.body } : {},
+    shownCount: 1,
+    totalCount: 1,
+    truncated: truncation.truncated,
+    details: {
+      recall: {
+        ref: result.ref.entry,
+        state: result.state,
+        tokensReadmitted: result.tokens,
+        recallTurnId: recorded.turnId,
+        ...evictedState ? { reason: evictedState.reason, evictedAtTurnId: evictedState.evictedAtTurnId } : {},
+        ...result.offloadPath !== void 0 ? { offloadPath: result.offloadPath } : {}
+      }
+    },
+    reservation,
+    ...options ? { options } : {}
+  });
+}
+function createContextTool(deps = {}) {
+  return {
+    ...contextToolSurface,
+    async run(args, options) {
+      const scope = typeof args.scope === "string" ? args.scope : "";
+      if (scope !== "workspace" && scope !== "docs" && scope !== "skills" && scope !== "library" && scope !== "recall") {
+        return {
+          kind: "error",
+          message: `context: scope must be workspace, docs, skills, library, or recall; got '${scope}'`
+        };
+      }
+      const selfCap = scope === "docs" ? OBSERVE_SELF_CAPS.contextDocs : scope === "skills" ? OBSERVE_SELF_CAPS.contextSkills : scope === "library" ? OBSERVE_SELF_CAPS.contextLibrary : OBSERVE_SELF_CAPS.contextWorkspace;
+      const reservation = reserveObservation(selfCap, options);
+      if (reservation.exhausted) {
+        return observationBudgetExhausted({
+          tool: ToolNames.Context,
+          unit: scope === "docs" ? "sections" : scope === "skills" || scope === "library" ? "entries" : "results",
+          reservation,
+          subject: `scope=${scope}`,
+          hint: "Continue in a follow-up turn."
+        });
+      }
+      if (scope === "workspace") return runWorkspaceScope(deps, reservation, options);
+      if (scope === "docs") return runDocsScope(args, reservation, options);
+      if (scope === "recall") return runRecallScope(deps, args, reservation, options);
+      if (scope === "library") {
+        const { runLibraryScope } = await import("./library-LF7DLU6S.js");
+        return runLibraryScope(
+          {
+            getCwd: () => cwdFromDeps(deps),
+            ...deps.skillMarketplace !== void 0 ? { skillMarketplace: deps.skillMarketplace } : {},
+            ...deps.getSkillLoaderOptions ? { skillLoaderOptions: deps.getSkillLoaderOptions() } : {}
+          },
+          args,
+          reservation,
+          options
+        );
+      }
+      return runSkillsScope(deps, args, reservation, options);
+    }
+  };
+}
+export {
+  createContextTool
+};
+//# sourceMappingURL=context-EZZPT2ZV.js.map