@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/{chunk-GAYUJ7LE.js → chunk-JA5QWE4Z.js}

@@ -7,40 +7,47 @@ import {
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
   runTaskMemoryPolicy,
   taskMemoryBankDelta
-} from "./chunk-O6I4CIEU.js";
+} from "./chunk-I66EAJFY.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-4H6ULJ3H.js";
+} from "./chunk-2VG7KLYV.js";
 import {
   taskBoardCounts
-} from "./chunk-2JDWVJND.js";
+} from "./chunk-6DWBAZ5U.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,
   SKILL_SUGGESTION_PREFIX
-} from "./chunk-RAPCMZL4.js";
+} from "./chunk-FSP7CMNU.js";
 import {
   legacyToolResultDigest,
   sanitizeToolResultDigest
-} from "./chunk-ODFEOB4F.js";
+} from "./chunk-R23Z6K6I.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   registerForegroundStream
-} from "./chunk-MIX5N5AC.js";
+} from "./chunk-UEDMSP56.js";
 import {
   ceilChars
-} from "./chunk-AEYBF3TB.js";
+} from "./chunk-CWVRRIEI.js";
+import {
+  BusChannels
+} from "./chunk-HLW2MRKE.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-B5CSFE7B.js";
-import {
-  BusChannels
-} from "./chunk-RKRLDWD3.js";
+} from "./chunk-JIEGK6UF.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
+import {
+  clioConfigDir
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -424,7 +431,7 @@ function cloneRuleDefinition(definition) {
 function writeMiddlewareDiagnosticToStderr(diagnostic) {
   if (diagnostic.kind === "hook_failed") {
     process.stderr.write(
-      `[clio:middleware] registration '${diagnostic.registrationId}' failed on '${diagnostic.hook}': ${diagnostic.message}
+      `[clio-coder:middleware] registration '${diagnostic.registrationId}' failed on '${diagnostic.hook}': ${diagnostic.message}
 `
     );
     return;
@@ -433,7 +440,7 @@ function writeMiddlewareDiagnosticToStderr(diagnostic) {
   const stats = diagnostic.stats;
   const trend = stats.window > 0 ? ` (slow on ${stats.overCount}/${stats.window} recent ${diagnostic.hook} calls, p95 ${stats.p95Ms.toFixed(1)}ms)` : "";
   process.stderr.write(
-    `[clio:middleware] registration '${diagnostic.registrationId}' exceeded budget on '${diagnostic.hook}': ${diagnostic.elapsedMs.toFixed(1)}ms > ${diagnostic.budgetMs}ms${trend}
+    `[clio-coder:middleware] registration '${diagnostic.registrationId}' exceeded budget on '${diagnostic.hook}': ${diagnostic.elapsedMs.toFixed(1)}ms > ${diagnostic.budgetMs}ms${trend}
 `
   );
 }
@@ -957,112 +964,112 @@ function validateMiddlewareEffect(value, source = "$") {
   if (issues.length > 0 || effect === null) return { valid: false, issues };
   return { valid: true, effect, issues: [] };
 }
-function readMiddlewareEffect(value, path, issues) {
+function readMiddlewareEffect(value, path2, issues) {
   if (!isRecord(value)) {
-    issues.push({ path, message: "expected middleware effect object" });
+    issues.push({ path: path2, message: "expected middleware effect object" });
     return null;
   }
   const kindValue = value.kind;
   if (typeof kindValue !== "string" || !isMiddlewareEffectKind(kindValue)) {
-    issues.push({ path: `${path}.kind`, message: "expected known middleware effect kind" });
+    issues.push({ path: `${path2}.kind`, message: "expected known middleware effect kind" });
     return null;
   }
   switch (kindValue) {
     case "inject_reminder":
-      return readInjectReminder(value, path, issues);
+      return readInjectReminder(value, path2, issues);
     case "annotate_tool_result":
-      return readAnnotateToolResult(value, path, issues);
+      return readAnnotateToolResult(value, path2, issues);
     case "block_tool":
-      return readBlockTool(value, path, issues);
+      return readBlockTool(value, path2, issues);
     case "protect_path":
-      return readProtectPath(value, path, issues);
+      return readProtectPath(value, path2, issues);
     case "request_continuation":
-      return readRequestContinuation(value, path, issues);
+      return readRequestContinuation(value, path2, issues);
     case "require_tool":
-      return readRequireTool(value, path, issues);
+      return readRequireTool(value, path2, issues);
     case "lock_tools":
-      rejectUnexpectedFields(value, path, ["kind"], issues);
+      rejectUnexpectedFields(value, path2, ["kind"], issues);
       return { kind: "lock_tools" };
   }
 }
-function readRequireTool(record, path, issues) {
-  rejectUnexpectedFields(record, path, ["kind", "toolName"], issues);
-  const toolName = readRequiredString(record, `${path}.toolName`, issues);
+function readRequireTool(record, path2, issues) {
+  rejectUnexpectedFields(record, path2, ["kind", "toolName"], issues);
+  const toolName = readRequiredString(record, `${path2}.toolName`, issues);
   return toolName === null ? null : { kind: "require_tool", toolName };
 }
-function readInjectReminder(record, path, issues) {
-  rejectUnexpectedFields(record, path, ["kind", "message", "severity"], issues);
-  const message = readRequiredString(record, `${path}.message`, issues);
-  const severity = readOptionalString(record, `${path}.severity`, issues);
+function readInjectReminder(record, path2, issues) {
+  rejectUnexpectedFields(record, path2, ["kind", "message", "severity"], issues);
+  const message = readRequiredString(record, `${path2}.message`, issues);
+  const severity = readOptionalString(record, `${path2}.severity`, issues);
   if (severity !== void 0 && !isMiddlewareReminderSeverity(severity)) {
-    issues.push({ path: `${path}.severity`, message: "expected info, advisory, warn, or hard-block" });
+    issues.push({ path: `${path2}.severity`, message: "expected info, advisory, warn, or hard-block" });
   }
   if (message === null) return null;
   const effect = { kind: "inject_reminder", message };
   if (severity !== void 0 && isMiddlewareReminderSeverity(severity)) effect.severity = severity;
   return effect;
 }
-function readAnnotateToolResult(record, path, issues) {
-  rejectUnexpectedFields(record, path, ["kind", "message", "severity"], issues);
-  const message = readRequiredString(record, `${path}.message`, issues);
-  const severity = readOptionalString(record, `${path}.severity`, issues);
+function readAnnotateToolResult(record, path2, issues) {
+  rejectUnexpectedFields(record, path2, ["kind", "message", "severity"], issues);
+  const message = readRequiredString(record, `${path2}.message`, issues);
+  const severity = readOptionalString(record, `${path2}.severity`, issues);
   if (severity !== void 0 && !isMiddlewareAnnotationSeverity(severity)) {
-    issues.push({ path: `${path}.severity`, message: "expected info or warn" });
+    issues.push({ path: `${path2}.severity`, message: "expected info or warn" });
   }
   if (message === null) return null;
   const effect = { kind: "annotate_tool_result", message };
   if (severity !== void 0 && isMiddlewareAnnotationSeverity(severity)) effect.severity = severity;
   return effect;
 }
-function readBlockTool(record, path, issues) {
-  rejectUnexpectedFields(record, path, ["kind", "reason", "severity"], issues);
-  const reason = readRequiredString(record, `${path}.reason`, issues);
-  const severity = readRequiredString(record, `${path}.severity`, issues);
+function readBlockTool(record, path2, issues) {
+  rejectUnexpectedFields(record, path2, ["kind", "reason", "severity"], issues);
+  const reason = readRequiredString(record, `${path2}.reason`, issues);
+  const severity = readRequiredString(record, `${path2}.severity`, issues);
   if (severity !== null && severity !== "hard-block") {
-    issues.push({ path: `${path}.severity`, message: "expected hard-block" });
+    issues.push({ path: `${path2}.severity`, message: "expected hard-block" });
   }
   if (reason === null || severity !== "hard-block") return null;
   return { kind: "block_tool", reason, severity };
 }
-function readProtectPath(record, path, issues) {
-  rejectUnexpectedFields(record, path, ["kind", "path", "reason"], issues);
-  const protectedPath = readRequiredString(record, `${path}.path`, issues);
-  const reason = readRequiredString(record, `${path}.reason`, issues);
+function readProtectPath(record, path2, issues) {
+  rejectUnexpectedFields(record, path2, ["kind", "path", "reason"], issues);
+  const protectedPath = readRequiredString(record, `${path2}.path`, issues);
+  const reason = readRequiredString(record, `${path2}.reason`, issues);
   if (protectedPath === null || reason === null) return null;
   return { kind: "protect_path", path: protectedPath, reason };
 }
-function readRequestContinuation(record, path, issues) {
-  rejectUnexpectedFields(record, path, ["kind", "message"], issues);
-  const message = readRequiredString(record, `${path}.message`, issues);
+function readRequestContinuation(record, path2, issues) {
+  rejectUnexpectedFields(record, path2, ["kind", "message"], issues);
+  const message = readRequiredString(record, `${path2}.message`, issues);
   if (message === null) return null;
   return { kind: "request_continuation", message };
 }
-function readRequiredString(record, path, issues) {
-  const value = record[pathField(path)];
+function readRequiredString(record, path2, issues) {
+  const value = record[pathField(path2)];
   if (typeof value !== "string" || value.trim().length === 0) {
-    issues.push({ path, message: "expected non-empty string" });
+    issues.push({ path: path2, message: "expected non-empty string" });
     return null;
   }
   return value;
 }
-function readOptionalString(record, path, issues) {
-  const field = pathField(path);
+function readOptionalString(record, path2, issues) {
+  const field = pathField(path2);
   if (!Object.hasOwn(record, field)) return void 0;
   const value = record[field];
   if (typeof value !== "string" || value.trim().length === 0) {
-    issues.push({ path, message: "expected non-empty string" });
+    issues.push({ path: path2, message: "expected non-empty string" });
     return void 0;
   }
   return value;
 }
-function rejectUnexpectedFields(record, path, allowedFields, issues) {
+function rejectUnexpectedFields(record, path2, allowedFields, issues) {
   const allowed = new Set(allowedFields);
   for (const field of Object.keys(record).sort((a, b) => a.localeCompare(b))) {
-    if (!allowed.has(field)) issues.push({ path: `${path}.${field}`, message: "unexpected field" });
+    if (!allowed.has(field)) issues.push({ path: `${path2}.${field}`, message: "unexpected field" });
   }
 }
-function pathField(path) {
-  return path.slice(path.lastIndexOf(".") + 1);
+function pathField(path2) {
+  return path2.slice(path2.lastIndexOf(".") + 1);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1383,16 +1390,425 @@ function spawnSyncCommandRunner() {
   };
 }
 
+// src/domains/middleware/skills-reminder.ts
+init_esm_shims();
+var SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
+function skillsReminderMessage(installed, installable = 0) {
+  const counts = installable > 0 ? `${installed} installed, ${installable} installable from the marketplace` : `${installed} installed`;
+  return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and then continue the task in the same turn without the skill. Only the operator loads a skill, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
+}
+var NO_EFFECTS = [];
+var GREETING_WORDS = /* @__PURE__ */ new Set([
+  "hi",
+  "hello",
+  "hey",
+  "heya",
+  "hiya",
+  "howdy",
+  "yo",
+  "sup",
+  "hola",
+  "greetings",
+  "gm",
+  "gn",
+  "morning",
+  "afternoon",
+  "evening",
+  "good",
+  "day",
+  "night",
+  "there",
+  "you",
+  "clio",
+  "thanks",
+  "thank",
+  "thankyou",
+  "thx",
+  "ty",
+  "ok",
+  "okay",
+  "k",
+  "cool",
+  "nice",
+  "test",
+  "testing",
+  "ping",
+  "pong"
+]);
+function isSubstantiveUserTurn(text) {
+  const normalized = (text ?? "").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
+  if (normalized.length === 0) return false;
+  const tokens = normalized.split(" ");
+  if (tokens.length > 4) return true;
+  return tokens.some((token) => !GREETING_WORDS.has(token));
+}
+function createSkillsReminderRegistration(deps) {
+  let lastSeenSessionId;
+  let spentForActiveSession = false;
+  let observedFreshStart = false;
+  let observedAnyTurn = false;
+  return {
+    id: SKILLS_REMINDER_REGISTRATION_ID,
+    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol; keeps a turn going that stopped on the suggestion",
+    hooks: ["turn_start", "turn_end"],
+    evaluate(input) {
+      if (input.hook === "turn_end") {
+        return isSkillSuggestionWait(input) ? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }] : NO_EFFECTS;
+      }
+      const sessionId = input.sessionId ?? null;
+      if (lastSeenSessionId === void 0) {
+        lastSeenSessionId = sessionId;
+      } else if (lastSeenSessionId === null && sessionId !== null) {
+        lastSeenSessionId = sessionId;
+      } else if (sessionId !== lastSeenSessionId) {
+        lastSeenSessionId = sessionId;
+        spentForActiveSession = false;
+        observedFreshStart = false;
+        observedAnyTurn = false;
+      }
+      if (spentForActiveSession) return NO_EFFECTS;
+      const conversationMessages = metadataNumber(input, "conversationMessages");
+      if (!observedAnyTurn) {
+        observedAnyTurn = true;
+        if (conversationMessages === null || conversationMessages > 0) {
+          spentForActiveSession = true;
+          return NO_EFFECTS;
+        }
+        observedFreshStart = true;
+      }
+      if (!observedFreshStart) {
+        spentForActiveSession = true;
+        return NO_EFFECTS;
+      }
+      if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS;
+      spentForActiveSession = true;
+      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
+      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS;
+      let installed = 0;
+      let installable = 0;
+      try {
+        installed = deps.countModelVisibleSkills();
+        installable = deps.countInstallableSkills?.() ?? 0;
+      } catch {
+        return NO_EFFECTS;
+      }
+      if (installed <= 0 && installable <= 0) return NO_EFFECTS;
+      return [{ kind: "inject_reminder", severity: "info", message: skillsReminderMessage(installed, installable) }];
+    }
+  };
+}
+
+// src/domains/middleware/marketplace-offer.ts
+init_esm_shims();
+import { randomUUID } from "node:crypto";
+
+// src/domains/resources/skills/promotion.ts
+init_esm_shims();
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import path from "node:path";
+var TOKEN_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "for",
+  "with",
+  "this",
+  "that",
+  "when",
+  "what",
+  "how",
+  "into",
+  "from",
+  "use",
+  "used",
+  "using",
+  "one",
+  "not",
+  "skill",
+  "skills",
+  "clio",
+  "please",
+  "can",
+  "you",
+  "should",
+  "would",
+  "about",
+  "need",
+  "want",
+  "help",
+  "make",
+  "file",
+  "files",
+  "code"
+]);
+function normalize(text) {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
+}
+function distinctiveTokens(text) {
+  return new Set(
+    normalize(text).split(" ").filter((token) => token.length >= 4 && !TOKEN_STOPWORDS.has(token))
+  );
+}
+var TRIGGER_SCORE = 4;
+var TOKEN_FIRE_THRESHOLD = 3;
+function scorePromotionEntry(userText, entry) {
+  const haystack = ` ${normalize(userText)} `;
+  if (haystack.trim().length === 0) return null;
+  for (const trigger of entry.triggers ?? []) {
+    const phrase = normalize(trigger);
+    if (phrase.length >= 4 && haystack.includes(` ${phrase} `)) {
+      return { entry, score: TRIGGER_SCORE, matchedTrigger: trigger };
+    }
+  }
+  const requestTokens = distinctiveTokens(userText);
+  if (requestTokens.size === 0) return null;
+  const entryTokens = distinctiveTokens(`${entry.name.replace(/-/g, " ")} ${entry.description}`);
+  let overlap = 0;
+  for (const token of requestTokens) if (entryTokens.has(token)) overlap += 1;
+  return overlap >= TOKEN_FIRE_THRESHOLD ? { entry, score: overlap } : null;
+}
+function matchMarketplaceSkills(userText, entries, excludedNames) {
+  const matches = [];
+  for (const entry of entries) {
+    if (entry.kind !== "skill" || excludedNames.has(entry.name)) continue;
+    const match = scorePromotionEntry(userText, entry);
+    if (match) matches.push(match);
+  }
+  return matches.sort((a, b) => b.score - a.score || a.entry.name.localeCompare(b.entry.name));
+}
+var OWN_MARKETPLACE_URL_PREFIX = "https://github.com/iowarp/clio-coder/";
+function isOwnMarketplaceSource(entry) {
+  const source = entry.sourceUrl.trim();
+  if (/^(?:https?:\/\/|git@)/.test(source)) return source.startsWith(OWN_MARKETPLACE_URL_PREFIX);
+  return entry.origin === "catalog" && path.isAbsolute(source);
+}
+function assertPromotionInstallSource(entry) {
+  if (isOwnMarketplaceSource(entry)) return;
+  throw new Error(
+    `skill promotion: refusing to install "${entry.name}" from ${entry.sourceUrl}; promotion installs only from Clio's own marketplace (local catalog or ${OWN_MARKETPLACE_URL_PREFIX}). Install manually with clio-coder skills install if intended.`
+  );
+}
+var PROMOTION_DECLINES_FILE = "skill-promotion-declines.json";
+function declineKey(name, version) {
+  return `${name}@${version ?? ""}`;
+}
+function declinesPath(configDir) {
+  return path.join(configDir ?? clioConfigDir(), PROMOTION_DECLINES_FILE);
+}
+function readPromotionDeclines(configDir) {
+  const file = declinesPath(configDir);
+  if (!existsSync(file)) return { never: {} };
+  try {
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    const never = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed.never : void 0;
+    if (never && typeof never === "object" && !Array.isArray(never)) {
+      const entries = Object.entries(never).filter(
+        (pair) => typeof pair[1] === "string"
+      );
+      return { never: Object.fromEntries(entries) };
+    }
+  } catch {
+  }
+  return { never: {} };
+}
+function recordPromotionNeverDecline(name, version, configDir) {
+  const store = readPromotionDeclines(configDir);
+  store.never[declineKey(name, version)] = (/* @__PURE__ */ new Date()).toISOString();
+  safeResourceWrite(declinesPath(configDir), `${JSON.stringify(store, null, 2)}
+`, { encoding: "utf8" });
+}
+
+// src/domains/middleware/marketplace-offer.ts
+var MARKETPLACE_OFFER_REGISTRATION_ID = "observer.marketplace-offer";
+var NO_EFFECTS2 = [];
+function offerBindingTag(offerTag) {
+  return `[clio-install:${offerTag}]`;
+}
+function marketplaceOfferReminder(entry, offerTag) {
+  return `[Marketplace] This request may need expertise no installed skill covers. The local marketplace has "${entry.name}" (not installed): ${entry.description} First check the installed side with context(scope="skills"); if ${entry.name} is genuinely the right fit and nothing installed serves, ask the operator with ask_user (mode=single_question, header "Install skill") whether to install ${entry.name}, offering exactly these options in this order: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". Include the exact tag ${offerBindingTag(offerTag)} verbatim in that question's text so the harness can bind the answer to this offer; the harness acts only on an answer carrying this tag. Then continue the task in the same turn. The harness handles the answer; never install or load a skill yourself. If it is not actually needed, do not mention it.`;
+}
+function marketplaceAutoInstallReminder(entry, result) {
+  return `[Marketplace] Installed skill "${entry.name}" from Clio's own local marketplace (full-auto) to ${result.path}. Source ${result.sourceUrl}, sha256 ${result.installedHash}. ${entry.description} It is installed but not active \u2014 activation stays operator-gated. If it fits this task, suggest /skill ${entry.name} to the operator; never load it yourself.`;
+}
+function answersFromDetails(details) {
+  const raw = details?.answers;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (entry) => typeof entry === "object" && entry !== null && typeof entry.question === "string" && typeof entry.answer === "string"
+  );
+}
+function chosenOfferOption(answer) {
+  const labels = [
+    SKILL_INSTALL_OFFER_OPTION_PROJECT,
+    SKILL_INSTALL_OFFER_OPTION_USER,
+    SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
+    SKILL_INSTALL_OFFER_OPTION_NEVER
+  ];
+  for (const label of labels) {
+    if (answer.options?.includes(label)) return label;
+  }
+  for (const label of labels) {
+    if (answer.answer.includes(label)) return label;
+  }
+  return null;
+}
+function createMarketplaceOfferRegistration(deps) {
+  const declines = deps.declines ?? {
+    readNever: () => readPromotionDeclines().never,
+    recordNever: (name, version) => recordPromotionNeverDecline(name, version)
+  };
+  const newOfferTag = deps.newOfferTag ?? (() => randomUUID());
+  let lastSeenSessionId;
+  let offeredNames = /* @__PURE__ */ new Set();
+  let sessionDeclines = /* @__PURE__ */ new Set();
+  let installedNamesCache = null;
+  let marketplaceEntriesCache = null;
+  let pendingOffer = null;
+  const trackSession = (input) => {
+    const sessionId = input.sessionId ?? null;
+    if (lastSeenSessionId === void 0 || lastSeenSessionId === null && sessionId !== null) {
+      lastSeenSessionId = sessionId;
+      return;
+    }
+    if (sessionId !== lastSeenSessionId) {
+      lastSeenSessionId = sessionId;
+      offeredNames = /* @__PURE__ */ new Set();
+      sessionDeclines = /* @__PURE__ */ new Set();
+      pendingOffer = null;
+      installedNamesCache = null;
+      marketplaceEntriesCache = null;
+    }
+  };
+  const bestMatch = (text) => {
+    const installedWasCached = installedNamesCache !== null;
+    let never;
+    try {
+      installedNamesCache ??= new Set(deps.listInstalledSkillNames());
+      marketplaceEntriesCache ??= deps.listMarketplaceEntries();
+      never = declines.readNever();
+    } catch {
+      return null;
+    }
+    const declinedKeys = /* @__PURE__ */ new Set([...Object.keys(never), ...sessionDeclines]);
+    const findMatch = () => matchMarketplaceSkills(
+      text,
+      marketplaceEntriesCache ?? [],
+      /* @__PURE__ */ new Set([...installedNamesCache ?? [], ...offeredNames])
+    ).find((candidate) => !declinedKeys.has(declineKey(candidate.entry.name, candidate.entry.version))) ?? null;
+    let match = findMatch();
+    if (match && installedWasCached) {
+      try {
+        installedNamesCache = new Set(deps.listInstalledSkillNames());
+      } catch {
+        return null;
+      }
+      match = findMatch();
+    }
+    return match;
+  };
+  const installGated = (entry, scope) => {
+    assertPromotionInstallSource(entry);
+    const result = deps.installEntry(entry, scope);
+    installedNamesCache?.add(entry.name);
+    return result;
+  };
+  const evaluateAskUserAnswers = (input) => {
+    const offer = pendingOffer;
+    if (!offer) return NO_EFFECTS2;
+    const marker = offerBindingTag(offer.tag);
+    if (input.toolResultDetails?.cancelled === true) {
+      return NO_EFFECTS2;
+    }
+    for (const answer of answersFromDetails(input.toolResultDetails)) {
+      if (!answer.question.includes(marker)) continue;
+      const option = chosenOfferOption(answer);
+      if (option === null) continue;
+      pendingOffer = null;
+      const offerKey = declineKey(offer.entry.name, offer.entry.version);
+      if (option === SKILL_INSTALL_OFFER_OPTION_NOT_NOW) {
+        sessionDeclines.add(offerKey);
+        return NO_EFFECTS2;
+      }
+      if (option === SKILL_INSTALL_OFFER_OPTION_NEVER) {
+        sessionDeclines.add(offerKey);
+        try {
+          declines.recordNever(offer.entry.name, offer.entry.version);
+        } catch {
+        }
+        return NO_EFFECTS2;
+      }
+      const scope = option === SKILL_INSTALL_OFFER_OPTION_USER ? "user" : "project";
+      try {
+        const result = installGated(offer.entry, scope);
+        return [
+          {
+            kind: "annotate_tool_result",
+            severity: "info",
+            message: `[Marketplace] Installed skill "${offer.entry.name}" (${scope} scope) to ${result.path}. It is installed but not active; the operator activates it with /skill ${offer.entry.name}.`
+          }
+        ];
+      } catch (error) {
+        sessionDeclines.add(offerKey);
+        return [
+          {
+            kind: "annotate_tool_result",
+            severity: "warn",
+            message: `[Marketplace] Install of "${offer.entry.name}" failed: ${error instanceof Error ? error.message : String(error)}. Continue the task without it.`
+          }
+        ];
+      }
+    }
+    return NO_EFFECTS2;
+  };
+  return {
+    id: MARKETPLACE_OFFER_REGISTRATION_ID,
+    description: "offers an uninstalled marketplace skill via ask_user when the request matches it; consented installs run gated to Clio's own marketplace, declines are remembered",
+    hooks: ["turn_start", "after_tool"],
+    evaluate(input) {
+      trackSession(input);
+      if (input.hook === "after_tool") {
+        return input.toolName === ToolNames.AskUser ? evaluateAskUserAnswers(input) : NO_EFFECTS2;
+      }
+      if (input.hook !== "turn_start") return NO_EFFECTS2;
+      if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS2;
+      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
+      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS2;
+      const match = bestMatch(input.text ?? "");
+      if (!match) return NO_EFFECTS2;
+      offeredNames.add(match.entry.name);
+      if (deps.getAutonomy() === "full-auto") {
+        try {
+          const result = installGated(match.entry, "project");
+          return [
+            {
+              kind: "inject_reminder",
+              severity: "info",
+              message: marketplaceAutoInstallReminder(match.entry, result)
+            }
+          ];
+        } catch {
+        }
+      }
+      const tag = newOfferTag();
+      pendingOffer = { entry: match.entry, tag };
+      return [{ kind: "inject_reminder", severity: "info", message: marketplaceOfferReminder(match.entry, tag) }];
+    }
+  };
+}
+
 // src/domains/middleware/memory-intervention.ts
 init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
 var MEMORY_INTERVENTION_REGISTRATION_ID = "observer.memory-intervention";
 var MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS = 8;
-var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 400;
+var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 2e3;
 var MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS = 10;
+var MEMORY_INTERVENTION_TIMEOUT_BACKOFF_THRESHOLD = 2;
 var MEMORY_INTERVENTION_ACTIVITY_LIMIT = 20;
 var CALL_DESCRIPTION_MAX_CHARS = 180;
-var NO_EFFECTS = [];
+var NO_EFFECTS3 = [];
 function createMemoryInterventionRegistration(deps) {
   const pending = /* @__PURE__ */ new Map();
   const trajectory = [];
@@ -1416,21 +1832,22 @@ function createMemoryInterventionRegistration(deps) {
   let outstandingStep = Promise.resolve();
   let rulesInjectedSincePromptedStep = false;
   let annotatedSinceTurnEnd = false;
+  let consecutiveLlmTimeouts = 0;
   return {
     id: MEMORY_INTERVENTION_REGISTRATION_ID,
     description: "maintain bounded task execution memory and selectively remind after repeated failures or compaction",
     hooks: ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"],
     evaluate(input) {
-      if (!settings().enabled) return NO_EFFECTS;
+      if (!settings().enabled) return NO_EFFECTS3;
       try {
         switch (input.hook) {
           case "before_tool":
             observeBeforeTool(input);
-            return NO_EFFECTS;
+            return NO_EFFECTS3;
           case "after_tool":
             return observeAfterTool(input);
           case "turn_end": {
-            if (toolStep <= lastTurnEndStep) return NO_EFFECTS;
+            if (toolStep <= lastTurnEndStep) return NO_EFFECTS3;
             const alreadyReported = annotatedSinceTurnEnd;
             annotatedSinceTurnEnd = false;
             const started = process.hrtime.bigint();
@@ -1449,9 +1866,9 @@ function createMemoryInterventionRegistration(deps) {
             return effects;
           }
           case "on_compaction":
-            if (input.metadata?.stage === "working_set_recall") return NO_EFFECTS;
+            if (input.metadata?.stage === "working_set_recall") return NO_EFFECTS3;
             reactivateAfterCompaction = true;
-            return NO_EFFECTS;
+            return NO_EFFECTS3;
           case "turn_start": {
             if (input.text?.trim()) currentTask = shortText(input.text, 2e3);
             annotatedThisTurn.clear();
@@ -1474,7 +1891,7 @@ function createMemoryInterventionRegistration(deps) {
           }
         }
       } catch {
-        return NO_EFFECTS;
+        return NO_EFFECTS3;
       }
     },
     /**
@@ -1488,13 +1905,13 @@ function createMemoryInterventionRegistration(deps) {
      * would have been buffered anyway.
      */
     async evaluateAsync(input, context) {
-      if (!settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS;
+      if (!settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS3;
       const boundary = input.turnId ?? input.metadata?.userTurnId?.toString() ?? `tool-step:${toolStep}`;
-      if (boundary === lastPromptedBoundary) return NO_EFFECTS;
+      if (boundary === lastPromptedBoundary) return NO_EFFECTS3;
       if (deps.deliversDeferredReminders === false) {
         emitTelemetry([...pendingTriggers], "rules", "silent", "no_consumer", 0, 0, 0, process.hrtime.bigint());
         pendingTriggers.clear();
-        return NO_EFFECTS;
+        return NO_EFFECTS3;
       }
       if (promptedStepInFlight) {
         emitTelemetry(
@@ -1507,7 +1924,7 @@ function createMemoryInterventionRegistration(deps) {
           0,
           process.hrtime.bigint()
         );
-        return NO_EFFECTS;
+        return NO_EFFECTS3;
       }
       lastPromptedBoundary = boundary;
       const triggers = [...pendingTriggers];
@@ -1532,7 +1949,7 @@ function createMemoryInterventionRegistration(deps) {
       }).finally(() => {
         promptedStepInFlight = false;
       });
-      return NO_EFFECTS;
+      return NO_EFFECTS3;
     },
     runPromptedStep,
     signalLoop() {
@@ -1566,7 +1983,7 @@ function createMemoryInterventionRegistration(deps) {
       inputTokens: 0,
       outputTokens: 0,
       usage: null,
-      effects: NO_EFFECTS
+      effects: NO_EFFECTS3
     });
     const live = settings();
     if (!live.enabled) {
@@ -1581,27 +1998,32 @@ function createMemoryInterventionRegistration(deps) {
     let promptedResult;
     let telemetryDecision = null;
     try {
-      const client = deps.getModelClient?.() ?? null;
-      if (client === null) {
-        promptedResult = silent("no_client");
-      } else if (deps.backgroundEndpointBusy?.() === true) {
-        tier = "llm";
-        promptedStepTier = tier;
-        promptedResult = silent("endpoint_busy");
-        telemetryDecision = "dropped";
+      if (consecutiveLlmTimeouts >= MEMORY_INTERVENTION_TIMEOUT_BACKOFF_THRESHOLD) {
+        promptedResult = silent("llm_timeout_backoff");
       } else {
-        tier = "llm";
-        promptedStepTier = tier;
-        promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
-          task: input.task?.trim() || currentTask,
-          trajectory: [...trajectory],
-          deterministicTrigger: input.deterministicTrigger,
-          maxTokens: live.maxTokens,
-          ...input.suppressIntervention === void 0 ? {} : { suppressIntervention: input.suppressIntervention },
-          previousReminder: lastInjectedMessage,
-          timeoutMs: live.timeoutMs,
-          ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
-        });
+        const client = deps.getModelClient?.() ?? null;
+        if (client === null) {
+          promptedResult = silent("no_client");
+        } else if (deps.backgroundEndpointBusy?.() === true) {
+          tier = "llm";
+          promptedStepTier = tier;
+          promptedResult = silent("endpoint_busy");
+          telemetryDecision = "dropped";
+        } else {
+          tier = "llm";
+          promptedStepTier = tier;
+          promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
+            task: input.task?.trim() || currentTask,
+            trajectory: [...trajectory],
+            deterministicTrigger: input.deterministicTrigger,
+            maxTokens: live.maxTokens,
+            modelMaxTokens: positiveInteger(deps.getModelMaxTokens?.(live.maxTokens), live.maxTokens),
+            ...input.suppressIntervention === void 0 ? {} : { suppressIntervention: input.suppressIntervention },
+            previousReminder: lastInjectedMessage,
+            timeoutMs: live.timeoutMs,
+            ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
+          });
+        }
       }
     } catch (error) {
       promptedResult = silent("client_error");
@@ -1617,6 +2039,8 @@ function createMemoryInterventionRegistration(deps) {
         error: error instanceof Error ? error.message : "resolving the background model client failed"
       });
     }
+    if (tier === "llm" && promptedResult.decision === "timeout") consecutiveLlmTimeouts += 1;
+    else if (tier === "llm" && telemetryDecision !== "dropped") consecutiveLlmTimeouts = 0;
     lastDecision = promptedResult.decision;
     if (promptedResult.usage !== null) {
       try {
@@ -1638,7 +2062,7 @@ function createMemoryInterventionRegistration(deps) {
     );
     return {
       ...promptedResult,
-      effects: promptedResult.reminder === null ? NO_EFFECTS : [{ kind: "inject_reminder", message: promptedResult.reminder, severity: "advisory" }]
+      effects: promptedResult.reminder === null ? NO_EFFECTS3 : [{ kind: "inject_reminder", message: promptedResult.reminder, severity: "advisory" }]
     };
   }
   function emitTelemetry(triggerReasons, tier, decision, reason, citedEntries2, inputTokens, outputTokens, started, operations = { bankOperations: 0, droppedOperations: 0 }) {
@@ -1699,7 +2123,7 @@ function createMemoryInterventionRegistration(deps) {
   }
   function observeAfterTool(input) {
     const fallback = prepareToolStep(input);
-    if (fallback === null) return NO_EFFECTS;
+    if (fallback === null) return NO_EFFECTS3;
     const key = pendingKey(input, fallback.operationFingerprint);
     const prepared = pending.get(key) ?? fallback;
     pending.delete(key);
@@ -1724,22 +2148,22 @@ function createMemoryInterventionRegistration(deps) {
     };
     trajectory.push(step);
     if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
-    if (outcome !== "error") return NO_EFFECTS;
+    if (outcome !== "error") return NO_EFFECTS3;
     rememberFailure(step);
     return annotateRepeatedFailure(step);
   }
   function annotateRepeatedFailure(step) {
-    if (annotatedThisTurn.has(step.operationFingerprint)) return NO_EFFECTS;
+    if (annotatedThisTurn.has(step.operationFingerprint)) return NO_EFFECTS3;
     const occurrences = trajectory.filter(
       (candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint
     ).length;
     const failure = failures.get(step.operationFingerprint);
-    if (occurrences < 2 || failure === void 0) return NO_EFFECTS;
+    if (occurrences < 2 || failure === void 0) return NO_EFFECTS3;
     const message = boundedReminder(
       `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}. Change the approach rather than repeating it.`,
       settings().maxTokens
     );
-    if (message.length === 0) return NO_EFFECTS;
+    if (message.length === 0) return NO_EFFECTS3;
     annotatedThisTurn.add(step.operationFingerprint);
     lastInjectedOperationFingerprint = step.operationFingerprint;
     lastDecision = "injected";
@@ -1793,7 +2217,7 @@ function createMemoryInterventionRegistration(deps) {
           `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}.`,
           settings().maxTokens
         );
-        if (message.length === 0) return NO_EFFECTS;
+        if (message.length === 0) return NO_EFFECTS3;
         lastInjectedOperationFingerprint = step.operationFingerprint;
         lastInjectedMessage = message;
         lastDecision = "injected";
@@ -1802,13 +2226,13 @@ function createMemoryInterventionRegistration(deps) {
         return [{ kind: "inject_reminder", message, severity: "advisory" }];
       }
       lastDecision = "silent";
-      return NO_EFFECTS;
+      return NO_EFFECTS3;
     } finally {
       lastTurnEndStep = toolStep;
     }
   }
   function reactivateKnowledge() {
-    if (!reactivateAfterCompaction) return NO_EFFECTS;
+    if (!reactivateAfterCompaction) return NO_EFFECTS3;
     reactivateAfterCompaction = false;
     const prefix = "Memory: execution state restored after compaction:\n";
     const maxTokens = settings().maxTokens;
@@ -1816,12 +2240,12 @@ function createMemoryInterventionRegistration(deps) {
     const rendered = deps.bank.renderRestoredState(Math.max(0, maxTokens - prefixTokens));
     if (rendered.length === 0) {
       lastDecision = "silent";
-      return NO_EFFECTS;
+      return NO_EFFECTS3;
     }
     const message = boundedReminder(`${prefix}${rendered}`, maxTokens);
     if (message.length === 0) {
       lastDecision = "silent";
-      return NO_EFFECTS;
+      return NO_EFFECTS3;
     }
     const citedIds = [...message.matchAll(/\[([^\]]+)\]/gu)].map((match) => match[1]).filter((id) => id !== void 0);
     deps.bank.recordInjection(citedIds);
@@ -1920,114 +2344,6 @@ function announceMemoryStepEndpoint(deps, complete) {
   };
 }
 
-// src/domains/middleware/skills-reminder.ts
-init_esm_shims();
-var SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
-function skillsReminderMessage(installed, installable = 0) {
-  const counts = installable > 0 ? `${installed} installed, ${installable} installable from the marketplace` : `${installed} installed`;
-  return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and then continue the task in the same turn without the skill. Only the operator loads a skill, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
-}
-var NO_EFFECTS2 = [];
-var GREETING_WORDS = /* @__PURE__ */ new Set([
-  "hi",
-  "hello",
-  "hey",
-  "heya",
-  "hiya",
-  "howdy",
-  "yo",
-  "sup",
-  "hola",
-  "greetings",
-  "gm",
-  "gn",
-  "morning",
-  "afternoon",
-  "evening",
-  "good",
-  "day",
-  "night",
-  "there",
-  "you",
-  "clio",
-  "thanks",
-  "thank",
-  "thankyou",
-  "thx",
-  "ty",
-  "ok",
-  "okay",
-  "k",
-  "cool",
-  "nice",
-  "test",
-  "testing",
-  "ping",
-  "pong"
-]);
-function isSubstantiveUserTurn(text) {
-  const normalized = (text ?? "").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
-  if (normalized.length === 0) return false;
-  const tokens = normalized.split(" ");
-  if (tokens.length > 4) return true;
-  return tokens.some((token) => !GREETING_WORDS.has(token));
-}
-function createSkillsReminderRegistration(deps) {
-  let lastSeenSessionId;
-  let spentForActiveSession = false;
-  let observedFreshStart = false;
-  let observedAnyTurn = false;
-  return {
-    id: SKILLS_REMINDER_REGISTRATION_ID,
-    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol; keeps a turn going that stopped on the suggestion",
-    hooks: ["turn_start", "turn_end"],
-    evaluate(input) {
-      if (input.hook === "turn_end") {
-        return isSkillSuggestionWait(input) ? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }] : NO_EFFECTS2;
-      }
-      const sessionId = input.sessionId ?? null;
-      if (lastSeenSessionId === void 0) {
-        lastSeenSessionId = sessionId;
-      } else if (lastSeenSessionId === null && sessionId !== null) {
-        lastSeenSessionId = sessionId;
-      } else if (sessionId !== lastSeenSessionId) {
-        lastSeenSessionId = sessionId;
-        spentForActiveSession = false;
-        observedFreshStart = false;
-        observedAnyTurn = false;
-      }
-      if (spentForActiveSession) return NO_EFFECTS2;
-      const conversationMessages = metadataNumber(input, "conversationMessages");
-      if (!observedAnyTurn) {
-        observedAnyTurn = true;
-        if (conversationMessages === null || conversationMessages > 0) {
-          spentForActiveSession = true;
-          return NO_EFFECTS2;
-        }
-        observedFreshStart = true;
-      }
-      if (!observedFreshStart) {
-        spentForActiveSession = true;
-        return NO_EFFECTS2;
-      }
-      if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS2;
-      spentForActiveSession = true;
-      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
-      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS2;
-      let installed = 0;
-      let installable = 0;
-      try {
-        installed = deps.countModelVisibleSkills();
-        installable = deps.countInstallableSkills?.() ?? 0;
-      } catch {
-        return NO_EFFECTS2;
-      }
-      if (installed <= 0 && installable <= 0) return NO_EFFECTS2;
-      return [{ kind: "inject_reminder", severity: "info", message: skillsReminderMessage(installed, installable) }];
-    }
-  };
-}
-
 // src/domains/middleware/task-board-reminder.ts
 init_esm_shims();
 var TASK_BOARD_REMINDER_REGISTRATION_ID = "observer.task-board-reminder";
@@ -2054,7 +2370,7 @@ function countEnumeratedSteps(text) {
   const bulletLines = value.split(/\r?\n/).filter((line) => /^\s*[-*]\s+\S/.test(line)).length;
   return bulletLines >= 3 ? bulletLines : 0;
 }
-var NO_EFFECTS3 = [];
+var NO_EFFECTS4 = [];
 function createTaskBoardReminderRegistration() {
   let lastSeenSessionId;
   let spentForActiveSession = false;
@@ -2070,12 +2386,12 @@ function createTaskBoardReminderRegistration() {
         lastSeenSessionId = sessionId;
         spentForActiveSession = false;
       }
-      if (spentForActiveSession) return NO_EFFECTS3;
+      if (spentForActiveSession) return NO_EFFECTS4;
       const steps = countEnumeratedSteps(input.text);
-      if (steps < 3) return NO_EFFECTS3;
+      if (steps < 3) return NO_EFFECTS4;
       spentForActiveSession = true;
       const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
-      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS3;
+      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS4;
       return [{ kind: "inject_reminder", severity: "info", message: taskBoardReminderMessage(steps) }];
     }
   };
@@ -2157,7 +2473,7 @@ var WATCHDOG_DIFF_MAX_BYTES = 12 * 1024;
 var WATCHDOG_PATHS_MAX = 40;
 var WATCHDOG_TRUNCATION_MARKER = "\n[diff truncated]";
 var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([ToolNames.Write, ToolNames.Edit, ToolNames.Artifact]);
-var NO_EFFECTS4 = [];
+var NO_EFFECTS5 = [];
 function stringValue2(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
@@ -2165,20 +2481,20 @@ function firstPath(details) {
   const paths = details?.paths;
   if (!Array.isArray(paths)) return null;
   for (const entry of paths) {
-    const path = stringValue2(entry);
-    if (path !== null) return path;
+    const path2 = stringValue2(entry);
+    if (path2 !== null) return path2;
   }
   return null;
 }
 function coalesceTurnDiff(byPath, maxBytes = WATCHDOG_DIFF_MAX_BYTES) {
   const blocks = [];
   let index = 0;
-  for (const [path, diff] of byPath) {
+  for (const [path2, diff] of byPath) {
     if (index >= WATCHDOG_PATHS_MAX) {
       blocks.push(`[${byPath.size - WATCHDOG_PATHS_MAX} more changed path(s) omitted]`);
       break;
     }
-    blocks.push(`--- ${path}
+    blocks.push(`--- ${path2}
 ${diff}`);
     index += 1;
   }
@@ -2270,19 +2586,19 @@ function createWatchdogRegistration(deps) {
       const settings = active();
       if (settings === null) {
         if (input.hook === "turn_end") resetTurn();
-        return NO_EFFECTS4;
+        return NO_EFFECTS5;
       }
       if (input.hook === "after_tool") {
         toolCalls += 1;
         recordMutation(input);
         const cadence = settings.cadenceToolCalls;
         if (cadence !== void 0 && cadence >= 1 && toolCalls % cadence === 0) fire("cadence");
-        return NO_EFFECTS4;
+        return NO_EFFECTS5;
       }
-      if (input.hook !== "turn_end") return NO_EFFECTS4;
+      if (input.hook !== "turn_end") return NO_EFFECTS5;
       fire("turn_end");
       resetTurn();
-      return NO_EFFECTS4;
+      return NO_EFFECTS5;
     },
     droppedTriggers: () => dropped,
     runInFlight: () => inFlight,
@@ -2447,9 +2763,10 @@ export {
   loadUserHooks,
   readHookSources,
   installUserHooks,
+  createSkillsReminderRegistration,
+  createMarketplaceOfferRegistration,
   createMemoryInterventionRegistration,
   announceMemoryStepEndpoint,
-  createSkillsReminderRegistration,
   createTaskBoardReminderRegistration,
   createTaskNudgeRegistration,
   createMiddlewareToolChoiceControl,
@@ -2458,4 +2775,4 @@ export {
   createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-GAYUJ7LE.js.map
+//# sourceMappingURL=chunk-JA5QWE4Z.js.map