@iowarp/clio-coder 0.4.1 → 0.4.2

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

@@ -1,7 +1,4 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  hashToolCall
-} from "./chunk-UOV2BYIW.js";
 import {
   TASK_MEMORY_DEFAULT_PROCEDURAL_CAP,
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
@@ -10,10 +7,13 @@ import {
 } from "./chunk-I66EAJFY.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-2VG7KLYV.js";
+} from "./chunk-IKSLQ4XV.js";
 import {
   taskBoardCounts
-} from "./chunk-6DWBAZ5U.js";
+} from "./chunk-Q4XWMHX6.js";
+import {
+  hashToolCall
+} from "./chunk-IDNA72AH.js";
 import {
   SKILL_INSTALL_OFFER_OPTION_NEVER,
   SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
@@ -25,19 +25,19 @@ import {
 import {
   legacyToolResultDigest,
   sanitizeToolResultDigest
-} from "./chunk-R23Z6K6I.js";
+} from "./chunk-B7HM5Z7T.js";
 import {
   ToolNames
 } from "./chunk-K6BSR66V.js";
 import {
   registerForegroundStream
-} from "./chunk-UEDMSP56.js";
+} from "./chunk-BYMNWQ7O.js";
 import {
   ceilChars
 } from "./chunk-CWVRRIEI.js";
 import {
   BusChannels
-} from "./chunk-HLW2MRKE.js";
+} from "./chunk-F4EKGO4N.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
@@ -436,6 +436,11 @@ function writeMiddlewareDiagnosticToStderr(diagnostic) {
     );
     return;
   }
+  if (diagnostic.kind === "registration_conflict") {
+    process.stderr.write(`[clio-coder:middleware] ${formatRegistrationConflict(diagnostic)}
+`);
+    return;
+  }
   if (!diagnostic.steadyStateWarn && process.env.CLIO_CODER_HOOK_BUDGET_DEBUG !== "1") return;
   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)` : "";
@@ -444,6 +449,9 @@ function writeMiddlewareDiagnosticToStderr(diagnostic) {
 `
   );
 }
+function formatRegistrationConflict(diagnostic) {
+  return diagnostic.action === "dropped" ? `${diagnostic.owner} registration '${diagnostic.registrationId}' (generation ${diagnostic.generation}) dropped: id is held by a ${diagnostic.conflictsWith} registration` : `${diagnostic.owner} registration '${diagnostic.registrationId}' (generation ${diagnostic.generation}) evicted by a ${diagnostic.conflictsWith} registration with the same id`;
+}
 function registrationFromRuleDefinition(definition) {
   const registration = {
     id: definition.rule.id,
@@ -906,6 +914,7 @@ function createDetachedDispatchNudgeRegistration(options) {
 
 // src/domains/middleware/hook-receipts.ts
 init_esm_shims();
+import { readFileSync } from "node:fs";
 var HOOK_RECEIPT_LOG_CAPACITY = 200;
 var PERSIST_THROTTLE_MS = 2e3;
 function createHookReceiptLog(options = {}) {
@@ -943,1806 +952,2023 @@ function createHookReceiptLog(options = {}) {
     }
   };
 }
+function readPersistedHookReceipts(persistPath) {
+  let raw;
+  try {
+    raw = readFileSync(persistPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 1 || !Array.isArray(parsed.receipts)) {
+    throw new Error(`${persistPath}: unrecognized hook receipt log shape`);
+  }
+  return parsed.receipts;
+}
 
-// src/domains/middleware/hooks-io.ts
+// src/domains/middleware/skills-reminder.ts
 init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+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/hooks.ts
+// src/domains/middleware/marketplace-offer.ts
 init_esm_shims();
-import { createHash } from "node:crypto";
-import { isAbsolute, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
 
-// src/domains/middleware/validate.ts
+// src/domains/resources/skills/promotion.ts
 init_esm_shims();
-function validateMiddlewareEffect(value, source = "$") {
-  const issues = [];
-  const effect = readMiddlewareEffect(value, source, issues);
-  if (issues.length > 0 || effect === null) return { valid: false, issues };
-  return { valid: true, effect, issues: [] };
-}
-function readMiddlewareEffect(value, path2, issues) {
-  if (!isRecord(value)) {
-    issues.push({ path: path2, message: "expected middleware effect object" });
-    return null;
-  }
-  const kindValue = value.kind;
-  if (typeof kindValue !== "string" || !isMiddlewareEffectKind(kindValue)) {
-    issues.push({ path: `${path2}.kind`, message: "expected known middleware effect kind" });
-    return null;
-  }
-  switch (kindValue) {
-    case "inject_reminder":
-      return readInjectReminder(value, path2, issues);
-    case "annotate_tool_result":
-      return readAnnotateToolResult(value, path2, issues);
-    case "block_tool":
-      return readBlockTool(value, path2, issues);
-    case "protect_path":
-      return readProtectPath(value, path2, issues);
-    case "request_continuation":
-      return readRequestContinuation(value, path2, issues);
-    case "require_tool":
-      return readRequireTool(value, path2, issues);
-    case "lock_tools":
-      rejectUnexpectedFields(value, path2, ["kind"], issues);
-      return { kind: "lock_tools" };
-  }
+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 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 distinctiveTokens(text) {
+  return new Set(
+    normalize(text).split(" ").filter((token) => token.length >= 4 && !TOKEN_STOPWORDS.has(token))
+  );
 }
-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: `${path2}.severity`, message: "expected info, advisory, warn, or hard-block" });
+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 };
+    }
   }
-  if (message === null) return null;
-  const effect = { kind: "inject_reminder", message };
-  if (severity !== void 0 && isMiddlewareReminderSeverity(severity)) effect.severity = severity;
-  return effect;
+  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 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: `${path2}.severity`, message: "expected info or warn" });
+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);
   }
-  if (message === null) return null;
-  const effect = { kind: "annotate_tool_result", message };
-  if (severity !== void 0 && isMiddlewareAnnotationSeverity(severity)) effect.severity = severity;
-  return effect;
+  return matches.sort((a, b) => b.score - a.score || a.entry.name.localeCompare(b.entry.name));
 }
-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: `${path2}.severity`, message: "expected hard-block" });
-  }
-  if (reason === null || severity !== "hard-block") return null;
-  return { kind: "block_tool", reason, severity };
+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 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 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.`
+  );
 }
-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 };
+var PROMOTION_DECLINES_FILE = "skill-promotion-declines.json";
+function declineKey(name, version) {
+  return `${name}@${version ?? ""}`;
 }
-function readRequiredString(record, path2, issues) {
-  const value = record[pathField(path2)];
-  if (typeof value !== "string" || value.trim().length === 0) {
-    issues.push({ path: path2, message: "expected non-empty string" });
-    return null;
-  }
-  return value;
+function declinesPath(configDir) {
+  return path.join(configDir ?? clioConfigDir(), PROMOTION_DECLINES_FILE);
 }
-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: path2, message: "expected non-empty string" });
-    return void 0;
+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 value;
+  return { never: {} };
 }
-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: `${path2}.${field}`, message: "unexpected field" });
-  }
+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" });
 }
-function pathField(path2) {
-  return path2.slice(path2.lastIndexOf(".") + 1);
+
+// 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 isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+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.`;
 }
-
-// src/domains/middleware/hooks.ts
-var USER_HOOK_ORIGIN_ORDER = ["extension", "user", "project", "project.local"];
-var USER_HOOK_COMMAND_TIMEOUT_DEFAULT_MS = 2e3;
-var USER_HOOK_COMMAND_TIMEOUT_MIN_MS = 100;
-var USER_HOOK_COMMAND_TIMEOUT_MAX_MS = 5e3;
-var USER_HOOK_COMMAND_OUTPUT_MAX_CHARS = 4e3;
-var USER_HOOK_PROMPT_MAX_CHARS = 2e3;
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+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 stableHash(value) {
-  return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 16);
+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 canonicalJson(value) {
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  if (isRecord2(value)) {
-    const keys = Object.keys(value).sort();
-    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+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;
   }
-  return JSON.stringify(value) ?? "null";
-}
-function readStringArray(value) {
-  if (!Array.isArray(value)) return null;
-  const out = [];
-  for (const item of value) {
-    if (typeof item !== "string" || item.length === 0) return null;
-    out.push(item);
+  for (const label of labels) {
+    if (answer.answer.includes(label)) return label;
   }
-  return out;
+  return null;
 }
-function normalizeCommandSpec(raw, options, issues) {
-  const argv = readStringArray(raw.argv);
-  if (!argv || argv.length === 0) {
-    issues.push("command.argv must be a non-empty array of non-empty strings");
-    return null;
-  }
-  const spec = {
-    kind: "command",
-    argv,
-    cwd: resolve(options.workspaceRoot),
-    timeoutMs: USER_HOOK_COMMAND_TIMEOUT_DEFAULT_MS,
-    as: "annotate"
+function createMarketplaceOfferRegistration(deps) {
+  const declines = deps.declines ?? {
+    readNever: () => readPromotionDeclines().never,
+    recordNever: (name, version) => recordPromotionNeverDecline(name, version)
   };
-  if (raw.cwd !== void 0) {
-    if (typeof raw.cwd !== "string" || raw.cwd.length === 0) {
-      issues.push("command.cwd must be a non-empty string");
-      return null;
+  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;
     }
-    const resolved = isAbsolute(raw.cwd) ? resolve(raw.cwd) : resolve(options.workspaceRoot, raw.cwd);
-    if (!isWithin(resolved, options.workspaceRoot)) {
-      issues.push("command.cwd must resolve under the workspace root");
-      return null;
+    if (sessionId !== lastSeenSessionId) {
+      lastSeenSessionId = sessionId;
+      offeredNames = /* @__PURE__ */ new Set();
+      sessionDeclines = /* @__PURE__ */ new Set();
+      pendingOffer = null;
+      installedNamesCache = null;
+      marketplaceEntriesCache = null;
     }
-    spec.cwd = resolved;
-  }
-  if (raw.timeoutMs !== void 0) {
-    if (typeof raw.timeoutMs !== "number" || !Number.isFinite(raw.timeoutMs)) {
-      issues.push("command.timeoutMs must be a number");
+  };
+  const bestMatch = (text) => {
+    const installedWasCached = installedNamesCache !== null;
+    let never;
+    try {
+      installedNamesCache ??= new Set(deps.listInstalledSkillNames());
+      marketplaceEntriesCache ??= deps.listMarketplaceEntries();
+      never = declines.readNever();
+    } catch {
       return null;
     }
-    spec.timeoutMs = Math.min(
-      USER_HOOK_COMMAND_TIMEOUT_MAX_MS,
-      Math.max(USER_HOOK_COMMAND_TIMEOUT_MIN_MS, Math.floor(raw.timeoutMs))
-    );
-  }
-  if (raw.as !== void 0) {
-    if (raw.as !== "annotate" && raw.as !== "reminder") {
-      issues.push('command.as must be "annotate" or "reminder"');
-      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();
     }
-    spec.as = raw.as;
-  }
-  return spec;
-}
-function normalizePromptSpec(raw, issues) {
-  if (typeof raw.message !== "string" || raw.message.trim().length === 0) {
-    issues.push("prompt.message must be a non-empty string");
-    return null;
-  }
-  let severity = "info";
-  if (raw.severity !== void 0) {
-    if (typeof raw.severity !== "string" || !isMiddlewareReminderSeverity(raw.severity)) {
-      issues.push("prompt.severity must be info, advisory, warn, or hard-block");
-      return null;
+    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;
     }
-    severity = raw.severity;
-  }
-  return { kind: "prompt", message: raw.message.slice(0, USER_HOOK_PROMPT_MAX_CHARS), severity };
-}
-function normalizeEffectSpec(raw, issues) {
-  const result = validateMiddlewareEffect(raw.effect ?? raw, "effect");
-  if (!result.valid) {
-    for (const issue of result.issues) issues.push(`effect: ${issue.message}`);
-    return null;
-  }
-  return { kind: "effect", effect: result.effect };
-}
-function isWithin(child, parent) {
-  const rel = resolve(child);
-  const base = resolve(parent);
-  return rel === base || rel.startsWith(`${base}/`);
-}
-function normalizeUserHook(raw, source, options) {
-  const issues = [];
-  if (!isRecord2(raw)) {
-    return { issues: ["hook declaration must be an object"] };
-  }
-  if (raw.on === void 0 || typeof raw.on !== "string" || !isMiddlewareHook(raw.on)) {
-    issues.push("on must be one of before_tool, after_tool, turn_start, turn_end, on_compaction");
-  }
-  let tools;
-  if (raw.tools !== void 0) {
-    const parsed = readStringArray(raw.tools);
-    if (!parsed) issues.push("tools must be an array of non-empty tool names");
-    else tools = parsed;
-  }
-  let enabled = true;
-  if (raw.enabled !== void 0) {
-    if (typeof raw.enabled !== "boolean") issues.push("enabled must be a boolean");
-    else enabled = raw.enabled;
-  }
-  let spec = null;
-  if (raw.kind === "command") spec = normalizeCommandSpec(raw, options, issues);
-  else if (raw.kind === "prompt") spec = normalizePromptSpec(raw, issues);
-  else if (raw.kind === "effect") spec = normalizeEffectSpec(raw, issues);
-  else issues.push('kind must be "command", "prompt", or "effect"');
-  if (issues.length > 0 || spec === null || raw.on === void 0 || typeof raw.on !== "string") {
-    return { issues };
-  }
-  const on = raw.on;
-  const hash = stableHash({ on, tools: tools ?? null, spec });
-  const id = typeof raw.id === "string" && raw.id.length > 0 ? raw.id : `${source.sourceId ?? source.origin}.${spec.kind}.${hash}`;
-  const hook = { id, source, hash, on, enabled, spec };
-  if (tools !== void 0) hook.tools = tools;
-  return { hook, issues };
-}
-function declarationsArray(declarations) {
-  if (Array.isArray(declarations)) return declarations;
-  if (isRecord2(declarations) && Array.isArray(declarations.hooks)) return declarations.hooks;
-  return [];
+    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) }];
+    }
+  };
 }
-function loadUserHooks(batches, options) {
-  const ordered = [...batches].sort(
-    (a, b) => USER_HOOK_ORIGIN_ORDER.indexOf(a.source.origin) - USER_HOOK_ORIGIN_ORDER.indexOf(b.source.origin)
-  );
-  const byId = /* @__PURE__ */ new Map();
-  const overridden = [];
-  const issues = [];
-  for (const batch of ordered) {
-    const declarations = declarationsArray(batch.declarations);
-    declarations.forEach((raw, index) => {
-      const result = normalizeUserHook(raw, batch.source, options);
-      if (!result.hook) {
-        issues.push({ source: batch.source, index, issues: result.issues });
-        return;
+
+// src/domains/middleware/memory-intervention.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var MEMORY_INTERVENTION_REGISTRATION_ID = "observer.memory-intervention";
+var MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS = 8;
+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_EFFECTS3 = [];
+function createMemoryInterventionRegistration(deps) {
+  const pending = /* @__PURE__ */ new Map();
+  const trajectory = [];
+  const failures = /* @__PURE__ */ new Map();
+  let toolStep = 0;
+  let lastTurnEndStep = 0;
+  let reactivateAfterCompaction = false;
+  let lastInjectedOperationFingerprint = null;
+  let currentTask = "(current task unavailable)";
+  let toolsSinceMemoryStep = 0;
+  let consecutiveErrors = 0;
+  let lastPromptedBoundary = null;
+  let lastInjectedMessage = null;
+  let lastDecision = null;
+  const pendingTriggers = /* @__PURE__ */ new Set();
+  const activity = [];
+  const annotatedThisTurn = /* @__PURE__ */ new Set();
+  let telemetryBankSnapshot = deps.bank.snapshot();
+  let promptedStepInFlight = false;
+  let promptedStepTier = "rules";
+  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_EFFECTS3;
+      try {
+        switch (input.hook) {
+          case "before_tool":
+            observeBeforeTool(input);
+            return NO_EFFECTS3;
+          case "after_tool":
+            return observeAfterTool(input);
+          case "turn_end": {
+            if (toolStep <= lastTurnEndStep) return NO_EFFECTS3;
+            const alreadyReported = annotatedSinceTurnEnd;
+            annotatedSinceTurnEnd = false;
+            const started = process.hrtime.bigint();
+            const effects = decideRepeatedFailure();
+            if (alreadyReported && effects.length === 0) return effects;
+            emitTelemetry(
+              [effects.length > 0 ? "repeated_failure" : "turn_end"],
+              "rules",
+              effects.length > 0 ? "injected" : "silent",
+              effects.length > 0 ? "intervened" : "no_repeated_failure",
+              citedEntryCount(effects[0]?.kind === "inject_reminder" ? effects[0].message : null),
+              0,
+              0,
+              started
+            );
+            return effects;
+          }
+          case "on_compaction":
+            if (input.metadata?.stage === "working_set_recall") return NO_EFFECTS3;
+            reactivateAfterCompaction = true;
+            return NO_EFFECTS3;
+          case "turn_start": {
+            if (input.text?.trim()) currentTask = shortText(input.text, 2e3);
+            annotatedThisTurn.clear();
+            const shouldReactivate = reactivateAfterCompaction;
+            const started = process.hrtime.bigint();
+            const effects = reactivateKnowledge();
+            if (shouldReactivate) {
+              emitTelemetry(
+                ["post_compaction"],
+                "rules",
+                effects.length > 0 ? "injected" : "silent",
+                effects.length > 0 ? "intervened" : "bank_empty",
+                citedEntryCount(effects[0]?.kind === "inject_reminder" ? effects[0].message : null),
+                0,
+                0,
+                started
+              );
+            }
+            return effects;
+          }
+        }
+      } catch {
+        return NO_EFFECTS3;
       }
-      const existing = byId.get(result.hook.id);
-      if (existing) overridden.push({ winner: batch.source, loser: existing });
-      byId.set(result.hook.id, result.hook);
-    });
+    },
+    /**
+     * Kicks off the background memory step and returns immediately. The pi
+     * agent does not go idle until every `agent_end` listener settles, so
+     * awaiting a local memory model here would stall the visible turn for its
+     * full latency. Small local models measure in tens of seconds, which is far
+     * past any tolerable end-of-turn pause and past the policy timeout itself.
+     * The reminder is delivered through `onDeferredReminder` instead, landing
+     * in the next submitted turn, which is where an awaited turn_end reminder
+     * would have been buffered anyway.
+     */
+    async evaluateAsync(input, context) {
+      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_EFFECTS3;
+      if (deps.deliversDeferredReminders === false) {
+        emitTelemetry([...pendingTriggers], "rules", "silent", "no_consumer", 0, 0, 0, process.hrtime.bigint());
+        pendingTriggers.clear();
+        return NO_EFFECTS3;
+      }
+      if (promptedStepInFlight) {
+        emitTelemetry(
+          [...pendingTriggers],
+          promptedStepTier,
+          "dropped",
+          "step_in_flight",
+          0,
+          0,
+          0,
+          process.hrtime.bigint()
+        );
+        return NO_EFFECTS3;
+      }
+      lastPromptedBoundary = boundary;
+      const triggers = [...pendingTriggers];
+      pendingTriggers.clear();
+      toolsSinceMemoryStep = 0;
+      consecutiveErrors = 0;
+      const rulesAlreadySpoke = rulesInjectedSincePromptedStep || (context?.priorEffects.some(
+        (effect) => effect.kind === "inject_reminder" && effect.message.startsWith("Memory:")
+      ) ?? false);
+      rulesInjectedSincePromptedStep = false;
+      promptedStepInFlight = true;
+      outstandingStep = runPromptedStep({
+        deterministicTrigger: triggers.some((trigger) => trigger !== "interval"),
+        suppressIntervention: rulesAlreadySpoke,
+        triggerReasons: triggers
+      }).then((result) => {
+        if (rulesAlreadySpoke && result.decision === "silent") lastDecision = "injected";
+        if (result.reminder === null) return;
+        lastInjectedMessage = result.reminder;
+        deps.onDeferredReminder?.(result.reminder);
+      }).catch(() => {
+      }).finally(() => {
+        promptedStepInFlight = false;
+      });
+      return NO_EFFECTS3;
+    },
+    runPromptedStep,
+    signalLoop() {
+      if (settings().enabled) pendingTriggers.add("loop_signal");
+    },
+    lastDecision: () => lastDecision,
+    recentActivity: () => [...activity],
+    stepInFlight: () => promptedStepInFlight,
+    whenIdle: () => outstandingStep
+  };
+  function settings() {
+    const live = deps.getSettings?.();
+    return {
+      enabled: live?.enabled ?? deps.enabled ?? true,
+      everyNTools: Math.max(
+        2,
+        positiveInteger(live?.everyNTools ?? deps.everyNTools, MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS)
+      ),
+      windowSteps: positiveInteger(live?.windowSteps ?? deps.windowSteps, MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS),
+      maxTokens: positiveInteger(live?.maxTokens ?? deps.maxTokens, MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS),
+      timeoutMs: positiveInteger(live?.timeoutMs ?? deps.timeoutMs, TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS)
+    };
   }
-  return { hooks: [...byId.values()], overridden, issues };
-}
-function reminderEffect(message, severity) {
-  return severity === "info" ? { kind: "inject_reminder", message } : { kind: "inject_reminder", message, severity };
-}
-function commandEffect(hook, output) {
-  const message = output.slice(0, USER_HOOK_COMMAND_OUTPUT_MAX_CHARS);
-  return hook.as === "reminder" ? { kind: "inject_reminder", message } : { kind: "annotate_tool_result", message };
-}
-function userHookToRegistration(hook, deps) {
-  const now = deps.now ?? Date.now;
-  const baseReceipt = (input) => ({
-    at: now(),
-    hookId: hook.id,
-    origin: hook.source.origin,
-    sourcePath: hook.source.sourcePath,
-    hash: hook.hash,
-    hook: hook.on,
-    kind: hook.spec.kind,
-    ...input.toolName !== void 0 ? { toolName: input.toolName } : {}
-  });
-  const registration = {
-    id: hook.id,
-    description: `${hook.spec.kind} hook from ${hook.source.origin} (${hook.source.sourcePath})`,
-    hooks: [hook.on],
-    evaluate: (input) => {
-      if (!hook.enabled) return [];
+  async function runPromptedStep(input) {
+    const silent = (reason) => ({
+      decision: "silent",
+      reason,
+      bankOperations: 0,
+      droppedOperations: 0,
+      reminder: null,
+      inputTokens: 0,
+      outputTokens: 0,
+      usage: null,
+      effects: NO_EFFECTS3
+    });
+    const live = settings();
+    if (!live.enabled) {
+      const result = silent("no_client");
+      lastDecision = result.decision;
+      return result;
+    }
+    const started = process.hrtime.bigint();
+    const triggers = input.triggerReasons?.length ? input.triggerReasons : ["manual"];
+    let tier = "rules";
+    promptedStepTier = tier;
+    let promptedResult;
+    let telemetryDecision = null;
+    try {
+      if (consecutiveLlmTimeouts >= MEMORY_INTERVENTION_TIMEOUT_BACKOFF_THRESHOLD) {
+        promptedResult = silent("llm_timeout_backoff");
+      } else {
+        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");
+      deps.onEnvelope?.({
+        systemPrompt: "",
+        userPrompt: "",
+        response: "",
+        decision: "silent",
+        reason: "client_error",
+        bankOperations: 0,
+        droppedOperations: 0,
+        reminder: null,
+        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 {
-        return evaluateHook(hook, deps, baseReceipt(input));
+        deps.onStepUsage?.(promptedResult.usage);
       } catch {
-        deps.recordReceipt({ ...baseReceipt(input), outcome: "skipped" });
-        return [];
       }
     }
-  };
-  if (hook.tools !== void 0) registration.toolNames = [...hook.tools];
-  return registration;
-}
-function evaluateHook(hook, deps, base) {
-  if (hook.spec.kind === "prompt") {
-    const effect2 = reminderEffect(hook.spec.message, hook.spec.severity);
-    deps.recordReceipt({ ...base, outcome: "emitted", effectKinds: ["inject_reminder"] });
-    return [effect2];
+    if (promptedResult.decision === "injected") reportInjectedEntries(promptedResult.reminder);
+    emitTelemetry(
+      triggers,
+      tier,
+      telemetryDecision ?? promptedResult.decision,
+      promptedResult.reason,
+      citedEntryCount(promptedResult.reminder),
+      promptedResult.inputTokens,
+      promptedResult.outputTokens,
+      started,
+      { bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations }
+    );
+    return {
+      ...promptedResult,
+      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 }) {
+    const next = deps.bank.snapshot();
+    const bankDelta = taskMemoryBankDelta(telemetryBankSnapshot, next);
+    telemetryBankSnapshot = next;
+    const latencyMs = Number(process.hrtime.bigint() - started) / 1e6;
+    try {
+      deps.telemetry?.record({
+        triggerReasons,
+        tier,
+        bankDelta,
+        decision,
+        reason,
+        bankOperations: operations.bankOperations,
+        droppedOperations: operations.droppedOperations,
+        citedEntries: citedEntries2,
+        inputTokens,
+        outputTokens,
+        latencyMs
+      });
+    } catch {
+    }
+    const event = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      triggerReasons: [...new Set(triggerReasons)],
+      tier,
+      decision,
+      reason,
+      citedEntries: citedEntries2,
+      bankWrites: countBankWrites(bankDelta),
+      latencyMs
+    };
+    activity.unshift(event);
+    if (activity.length > MEMORY_INTERVENTION_ACTIVITY_LIMIT) activity.length = MEMORY_INTERVENTION_ACTIVITY_LIMIT;
   }
-  if (hook.spec.kind === "effect") {
-    deps.recordReceipt({ ...base, outcome: "emitted", effectKinds: [hook.spec.effect.kind] });
-    return [hook.spec.effect];
+  function citedEntries(message) {
+    if (message === null) return [];
+    const snapshot = deps.bank.snapshot();
+    return [...snapshot.knowledge, ...snapshot.procedural].filter((entry) => message.includes(`[${entry.id}]`));
   }
-  const result = deps.runCommand(hook.spec.argv, {
-    timeoutMs: hook.spec.timeoutMs,
-    ...hook.spec.cwd !== void 0 ? { cwd: hook.spec.cwd } : {}
-  });
-  const output = (result.stdout || result.stderr || "").trim();
-  if (result.timedOut) {
-    deps.recordReceipt({ ...base, outcome: "command-timeout", exitCode: result.code ?? -1, outputChars: output.length });
-    return [];
+  function citedEntryCount(message) {
+    return citedEntries(message).length;
   }
-  const outcome = result.code === 0 ? "command-ok" : "command-failed";
-  deps.recordReceipt({ ...base, outcome, exitCode: result.code ?? -1, outputChars: output.length });
-  if (output.length === 0) return [];
-  const effect = commandEffect(hook.spec, output);
-  return [effect];
-}
-
-// src/domains/middleware/hooks-io.ts
-var COMMAND_OUTPUT_MAX_BYTES = 1024 * 1024;
-function readBatch(source, filePath, fileIssues) {
-  let text;
-  try {
-    text = readFileSync(filePath, "utf8");
-  } catch {
-    return null;
+  function reportInjectedEntries(reminder) {
+    if (deps.onInjectedEntries === void 0) return;
+    const entries = citedEntries(reminder);
+    if (entries.length === 0) return;
+    try {
+      deps.onInjectedEntries(entries);
+    } catch {
+    }
   }
-  try {
-    const parsed = (0, import_yaml.parse)(text);
-    return { source, declarations: parsed ?? [] };
-  } catch (err) {
-    fileIssues.push({
-      source,
-      message: `failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-    });
-    return null;
+  function observeBeforeTool(input) {
+    const prepared = prepareToolStep(input);
+    if (prepared === null) return;
+    setBounded(pending, pendingKey(input, prepared.operationFingerprint), prepared, settings().windowSteps);
   }
-}
-function readHookSources(options) {
-  const fileIssues = [];
-  const batches = [];
-  for (const extension of options.extensions ?? []) {
-    const source = {
-      origin: "extension",
-      sourcePath: `${extension.id}:hooks.yaml`,
-      sourceId: extension.id
+  function observeAfterTool(input) {
+    const fallback = prepareToolStep(input);
+    if (fallback === null) return NO_EFFECTS3;
+    const key = pendingKey(input, fallback.operationFingerprint);
+    const prepared = pending.get(key) ?? fallback;
+    pending.delete(key);
+    const outcome = input.metadata?.resultKind === "error" ? "error" : "ok";
+    toolStep += 1;
+    toolsSinceMemoryStep += 1;
+    const live = settings();
+    if (toolsSinceMemoryStep >= live.everyNTools) pendingTriggers.add("interval");
+    if (outcome === "error") {
+      consecutiveErrors += 1;
+      if (consecutiveErrors >= 2) pendingTriggers.add("tool_error_streak");
+    } else {
+      consecutiveErrors = 0;
+    }
+    const digest = resultDigest(input, outcome);
+    const step = {
+      ...prepared,
+      step: toolStep,
+      outcome,
+      resultDigest: digest.text,
+      resultDigestProvenance: digest.provenance
     };
-    const batch = readBatch(source, join(extension.rootPath, "hooks.yaml"), fileIssues);
-    if (batch) batches.push(batch);
+    trajectory.push(step);
+    if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
+    if (outcome !== "error") return NO_EFFECTS3;
+    rememberFailure(step);
+    return annotateRepeatedFailure(step);
   }
-  const projectBatch = readBatch(
-    { origin: "project", sourcePath: ".clio-coder/hooks.yaml" },
-    join(options.cwd, ".clio-coder", "hooks.yaml"),
-    fileIssues
-  );
-  if (projectBatch) batches.push(projectBatch);
-  const localBatch = readBatch(
-    { origin: "project.local", sourcePath: ".clio-coder/hooks.local.yaml" },
-    join(options.cwd, ".clio-coder", "hooks.local.yaml"),
-    fileIssues
-  );
-  if (localBatch) batches.push(localBatch);
-  return { batches, fileIssues };
-}
-function installUserHooks(options) {
-  const workspaceRoot = options.workspaceRoot ?? options.cwd;
-  const readOptions = { cwd: options.cwd };
-  if (options.extensions !== void 0) readOptions.extensions = options.extensions;
-  const { batches, fileIssues } = readHookSources(readOptions);
-  const loaded = loadUserHooks(batches, { workspaceRoot });
-  const runCommand = options.runCommand ?? spawnSyncCommandRunner();
-  for (const hook of loaded.hooks) {
-    options.registerHook(
-      userHookToRegistration(hook, {
-        recordReceipt: options.recordReceipt,
-        runCommand,
-        ...options.now !== void 0 ? { now: options.now } : {}
-      })
+  function annotateRepeatedFailure(step) {
+    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_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
     );
-  }
-  return { ...loaded, fileIssues };
-}
-function spawnSyncCommandRunner() {
-  return (argv, options) => {
-    const [command, ...args] = argv;
-    const attribution = withManagedGitCommitAttributionEnvironment(process.env, {
-      cwd: options.cwd ?? process.cwd(),
-      evidence: {}
-    });
-    reportCommitAttributionDiagnostic(attribution.diagnostic);
-    const result = spawnSync(command ?? "", args, {
-      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
-      timeout: options.timeoutMs,
-      maxBuffer: COMMAND_OUTPUT_MAX_BYTES,
-      encoding: "utf8",
-      shell: false,
-      env: attribution.env
-    });
-    const timedOut = result.error !== void 0 && result.error.code === "ETIMEDOUT";
-    return {
-      code: result.status,
-      timedOut,
-      stdout: typeof result.stdout === "string" ? result.stdout : "",
-      stderr: typeof result.stderr === "string" ? result.stderr : ""
-    };
-  };
-}
-
-// 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;
+    if (message.length === 0) return NO_EFFECTS3;
+    annotatedThisTurn.add(step.operationFingerprint);
+    lastInjectedOperationFingerprint = step.operationFingerprint;
+    lastDecision = "injected";
+    rulesInjectedSincePromptedStep = true;
+    annotatedSinceTurnEnd = true;
+    deps.bank.recordInjection([failure.entryId]);
+    emitTelemetry(["repeated_failure"], "rules", "injected", "intervened", 1, 0, 0, process.hrtime.bigint());
+    return [{ kind: "annotate_tool_result", message, severity: "warn" }];
+  }
+  function rememberFailure(step) {
+    const previous = failures.get(step.operationFingerprint);
+    const attempts = (previous?.attempts ?? 0) + 1;
+    const firstStep = previous?.firstStep ?? step.step;
+    const content = proceduralContent(step.callDescription, attempts, firstStep, step.resultDigest);
+    let entryId;
+    if (previous === void 0) {
+      entryId = deps.bank.saveProcedural(content).id;
+    } else {
       try {
-        installed = deps.countModelVisibleSkills();
-        installable = deps.countInstallableSkills?.() ?? 0;
+        entryId = deps.bank.saveProcedural(content, { id: previous.entryId }).id;
       } catch {
-        return NO_EFFECTS;
+        entryId = deps.bank.saveProcedural(content).id;
       }
-      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 };
+    setBounded(
+      failures,
+      step.operationFingerprint,
+      {
+        entryId,
+        attempts,
+        firstStep,
+        callDescription: step.callDescription,
+        errorDigest: step.resultDigest
+      },
+      TASK_MEMORY_DEFAULT_PROCEDURAL_CAP
+    );
+  }
+  function decideRepeatedFailure() {
+    try {
+      for (let index = trajectory.length - 1; index >= 0; index -= 1) {
+        const step = trajectory[index];
+        if (step === void 0 || step.outcome !== "error" || step.step <= lastTurnEndStep || step.operationFingerprint === lastInjectedOperationFingerprint) {
+          continue;
+        }
+        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) continue;
+        const message = boundedReminder(
+          `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_EFFECTS3;
+        lastInjectedOperationFingerprint = step.operationFingerprint;
+        lastInjectedMessage = message;
+        lastDecision = "injected";
+        rulesInjectedSincePromptedStep = true;
+        deps.bank.recordInjection([failure.entryId]);
+        return [{ kind: "inject_reminder", message, severity: "advisory" }];
+      }
+      lastDecision = "silent";
+      return NO_EFFECTS3;
+    } finally {
+      lastTurnEndStep = toolStep;
     }
   }
-  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);
+  function reactivateKnowledge() {
+    if (!reactivateAfterCompaction) return NO_EFFECTS3;
+    reactivateAfterCompaction = false;
+    const prefix = "Memory: execution state restored after compaction:\n";
+    const maxTokens = settings().maxTokens;
+    const prefixTokens = ceilChars(prefix.length);
+    const rendered = deps.bank.renderRestoredState(Math.max(0, maxTokens - prefixTokens));
+    if (rendered.length === 0) {
+      lastDecision = "silent";
+      return NO_EFFECTS3;
+    }
+    const message = boundedReminder(`${prefix}${rendered}`, maxTokens);
+    if (message.length === 0) {
+      lastDecision = "silent";
+      return NO_EFFECTS3;
+    }
+    const citedIds = [...message.matchAll(/\[([^\]]+)\]/gu)].map((match) => match[1]).filter((id) => id !== void 0);
+    deps.bank.recordInjection(citedIds);
+    lastInjectedMessage = message;
+    lastDecision = "injected";
+    return [{ kind: "inject_reminder", message, severity: "advisory" }];
   }
-  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 prepareToolStep(input) {
+  const toolName = input.toolName?.trim();
+  if (!toolName) return null;
+  const canonical = hashToolCall(toolName, input.toolArgs ?? {});
+  return {
+    toolName,
+    operationFingerprint: createHash("sha256").update(canonical).digest("hex").slice(0, 16),
+    callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS)
+  };
 }
-function declinesPath(configDir) {
-  return path.join(configDir ?? clioConfigDir(), PROMOTION_DECLINES_FILE);
+function pendingKey(input, operationFingerprint) {
+  return input.toolCallId ?? `anonymous:${operationFingerprint}`;
 }
-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) };
+function resultDigest(input, outcome) {
+  if (input.toolResultDigest !== void 0) return sanitizeToolResultDigest(input.toolResultDigest);
+  if (outcome === "error") {
+    const metadataMessage = input.metadata?.errorMessage;
+    if (typeof metadataMessage === "string" && metadataMessage.trim().length > 0) {
+      return legacyToolResultDigest(diagnosticLine(metadataMessage), { outcome });
     }
-  } catch {
+    for (const key of ["error", "message"]) {
+      const value = input.toolResultDetails?.[key];
+      if (typeof value === "string" && value.trim().length > 0) {
+        return legacyToolResultDigest(diagnosticLine(value), { outcome });
+      }
+    }
+    return legacyToolResultDigest("", { outcome });
   }
-  return { never: {} };
+  const resultFingerprint = input.metadata?.resultFingerprint;
+  return legacyToolResultDigest(
+    typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok",
+    { outcome }
+  );
 }
-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" });
+var DIAGNOSTIC_HINT = /\b(error|failed|failure|cannot|unable|expected|refused|denied|missing|not found|timed out|timeout|fatal)\b/iu;
+function diagnosticLine(value) {
+  const lines = value.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
+  return lines.find((line) => DIAGNOSTIC_HINT.test(line)) ?? lines[0] ?? "";
 }
-
-// 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 proceduralContent(call, attempts, firstStep, error) {
+  return `${call} failed ${attempts} time${attempts === 1 ? "" : "s"}; first observed at step ${firstStep}: ${error}.`;
 }
-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 boundedReminder(message, maxTokens) {
+  const maxChars = maxTokens * 4;
+  if (maxChars <= 0) return "";
+  const normalized = message.replace(/[^\S\n]+/gu, " ").trim();
+  return normalized.length <= maxChars ? normalized : normalized.slice(0, maxChars).trimEnd();
 }
-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 shortText(value, maxChars) {
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized.length <= maxChars ? normalized : `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+}
+function positiveInteger(value, fallback) {
+  return value !== void 0 && Number.isInteger(value) && value > 0 ? value : fallback;
 }
-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 countBankWrites(delta) {
+  return [delta.status, delta.knowledge, delta.procedural].reduce(
+    (total, entry) => total + entry.added + entry.updated + entry.deleted,
+    0
   );
 }
-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;
+function setBounded(map, key, value, capacity) {
+  if (!map.has(key) && map.size >= capacity) {
+    const oldest = map.keys().next().value;
+    if (oldest !== void 0) map.delete(oldest);
   }
-  return null;
+  map.set(key, value);
 }
-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;
+
+// src/domains/middleware/memory-step-endpoint.ts
+init_esm_shims();
+function announceMemoryStepEndpoint(deps, complete) {
+  const { bus, endpointKey, targetId } = deps;
+  if (endpointKey === null) return complete;
+  return async (request) => {
+    const releaseEndpointSlot = registerForegroundStream(endpointKey);
     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);
+      return await complete(request);
+    } finally {
+      releaseEndpointSlot();
+      if (bus !== null) {
         try {
-          declines.recordNever(offer.entry.name, offer.entry.version);
+          bus.emit(BusChannels.MemoryStepCompleted, { endpointKey, targetId });
         } 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;
   };
+}
+
+// src/domains/middleware/task-board-reminder.ts
+init_esm_shims();
+var TASK_BOARD_REMINDER_REGISTRATION_ID = "observer.task-board-reminder";
+function taskBoardReminderMessage(steps) {
+  return `[Tasks] This request enumerates ${steps} steps. Before the first edit, declare the task board: tasks action="plan" with a title and one task per step, then work them one at a time ("start", then "done" with an evidence note).`;
+}
+function countEnumeratedSteps(text) {
+  const value = text ?? "";
+  if (value.trim().length === 0) return 0;
+  const markers = [];
+  const markerPattern = /(?:^|[\s(])(?:step\s+)?([1-9])\s*[).:]\s/gi;
+  let match = markerPattern.exec(value);
+  while (match !== null) {
+    const digit = Number(match[1]);
+    if (Number.isInteger(digit)) markers.push(digit);
+    match = markerPattern.exec(value);
+  }
+  let run = 0;
+  for (const digit of markers) {
+    if (digit === run + 1) run += 1;
+    else if (digit === 1) run = 1;
+  }
+  if (run >= 3) return run;
+  const bulletLines = value.split(/\r?\n/).filter((line) => /^\s*[-*]\s+\S/.test(line)).length;
+  return bulletLines >= 3 ? bulletLines : 0;
+}
+var NO_EFFECTS4 = [];
+function createTaskBoardReminderRegistration() {
+  let lastSeenSessionId;
+  let spentForActiveSession = false;
   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"],
+    id: TASK_BOARD_REMINDER_REGISTRATION_ID,
+    description: "once per session, on the first explicitly enumerated multi-step turn, teaches the board-first protocol",
+    hooks: ["turn_start"],
     evaluate(input) {
-      trackSession(input);
-      if (input.hook === "after_tool") {
-        return input.toolName === ToolNames.AskUser ? evaluateAskUserAnswers(input) : NO_EFFECTS2;
+      const sessionId = input.sessionId ?? null;
+      if (lastSeenSessionId === void 0 || lastSeenSessionId === null && sessionId !== null) {
+        lastSeenSessionId = sessionId;
+      } else if (sessionId !== lastSeenSessionId) {
+        lastSeenSessionId = sessionId;
+        spentForActiveSession = false;
       }
-      if (input.hook !== "turn_start") return NO_EFFECTS2;
-      if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS2;
+      if (spentForActiveSession) return NO_EFFECTS4;
+      const steps = countEnumeratedSteps(input.text);
+      if (steps < 3) return NO_EFFECTS4;
+      spentForActiveSession = true;
       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 {
-        }
+      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS4;
+      return [{ kind: "inject_reminder", severity: "info", message: taskBoardReminderMessage(steps) }];
+    }
+  };
+}
+
+// src/domains/middleware/task-nudge.ts
+init_esm_shims();
+var TASK_NUDGE_REGISTRATION_ID = "nudge.open-tasks";
+function openTasks(board) {
+  return board.tasks.filter((task) => task.status === "pending" || task.status === "active");
+}
+function buildOpenTasksMessage(board) {
+  const open = openTasks(board);
+  const counts = taskBoardCounts(board);
+  const rows = open.map((task) => `  ${task.status === "active" ? "[>]" : "[ ]"} ${task.id} ${task.title}`);
+  return `[Clio Coder] task board "${board.title}" still has ${open.length} of ${counts.total} task(s) open:
+${rows.join("\n")}
+Continue working them, or record the honest state on the board: tasks action="done" with an evidence note, action="block" with a reason, or action="drop". Do not end the turn with a stale board.`;
+}
+function createTaskNudgeRegistration(options) {
+  return {
+    id: TASK_NUDGE_REGISTRATION_ID,
+    description: "carry the turn onward when a work turn ends with open task-board tasks",
+    hooks: ["turn_end"],
+    evaluate(input) {
+      if (input.hook !== "turn_end") return [];
+      const stopReason = input.metadata?.stopReason;
+      if (stopReason !== void 0 && stopReason !== "stop") return [];
+      const turnToolCalls = input.metadata?.turnToolCalls;
+      if (typeof turnToolCalls !== "number" || turnToolCalls <= 0) return [];
+      const activeToolNames = input.metadata?.activeToolNames;
+      if (typeof activeToolNames === "string" && !activeToolNames.split(",").includes(ToolNames.Tasks)) return [];
+      let board;
+      try {
+        board = options.getBoard();
+      } catch {
+        return [];
       }
-      const tag = newOfferTag();
-      pendingOffer = { entry: match.entry, tag };
-      return [{ kind: "inject_reminder", severity: "info", message: marketplaceOfferReminder(match.entry, tag) }];
+      if (board === null || openTasks(board).length === 0) return [];
+      const message = buildOpenTasksMessage(board);
+      return [
+        { kind: "request_continuation", message },
+        { kind: "inject_reminder", message, severity: "warn" }
+      ];
     }
   };
 }
 
-// src/domains/middleware/memory-intervention.ts
+// src/domains/middleware/tool-choice-control.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 = 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_EFFECTS3 = [];
-function createMemoryInterventionRegistration(deps) {
-  const pending = /* @__PURE__ */ new Map();
-  const trajectory = [];
-  const failures = /* @__PURE__ */ new Map();
-  let toolStep = 0;
-  let lastTurnEndStep = 0;
-  let reactivateAfterCompaction = false;
-  let lastInjectedOperationFingerprint = null;
-  let currentTask = "(current task unavailable)";
-  let toolsSinceMemoryStep = 0;
-  let consecutiveErrors = 0;
-  let lastPromptedBoundary = null;
-  let lastInjectedMessage = null;
-  let lastDecision = null;
-  const pendingTriggers = /* @__PURE__ */ new Set();
-  const activity = [];
-  const annotatedThisTurn = /* @__PURE__ */ new Set();
-  let telemetryBankSnapshot = deps.bank.snapshot();
-  let promptedStepInFlight = false;
-  let promptedStepTier = "rules";
-  let outstandingStep = Promise.resolve();
-  let rulesInjectedSincePromptedStep = false;
-  let annotatedSinceTurnEnd = false;
-  let consecutiveLlmTimeouts = 0;
+function createMiddlewareToolChoiceControl() {
+  let choice = { kind: "auto" };
   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_EFFECTS3;
-      try {
-        switch (input.hook) {
-          case "before_tool":
-            observeBeforeTool(input);
-            return NO_EFFECTS3;
-          case "after_tool":
-            return observeAfterTool(input);
-          case "turn_end": {
-            if (toolStep <= lastTurnEndStep) return NO_EFFECTS3;
-            const alreadyReported = annotatedSinceTurnEnd;
-            annotatedSinceTurnEnd = false;
-            const started = process.hrtime.bigint();
-            const effects = decideRepeatedFailure();
-            if (alreadyReported && effects.length === 0) return effects;
-            emitTelemetry(
-              [effects.length > 0 ? "repeated_failure" : "turn_end"],
-              "rules",
-              effects.length > 0 ? "injected" : "silent",
-              effects.length > 0 ? "intervened" : "no_repeated_failure",
-              citedEntryCount(effects[0]?.kind === "inject_reminder" ? effects[0].message : null),
-              0,
-              0,
-              started
-            );
-            return effects;
-          }
-          case "on_compaction":
-            if (input.metadata?.stage === "working_set_recall") return NO_EFFECTS3;
-            reactivateAfterCompaction = true;
-            return NO_EFFECTS3;
-          case "turn_start": {
-            if (input.text?.trim()) currentTask = shortText(input.text, 2e3);
-            annotatedThisTurn.clear();
-            const shouldReactivate = reactivateAfterCompaction;
-            const started = process.hrtime.bigint();
-            const effects = reactivateKnowledge();
-            if (shouldReactivate) {
-              emitTelemetry(
-                ["post_compaction"],
-                "rules",
-                effects.length > 0 ? "injected" : "silent",
-                effects.length > 0 ? "intervened" : "bank_empty",
-                citedEntryCount(effects[0]?.kind === "inject_reminder" ? effects[0].message : null),
-                0,
-                0,
-                started
-              );
-            }
-            return effects;
-          }
+    apply(effects) {
+      for (const effect of effects) {
+        if (effect.kind === "lock_tools") {
+          choice = { kind: "none" };
+          continue;
         }
-      } catch {
-        return NO_EFFECTS3;
-      }
-    },
-    /**
-     * Kicks off the background memory step and returns immediately. The pi
-     * agent does not go idle until every `agent_end` listener settles, so
-     * awaiting a local memory model here would stall the visible turn for its
-     * full latency. Small local models measure in tens of seconds, which is far
-     * past any tolerable end-of-turn pause and past the policy timeout itself.
-     * The reminder is delivered through `onDeferredReminder` instead, landing
-     * in the next submitted turn, which is where an awaited turn_end reminder
-     * would have been buffered anyway.
-     */
-    async evaluateAsync(input, context) {
-      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_EFFECTS3;
-      if (deps.deliversDeferredReminders === false) {
-        emitTelemetry([...pendingTriggers], "rules", "silent", "no_consumer", 0, 0, 0, process.hrtime.bigint());
-        pendingTriggers.clear();
-        return NO_EFFECTS3;
-      }
-      if (promptedStepInFlight) {
-        emitTelemetry(
-          [...pendingTriggers],
-          promptedStepTier,
-          "dropped",
-          "step_in_flight",
-          0,
-          0,
-          0,
-          process.hrtime.bigint()
-        );
-        return NO_EFFECTS3;
-      }
-      lastPromptedBoundary = boundary;
-      const triggers = [...pendingTriggers];
-      pendingTriggers.clear();
-      toolsSinceMemoryStep = 0;
-      consecutiveErrors = 0;
-      const rulesAlreadySpoke = rulesInjectedSincePromptedStep || (context?.priorEffects.some(
-        (effect) => effect.kind === "inject_reminder" && effect.message.startsWith("Memory:")
-      ) ?? false);
-      rulesInjectedSincePromptedStep = false;
-      promptedStepInFlight = true;
-      outstandingStep = runPromptedStep({
-        deterministicTrigger: triggers.some((trigger) => trigger !== "interval"),
-        suppressIntervention: rulesAlreadySpoke,
-        triggerReasons: triggers
-      }).then((result) => {
-        if (rulesAlreadySpoke && result.decision === "silent") lastDecision = "injected";
-        if (result.reminder === null) return;
-        lastInjectedMessage = result.reminder;
-        deps.onDeferredReminder?.(result.reminder);
-      }).catch(() => {
-      }).finally(() => {
-        promptedStepInFlight = false;
-      });
-      return NO_EFFECTS3;
-    },
-    runPromptedStep,
-    signalLoop() {
-      if (settings().enabled) pendingTriggers.add("loop_signal");
-    },
-    lastDecision: () => lastDecision,
-    recentActivity: () => [...activity],
-    stepInFlight: () => promptedStepInFlight,
-    whenIdle: () => outstandingStep
-  };
-  function settings() {
-    const live = deps.getSettings?.();
-    return {
-      enabled: live?.enabled ?? deps.enabled ?? true,
-      everyNTools: Math.max(
-        2,
-        positiveInteger(live?.everyNTools ?? deps.everyNTools, MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS)
-      ),
-      windowSteps: positiveInteger(live?.windowSteps ?? deps.windowSteps, MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS),
-      maxTokens: positiveInteger(live?.maxTokens ?? deps.maxTokens, MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS),
-      timeoutMs: positiveInteger(live?.timeoutMs ?? deps.timeoutMs, TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS)
-    };
-  }
-  async function runPromptedStep(input) {
-    const silent = (reason) => ({
-      decision: "silent",
-      reason,
-      bankOperations: 0,
-      droppedOperations: 0,
-      reminder: null,
-      inputTokens: 0,
-      outputTokens: 0,
-      usage: null,
-      effects: NO_EFFECTS3
-    });
-    const live = settings();
-    if (!live.enabled) {
-      const result = silent("no_client");
-      lastDecision = result.decision;
-      return result;
-    }
-    const started = process.hrtime.bigint();
-    const triggers = input.triggerReasons?.length ? input.triggerReasons : ["manual"];
-    let tier = "rules";
-    promptedStepTier = tier;
-    let promptedResult;
-    let telemetryDecision = null;
-    try {
-      if (consecutiveLlmTimeouts >= MEMORY_INTERVENTION_TIMEOUT_BACKOFF_THRESHOLD) {
-        promptedResult = silent("llm_timeout_backoff");
-      } else {
-        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 }
-          });
+        if (effect.kind === "require_tool" && choice.kind !== "none") {
+          choice = { kind: "required", toolName: effect.toolName };
         }
       }
-    } catch (error) {
-      promptedResult = silent("client_error");
-      deps.onEnvelope?.({
-        systemPrompt: "",
-        userPrompt: "",
-        response: "",
-        decision: "silent",
-        reason: "client_error",
-        bankOperations: 0,
-        droppedOperations: 0,
-        reminder: null,
-        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 {
-        deps.onStepUsage?.(promptedResult.usage);
-      } catch {
-      }
+    },
+    current: () => choice,
+    toolStarted(toolName) {
+      if (choice.kind === "required" && choice.toolName === toolName) choice = { kind: "auto" };
+    },
+    reset() {
+      choice = { kind: "auto" };
     }
-    if (promptedResult.decision === "injected") reportInjectedEntries(promptedResult.reminder);
-    emitTelemetry(
-      triggers,
-      tier,
-      telemetryDecision ?? promptedResult.decision,
-      promptedResult.reason,
-      citedEntryCount(promptedResult.reminder),
-      promptedResult.inputTokens,
-      promptedResult.outputTokens,
-      started,
-      { bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations }
-    );
-    return {
-      ...promptedResult,
-      effects: promptedResult.reminder === null ? NO_EFFECTS3 : [{ kind: "inject_reminder", message: promptedResult.reminder, severity: "advisory" }]
-    };
+  };
+}
+
+// src/domains/middleware/watchdog.ts
+init_esm_shims();
+var WATCHDOG_REGISTRATION_ID = "observer.watchdog";
+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_EFFECTS5 = [];
+function stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function firstPath(details) {
+  const paths = details?.paths;
+  if (!Array.isArray(paths)) return null;
+  for (const entry of paths) {
+    const path2 = stringValue2(entry);
+    if (path2 !== null) return path2;
   }
-  function emitTelemetry(triggerReasons, tier, decision, reason, citedEntries2, inputTokens, outputTokens, started, operations = { bankOperations: 0, droppedOperations: 0 }) {
-    const next = deps.bank.snapshot();
-    const bankDelta = taskMemoryBankDelta(telemetryBankSnapshot, next);
-    telemetryBankSnapshot = next;
-    const latencyMs = Number(process.hrtime.bigint() - started) / 1e6;
+  return null;
+}
+function coalesceTurnDiff(byPath, maxBytes = WATCHDOG_DIFF_MAX_BYTES) {
+  const blocks = [];
+  let index = 0;
+  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(`--- ${path2}
+${diff}`);
+    index += 1;
+  }
+  const whole = blocks.join("\n\n");
+  if (Buffer.byteLength(whole, "utf8") <= maxBytes) return whole;
+  const room = Math.max(0, maxBytes - Buffer.byteLength(WATCHDOG_TRUNCATION_MARKER, "utf8"));
+  const buffer = Buffer.from(whole, "utf8");
+  let cut = Math.min(room, buffer.byteLength);
+  while (cut > 0) {
+    const next = buffer[cut];
+    if (next === void 0 || (next & 192) !== 128) break;
+    cut -= 1;
+  }
+  return `${buffer.subarray(0, cut).toString("utf8")}${WATCHDOG_TRUNCATION_MARKER}`;
+}
+var WATCHDOG_TASK = "Review the coalesced diff in the briefing against the scope it names. Report one check per concern: a change outside the stated scope, a change the scope required that the diff does not make, or a defect visible in the diff itself. Run no commands and change nothing.";
+function watchdogBriefing(trigger) {
+  const scope = trigger.scope === null ? "(no task board; scope is unstated)" : trigger.scope;
+  const paths = trigger.paths.length === 0 ? "(none)" : trigger.paths.join("\n");
+  return [
+    "## Current scope",
+    scope,
+    "",
+    "## Changed paths",
+    paths,
+    "",
+    "## Coalesced diff for this turn",
+    trigger.diff
+  ].join("\n");
+}
+function createWatchdogRegistration(deps) {
+  const diffByPath = /* @__PURE__ */ new Map();
+  let toolCalls = 0;
+  let dropped = 0;
+  let inFlight = false;
+  let outstanding = Promise.resolve();
+  const active = () => {
+    if (deps.firesOnThisSurface === false) return null;
+    let settings;
     try {
-      deps.telemetry?.record({
-        triggerReasons,
-        tier,
-        bankDelta,
-        decision,
-        reason,
-        bankOperations: operations.bankOperations,
-        droppedOperations: operations.droppedOperations,
-        citedEntries: citedEntries2,
-        inputTokens,
-        outputTokens,
-        latencyMs
-      });
+      settings = deps.getSettings();
     } catch {
+      return null;
     }
-    const event = {
-      at: (/* @__PURE__ */ new Date()).toISOString(),
-      triggerReasons: [...new Set(triggerReasons)],
-      tier,
-      decision,
+    return settings.enabled ? settings : null;
+  };
+  const resetTurn = () => {
+    diffByPath.clear();
+    toolCalls = 0;
+  };
+  const fire = (reason) => {
+    if (diffByPath.size === 0) return;
+    if (inFlight) {
+      dropped += 1;
+      return;
+    }
+    const trigger = {
       reason,
-      citedEntries: citedEntries2,
-      bankWrites: countBankWrites(bankDelta),
-      latencyMs
+      diff: coalesceTurnDiff(diffByPath),
+      paths: [...diffByPath.keys()].slice(0, WATCHDOG_PATHS_MAX),
+      scope: scopeNow(),
+      toolCalls
     };
-    activity.unshift(event);
-    if (activity.length > MEMORY_INTERVENTION_ACTIVITY_LIMIT) activity.length = MEMORY_INTERVENTION_ACTIVITY_LIMIT;
-  }
-  function citedEntries(message) {
-    if (message === null) return [];
-    const snapshot = deps.bank.snapshot();
-    return [...snapshot.knowledge, ...snapshot.procedural].filter((entry) => message.includes(`[${entry.id}]`));
-  }
-  function citedEntryCount(message) {
-    return citedEntries(message).length;
-  }
-  function reportInjectedEntries(reminder) {
-    if (deps.onInjectedEntries === void 0) return;
-    const entries = citedEntries(reminder);
-    if (entries.length === 0) return;
+    inFlight = true;
+    let started;
     try {
-      deps.onInjectedEntries(entries);
+      started = deps.run(trigger);
     } catch {
+      inFlight = false;
+      return;
     }
-  }
-  function observeBeforeTool(input) {
-    const prepared = prepareToolStep(input);
-    if (prepared === null) return;
-    setBounded(pending, pendingKey(input, prepared.operationFingerprint), prepared, settings().windowSteps);
-  }
-  function observeAfterTool(input) {
-    const fallback = prepareToolStep(input);
-    if (fallback === null) return NO_EFFECTS3;
-    const key = pendingKey(input, fallback.operationFingerprint);
-    const prepared = pending.get(key) ?? fallback;
-    pending.delete(key);
-    const outcome = input.metadata?.resultKind === "error" ? "error" : "ok";
-    toolStep += 1;
-    toolsSinceMemoryStep += 1;
-    const live = settings();
-    if (toolsSinceMemoryStep >= live.everyNTools) pendingTriggers.add("interval");
-    if (outcome === "error") {
-      consecutiveErrors += 1;
-      if (consecutiveErrors >= 2) pendingTriggers.add("tool_error_streak");
-    } else {
-      consecutiveErrors = 0;
+    outstanding = started.catch(() => {
+    }).finally(() => {
+      inFlight = false;
+    });
+  };
+  const scopeNow = () => {
+    try {
+      return deps.getScope?.() ?? null;
+    } catch {
+      return null;
     }
-    const digest = resultDigest(input, outcome);
-    const step = {
-      ...prepared,
-      step: toolStep,
-      outcome,
-      resultDigest: digest.text,
-      resultDigestProvenance: digest.provenance
-    };
-    trajectory.push(step);
-    if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
-    if (outcome !== "error") return NO_EFFECTS3;
-    rememberFailure(step);
-    return annotateRepeatedFailure(step);
-  }
-  function annotateRepeatedFailure(step) {
-    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_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_EFFECTS3;
-    annotatedThisTurn.add(step.operationFingerprint);
-    lastInjectedOperationFingerprint = step.operationFingerprint;
-    lastDecision = "injected";
-    rulesInjectedSincePromptedStep = true;
-    annotatedSinceTurnEnd = true;
-    deps.bank.recordInjection([failure.entryId]);
-    emitTelemetry(["repeated_failure"], "rules", "injected", "intervened", 1, 0, 0, process.hrtime.bigint());
-    return [{ kind: "annotate_tool_result", message, severity: "warn" }];
+  };
+  return {
+    id: WATCHDOG_REGISTRATION_ID,
+    description: "review a mutating turn's coalesced diff against the board scope with a read-only verifier run",
+    hooks: ["after_tool", "turn_end"],
+    evaluate(input) {
+      const settings = active();
+      if (settings === null) {
+        if (input.hook === "turn_end") resetTurn();
+        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_EFFECTS5;
+      }
+      if (input.hook !== "turn_end") return NO_EFFECTS5;
+      fire("turn_end");
+      resetTurn();
+      return NO_EFFECTS5;
+    },
+    droppedTriggers: () => dropped,
+    runInFlight: () => inFlight,
+    whenIdle: () => outstanding
+  };
+  function recordMutation(input) {
+    if (input.metadata?.resultKind !== "ok") return;
+    if (input.toolName === void 0 || !MUTATING_TOOL_NAMES.has(input.toolName)) return;
+    const diff = stringValue2(input.toolResultDetails?.diff);
+    if (diff === null) return;
+    diffByPath.set(firstPath(input.toolResultDetails) ?? input.toolName, diff);
   }
-  function rememberFailure(step) {
-    const previous = failures.get(step.operationFingerprint);
-    const attempts = (previous?.attempts ?? 0) + 1;
-    const firstStep = previous?.firstStep ?? step.step;
-    const content = proceduralContent(step.callDescription, attempts, firstStep, step.resultDigest);
-    let entryId;
-    if (previous === void 0) {
-      entryId = deps.bank.saveProcedural(content).id;
-    } else {
-      try {
-        entryId = deps.bank.saveProcedural(content, { id: previous.entryId }).id;
-      } catch {
-        entryId = deps.bank.saveProcedural(content).id;
+}
+
+// src/domains/middleware/index.ts
+init_esm_shims();
+
+// src/domains/middleware/extension.ts
+init_esm_shims();
+
+// src/domains/middleware/registrations.ts
+init_esm_shims();
+var MIDDLEWARE_REGISTRATION_OWNERS = ["user-hooks"];
+function isRegistrationOwner(value) {
+  return MIDDLEWARE_REGISTRATION_OWNERS.includes(value);
+}
+function createMiddlewareRegistrationTable(options) {
+  const fixed = Object.freeze([...options.fixed]);
+  const fixedIds = new Set(fixed.map((registration) => registration.id));
+  const buildList = (host, slots) => {
+    const list = [...fixed];
+    const slotAt = (index) => {
+      for (const owner of MIDDLEWARE_REGISTRATION_OWNERS) {
+        const slot = slots.get(owner);
+        if (slot !== void 0 && slot.anchor === index) list.push(...slot.registrations);
       }
+    };
+    for (let index = 0; index < host.length; index += 1) {
+      slotAt(index);
+      list.push(host[index]);
     }
-    setBounded(
-      failures,
-      step.operationFingerprint,
-      {
-        entryId,
-        attempts,
-        firstStep,
-        callDescription: step.callDescription,
-        errorDigest: step.resultDigest
-      },
-      TASK_MEMORY_DEFAULT_PROCEDURAL_CAP
-    );
-  }
-  function decideRepeatedFailure() {
+    slotAt(host.length);
+    return Object.freeze(list);
+  };
+  const makeState = (host, slots) => Object.freeze({
+    host: Object.freeze([...host]),
+    hostIds: new Set(host.map((registration) => registration.id)),
+    slots: new Map(slots),
+    list: buildList(host, slots)
+  });
+  let state = makeState([], /* @__PURE__ */ new Map());
+  const emit = (diagnostic) => {
     try {
-      for (let index = trajectory.length - 1; index >= 0; index -= 1) {
-        const step = trajectory[index];
-        if (step === void 0 || step.outcome !== "error" || step.step <= lastTurnEndStep || step.operationFingerprint === lastInjectedOperationFingerprint) {
+      options.diagnosticSink()(diagnostic);
+    } catch {
+    }
+  };
+  const slotFor = (base, owner) => base.slots.get(owner) ?? { generation: 0, registrations: [], anchor: base.host.length };
+  const disposeGeneration = (owner, generation) => {
+    const base = state;
+    const held = base.slots.get(owner);
+    if (held === void 0 || held.generation !== generation || held.registrations.length === 0) return;
+    const slots = new Map(base.slots);
+    slots.set(owner, { ...held, registrations: Object.freeze([]) });
+    state = makeState(base.host, slots);
+  };
+  const table = {
+    list: () => state.list,
+    registerHook(registration) {
+      const base = state;
+      if (fixedIds.has(registration.id) || base.hostIds.has(registration.id)) return;
+      const evictions = [];
+      const slots = new Map(base.slots);
+      for (const [owner, slot] of base.slots) {
+        if (!slot.registrations.some((entry) => entry.id === registration.id)) continue;
+        slots.set(owner, {
+          ...slot,
+          registrations: Object.freeze(slot.registrations.filter((entry) => entry.id !== registration.id))
+        });
+        evictions.push({
+          kind: "registration_conflict",
+          registrationId: registration.id,
+          owner,
+          generation: slot.generation,
+          conflictsWith: "host",
+          action: "evicted"
+        });
+      }
+      state = makeState([...base.host, registration], slots);
+      for (const eviction of evictions) emit(eviction);
+    },
+    prepareReplacement(owner, generation, registrations) {
+      if (!isRegistrationOwner(owner)) {
+        return { status: "rejected", owner, reason: "unknown-owner", activeGeneration: 0 };
+      }
+      const base = state;
+      const slot = slotFor(base, owner);
+      if (!Number.isInteger(generation) || generation <= slot.generation) {
+        return { status: "rejected", owner, reason: "stale", activeGeneration: slot.generation };
+      }
+      const dropped = [];
+      const conflicts = [];
+      const accepted = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const registration of registrations) {
+        const conflictsWith = fixedIds.has(registration.id) ? "builtin" : base.hostIds.has(registration.id) ? "host" : seen.has(registration.id) ? "owned" : null;
+        if (conflictsWith !== null) {
+          dropped.push({ id: registration.id, conflictsWith });
+          conflicts.push({
+            kind: "registration_conflict",
+            registrationId: registration.id,
+            owner,
+            generation,
+            conflictsWith,
+            action: "dropped"
+          });
           continue;
         }
-        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) continue;
-        const message = boundedReminder(
-          `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_EFFECTS3;
-        lastInjectedOperationFingerprint = step.operationFingerprint;
-        lastInjectedMessage = message;
-        lastDecision = "injected";
-        rulesInjectedSincePromptedStep = true;
-        deps.bank.recordInjection([failure.entryId]);
-        return [{ kind: "inject_reminder", message, severity: "advisory" }];
+        seen.add(registration.id);
+        accepted.push(registration);
       }
-      lastDecision = "silent";
-      return NO_EFFECTS3;
-    } finally {
-      lastTurnEndStep = toolStep;
-    }
-  }
-  function reactivateKnowledge() {
-    if (!reactivateAfterCompaction) return NO_EFFECTS3;
-    reactivateAfterCompaction = false;
-    const prefix = "Memory: execution state restored after compaction:\n";
-    const maxTokens = settings().maxTokens;
-    const prefixTokens = ceilChars(prefix.length);
-    const rendered = deps.bank.renderRestoredState(Math.max(0, maxTokens - prefixTokens));
-    if (rendered.length === 0) {
-      lastDecision = "silent";
-      return NO_EFFECTS3;
-    }
-    const message = boundedReminder(`${prefix}${rendered}`, maxTokens);
-    if (message.length === 0) {
-      lastDecision = "silent";
-      return NO_EFFECTS3;
+      const slots = new Map(base.slots);
+      slots.set(owner, { generation, registrations: Object.freeze(accepted), anchor: slot.anchor });
+      const prepared = makeState(base.host, slots);
+      let settled = false;
+      const frozenDropped = Object.freeze(dropped);
+      const frozenConflicts = Object.freeze(conflicts);
+      const replacement = {
+        owner,
+        generation,
+        dropped: frozenDropped,
+        conflicts: frozenConflicts,
+        size: accepted.length,
+        // Reference identity on the base state covers every kind of
+        // intervening change: host appends, other replacements, disposals.
+        current: () => !settled && state === base,
+        publish() {
+          settled = true;
+          state = prepared;
+        },
+        emitConflicts() {
+          for (const conflict of frozenConflicts) emit(conflict);
+        },
+        dispose() {
+          disposeGeneration(owner, generation);
+        },
+        discard() {
+          settled = true;
+        }
+      };
+      return { status: "prepared", replacement };
+    },
+    replaceRegistrations(owner, generation, registrations) {
+      const prepared = table.prepareReplacement(owner, generation, registrations);
+      if (prepared.status === "rejected") {
+        return {
+          applied: false,
+          owner: prepared.owner,
+          activeGeneration: prepared.activeGeneration,
+          reason: prepared.reason,
+          dropped: [],
+          dispose: () => void 0
+        };
+      }
+      const replacement = prepared.replacement;
+      if (!replacement.current()) {
+        replacement.discard();
+        return {
+          applied: false,
+          owner,
+          activeGeneration: table.ownedGeneration(owner),
+          reason: "stale",
+          dropped: replacement.dropped,
+          dispose: () => void 0
+        };
+      }
+      replacement.publish();
+      replacement.emitConflicts();
+      return {
+        applied: true,
+        owner,
+        activeGeneration: generation,
+        dropped: replacement.dropped,
+        dispose: () => replacement.dispose()
+      };
+    },
+    ownedGeneration(owner) {
+      return state.slots.get(owner)?.generation ?? 0;
     }
-    const citedIds = [...message.matchAll(/\[([^\]]+)\]/gu)].map((match) => match[1]).filter((id) => id !== void 0);
-    deps.bank.recordInjection(citedIds);
-    lastInjectedMessage = message;
-    lastDecision = "injected";
-    return [{ kind: "inject_reminder", message, severity: "advisory" }];
-  }
+  };
+  return table;
 }
-function prepareToolStep(input) {
-  const toolName = input.toolName?.trim();
-  if (!toolName) return null;
-  const canonical = hashToolCall(toolName, input.toolArgs ?? {});
+
+// src/domains/middleware/snapshot.ts
+init_esm_shims();
+function createMiddlewareSnapshot(rules = listMiddlewareRules()) {
   return {
-    toolName,
-    operationFingerprint: createHash2("sha256").update(canonical).digest("hex").slice(0, 16),
-    callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS)
+    version: 1,
+    rules: rules.map(cloneMiddlewareRule)
   };
 }
-function pendingKey(input, operationFingerprint) {
-  return input.toolCallId ?? `anonymous:${operationFingerprint}`;
-}
-function resultDigest(input, outcome) {
-  if (input.toolResultDigest !== void 0) return sanitizeToolResultDigest(input.toolResultDigest);
-  if (outcome === "error") {
-    const metadataMessage = input.metadata?.errorMessage;
-    if (typeof metadataMessage === "string" && metadataMessage.trim().length > 0) {
-      return legacyToolResultDigest(diagnosticLine(metadataMessage), { outcome });
-    }
-    for (const key of ["error", "message"]) {
-      const value = input.toolResultDetails?.[key];
-      if (typeof value === "string" && value.trim().length > 0) {
-        return legacyToolResultDigest(diagnosticLine(value), { outcome });
-      }
+function createMiddlewareContractFromSnapshot(snapshot) {
+  const builtinById = new Map(listMiddlewareRuleDefinitions().map((definition) => [definition.rule.id, definition]));
+  const definitions = snapshot.rules.map((rule) => {
+    const builtin = builtinById.get(rule.id);
+    const definition = {
+      rule: cloneMiddlewareRule(rule),
+      effects: builtin === void 0 ? [] : builtin.effects.map(cloneMiddlewareEffect)
+    };
+    if (builtin?.toolNames !== void 0) definition.toolNames = [...builtin.toolNames];
+    if (builtin?.predicate !== void 0) definition.predicate = builtin.predicate;
+    return definition;
+  });
+  let diagnosticSink;
+  const table = createMiddlewareRegistrationTable({
+    fixed: definitions.map(registrationFromRuleDefinition),
+    diagnosticSink: () => diagnosticSink ?? writeMiddlewareDiagnosticToStderr
+  });
+  const budgetTracker = createHookBudgetTracker({
+    budgets: resolveHookBudgetsFromEnv(),
+    ...resolveHookBudgetTunablesFromEnv()
+  });
+  return {
+    runHook(input) {
+      const registrations = table.list();
+      return runMiddlewareRegistrations(input, registrations, {
+        budgetTracker,
+        ...diagnosticSink !== void 0 ? { onDiagnostic: diagnosticSink } : {}
+      });
+    },
+    listRules() {
+      return definitions.map((definition) => cloneMiddlewareRule(definition.rule));
+    },
+    snapshot() {
+      return createMiddlewareSnapshot(definitions.map((definition) => definition.rule));
+    },
+    registerHook(registration) {
+      table.registerHook(registration);
+    },
+    setDiagnosticSink(sink) {
+      diagnosticSink = sink;
+    },
+    prepareRegistrationReplacement(owner, generation, registrations) {
+      return table.prepareReplacement(owner, generation, registrations);
+    },
+    replaceRegistrations(owner, generation, registrations) {
+      return table.replaceRegistrations(owner, generation, registrations);
+    },
+    ownedGeneration(owner) {
+      return table.ownedGeneration(owner);
     }
-    return legacyToolResultDigest("", { outcome });
-  }
-  const resultFingerprint = input.metadata?.resultFingerprint;
-  return legacyToolResultDigest(
-    typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok",
-    { outcome }
-  );
-}
-var DIAGNOSTIC_HINT = /\b(error|failed|failure|cannot|unable|expected|refused|denied|missing|not found|timed out|timeout|fatal)\b/iu;
-function diagnosticLine(value) {
-  const lines = value.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
-  return lines.find((line) => DIAGNOSTIC_HINT.test(line)) ?? lines[0] ?? "";
-}
-function proceduralContent(call, attempts, firstStep, error) {
-  return `${call} failed ${attempts} time${attempts === 1 ? "" : "s"}; first observed at step ${firstStep}: ${error}.`;
-}
-function boundedReminder(message, maxTokens) {
-  const maxChars = maxTokens * 4;
-  if (maxChars <= 0) return "";
-  const normalized = message.replace(/[^\S\n]+/gu, " ").trim();
-  return normalized.length <= maxChars ? normalized : normalized.slice(0, maxChars).trimEnd();
-}
-function shortText(value, maxChars) {
-  const normalized = value.replace(/\s+/gu, " ").trim();
-  return normalized.length <= maxChars ? normalized : `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+  };
 }
-function positiveInteger(value, fallback) {
-  return value !== void 0 && Number.isInteger(value) && value > 0 ? value : fallback;
+
+// src/domains/middleware/extension.ts
+function createEnvHookBudgetTracker(env = process.env) {
+  return createHookBudgetTracker({ budgets: resolveHookBudgetsFromEnv(env), ...resolveHookBudgetTunablesFromEnv(env) });
 }
-function countBankWrites(delta) {
-  return [delta.status, delta.knowledge, delta.procedural].reduce(
-    (total, entry) => total + entry.added + entry.updated + entry.deleted,
-    0
-  );
+function createMiddlewareBundle(options = {}) {
+  const ruleDefinitions = combineRuleDefinitions(listMiddlewareRuleDefinitions(), options.ruleDefinitions ?? []);
+  let diagnosticSink = options.onDiagnostic;
+  const table = createMiddlewareRegistrationTable({
+    fixed: ruleDefinitions.map(registrationFromRuleDefinition),
+    diagnosticSink: () => diagnosticSink ?? writeMiddlewareDiagnosticToStderr
+  });
+  for (const registration of options.registrations ?? []) table.registerHook(registration);
+  const budgetTracker = options.budgetTracker ?? createEnvHookBudgetTracker();
+  const contract = {
+    runHook(input) {
+      const registrations = table.list();
+      return runMiddlewareRegistrations(input, registrations, {
+        budgetTracker,
+        ...diagnosticSink !== void 0 ? { onDiagnostic: diagnosticSink } : {}
+      });
+    },
+    runAsyncHook(input, priorEffects = []) {
+      const registrations = table.list();
+      return runMiddlewareAsyncRegistrations(input, registrations, priorEffects, {
+        ...diagnosticSink !== void 0 ? { onDiagnostic: diagnosticSink } : {}
+      });
+    },
+    listRules() {
+      return ruleDefinitions.map((definition) => cloneMiddlewareRule(definition.rule));
+    },
+    snapshot() {
+      return createMiddlewareSnapshot(ruleDefinitions.map((definition) => definition.rule));
+    },
+    registerHook(registration) {
+      table.registerHook(registration);
+    },
+    setDiagnosticSink(sink) {
+      diagnosticSink = sink;
+    },
+    prepareRegistrationReplacement(owner, generation, registrations) {
+      return table.prepareReplacement(owner, generation, registrations);
+    },
+    replaceRegistrations(owner, generation, registrations) {
+      return table.replaceRegistrations(owner, generation, registrations);
+    },
+    ownedGeneration(owner) {
+      return table.ownedGeneration(owner);
+    }
+  };
+  return {
+    extension: {
+      start() {
+        return void 0;
+      }
+    },
+    contract
+  };
 }
-function setBounded(map, key, value, capacity) {
-  if (!map.has(key) && map.size >= capacity) {
-    const oldest = map.keys().next().value;
-    if (oldest !== void 0) map.delete(oldest);
+function combineRuleDefinitions(builtin, registered) {
+  const seen = /* @__PURE__ */ new Set();
+  const combined = [];
+  for (const definition of [...builtin, ...registered]) {
+    if (seen.has(definition.rule.id)) continue;
+    seen.add(definition.rule.id);
+    combined.push(definition);
   }
-  map.set(key, value);
+  return combined;
 }
 
-// src/domains/middleware/memory-step-endpoint.ts
+// src/domains/middleware/manifest.ts
 init_esm_shims();
-function announceMemoryStepEndpoint(deps, complete) {
-  const { bus, endpointKey, targetId } = deps;
-  if (endpointKey === null) return complete;
-  return async (request) => {
-    const releaseEndpointSlot = registerForegroundStream(endpointKey);
-    try {
-      return await complete(request);
-    } finally {
-      releaseEndpointSlot();
-      if (bus !== null) {
-        try {
-          bus.emit(BusChannels.MemoryStepCompleted, { endpointKey, targetId });
-        } catch {
-        }
-      }
-    }
-  };
-}
+var MiddlewareManifest = {
+  name: "middleware",
+  dependsOn: []
+};
 
-// src/domains/middleware/task-board-reminder.ts
+// src/domains/middleware/hooks.ts
 init_esm_shims();
-var TASK_BOARD_REMINDER_REGISTRATION_ID = "observer.task-board-reminder";
-function taskBoardReminderMessage(steps) {
-  return `[Tasks] This request enumerates ${steps} steps. Before the first edit, declare the task board: tasks action="plan" with a title and one task per step, then work them one at a time ("start", then "done" with an evidence note).`;
+import { createHash as createHash2 } from "node:crypto";
+import { isAbsolute, resolve } from "node:path";
+
+// src/domains/middleware/validate.ts
+init_esm_shims();
+function validateMiddlewareEffect(value, source = "$") {
+  const issues = [];
+  const effect = readMiddlewareEffect(value, source, issues);
+  if (issues.length > 0 || effect === null) return { valid: false, issues };
+  return { valid: true, effect, issues: [] };
 }
-function countEnumeratedSteps(text) {
-  const value = text ?? "";
-  if (value.trim().length === 0) return 0;
-  const markers = [];
-  const markerPattern = /(?:^|[\s(])(?:step\s+)?([1-9])\s*[).:]\s/gi;
-  let match = markerPattern.exec(value);
-  while (match !== null) {
-    const digit = Number(match[1]);
-    if (Number.isInteger(digit)) markers.push(digit);
-    match = markerPattern.exec(value);
+function readMiddlewareEffect(value, path2, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path: path2, message: "expected middleware effect object" });
+    return null;
   }
-  let run = 0;
-  for (const digit of markers) {
-    if (digit === run + 1) run += 1;
-    else if (digit === 1) run = 1;
+  const kindValue = value.kind;
+  if (typeof kindValue !== "string" || !isMiddlewareEffectKind(kindValue)) {
+    issues.push({ path: `${path2}.kind`, message: "expected known middleware effect kind" });
+    return null;
+  }
+  switch (kindValue) {
+    case "inject_reminder":
+      return readInjectReminder(value, path2, issues);
+    case "annotate_tool_result":
+      return readAnnotateToolResult(value, path2, issues);
+    case "block_tool":
+      return readBlockTool(value, path2, issues);
+    case "protect_path":
+      return readProtectPath(value, path2, issues);
+    case "request_continuation":
+      return readRequestContinuation(value, path2, issues);
+    case "require_tool":
+      return readRequireTool(value, path2, issues);
+    case "lock_tools":
+      rejectUnexpectedFields(value, path2, ["kind"], issues);
+      return { kind: "lock_tools" };
   }
-  if (run >= 3) return run;
-  const bulletLines = value.split(/\r?\n/).filter((line) => /^\s*[-*]\s+\S/.test(line)).length;
-  return bulletLines >= 3 ? bulletLines : 0;
 }
-var NO_EFFECTS4 = [];
-function createTaskBoardReminderRegistration() {
-  let lastSeenSessionId;
-  let spentForActiveSession = false;
-  return {
-    id: TASK_BOARD_REMINDER_REGISTRATION_ID,
-    description: "once per session, on the first explicitly enumerated multi-step turn, teaches the board-first protocol",
-    hooks: ["turn_start"],
-    evaluate(input) {
-      const sessionId = input.sessionId ?? null;
-      if (lastSeenSessionId === void 0 || lastSeenSessionId === null && sessionId !== null) {
-        lastSeenSessionId = sessionId;
-      } else if (sessionId !== lastSeenSessionId) {
-        lastSeenSessionId = sessionId;
-        spentForActiveSession = false;
-      }
-      if (spentForActiveSession) return NO_EFFECTS4;
-      const steps = countEnumeratedSteps(input.text);
-      if (steps < 3) return NO_EFFECTS4;
-      spentForActiveSession = true;
-      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
-      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS4;
-      return [{ kind: "inject_reminder", severity: "info", message: taskBoardReminderMessage(steps) }];
-    }
-  };
+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 };
 }
-
-// src/domains/middleware/task-nudge.ts
-init_esm_shims();
-var TASK_NUDGE_REGISTRATION_ID = "nudge.open-tasks";
-function openTasks(board) {
-  return board.tasks.filter((task) => task.status === "pending" || task.status === "active");
+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: `${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 buildOpenTasksMessage(board) {
-  const open = openTasks(board);
-  const counts = taskBoardCounts(board);
-  const rows = open.map((task) => `  ${task.status === "active" ? "[>]" : "[ ]"} ${task.id} ${task.title}`);
-  return `[Clio Coder] task board "${board.title}" still has ${open.length} of ${counts.total} task(s) open:
-${rows.join("\n")}
-Continue working them, or record the honest state on the board: tasks action="done" with an evidence note, action="block" with a reason, or action="drop". Do not end the turn with a stale board.`;
+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: `${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 createTaskNudgeRegistration(options) {
-  return {
-    id: TASK_NUDGE_REGISTRATION_ID,
-    description: "carry the turn onward when a work turn ends with open task-board tasks",
-    hooks: ["turn_end"],
-    evaluate(input) {
-      if (input.hook !== "turn_end") return [];
-      const stopReason = input.metadata?.stopReason;
-      if (stopReason !== void 0 && stopReason !== "stop") return [];
-      const turnToolCalls = input.metadata?.turnToolCalls;
-      if (typeof turnToolCalls !== "number" || turnToolCalls <= 0) return [];
-      const activeToolNames = input.metadata?.activeToolNames;
-      if (typeof activeToolNames === "string" && !activeToolNames.split(",").includes(ToolNames.Tasks)) return [];
-      let board;
-      try {
-        board = options.getBoard();
-      } catch {
-        return [];
-      }
-      if (board === null || openTasks(board).length === 0) return [];
-      const message = buildOpenTasksMessage(board);
-      return [
-        { kind: "request_continuation", message },
-        { kind: "inject_reminder", message, severity: "warn" }
-      ];
-    }
-  };
+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: `${path2}.severity`, message: "expected hard-block" });
+  }
+  if (reason === null || severity !== "hard-block") return null;
+  return { kind: "block_tool", reason, severity };
 }
-
-// src/domains/middleware/tool-choice-control.ts
-init_esm_shims();
-function createMiddlewareToolChoiceControl() {
-  let choice = { kind: "auto" };
-  return {
-    apply(effects) {
-      for (const effect of effects) {
-        if (effect.kind === "lock_tools") {
-          choice = { kind: "none" };
-          continue;
-        }
-        if (effect.kind === "require_tool" && choice.kind !== "none") {
-          choice = { kind: "required", toolName: effect.toolName };
-        }
-      }
-    },
-    current: () => choice,
-    toolStarted(toolName) {
-      if (choice.kind === "required" && choice.toolName === toolName) choice = { kind: "auto" };
-    },
-    reset() {
-      choice = { kind: "auto" };
-    }
-  };
+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, 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, path2, issues) {
+  const value = record[pathField(path2)];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push({ path: path2, message: "expected non-empty string" });
+    return null;
+  }
+  return value;
+}
+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: path2, message: "expected non-empty string" });
+    return void 0;
+  }
+  return value;
+}
+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: `${path2}.${field}`, message: "unexpected field" });
+  }
+}
+function pathField(path2) {
+  return path2.slice(path2.lastIndexOf(".") + 1);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/domains/middleware/watchdog.ts
-init_esm_shims();
-var WATCHDOG_REGISTRATION_ID = "observer.watchdog";
-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_EFFECTS5 = [];
-function stringValue2(value) {
-  return typeof value === "string" && value.length > 0 ? value : null;
+// src/domains/middleware/hooks.ts
+var USER_HOOK_ORIGIN_ORDER = ["extension", "user", "project", "project.local"];
+var USER_HOOK_COMMAND_TIMEOUT_DEFAULT_MS = 2e3;
+var USER_HOOK_COMMAND_TIMEOUT_MIN_MS = 100;
+var USER_HOOK_COMMAND_TIMEOUT_MAX_MS = 5e3;
+var USER_HOOK_COMMAND_OUTPUT_MAX_CHARS = 4e3;
+var USER_HOOK_PROMPT_MAX_CHARS = 2e3;
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function firstPath(details) {
-  const paths = details?.paths;
-  if (!Array.isArray(paths)) return null;
-  for (const entry of paths) {
-    const path2 = stringValue2(entry);
-    if (path2 !== null) return path2;
-  }
-  return null;
+function stableHash(value) {
+  return createHash2("sha256").update(canonicalJson(value)).digest("hex").slice(0, 16);
 }
-function coalesceTurnDiff(byPath, maxBytes = WATCHDOG_DIFF_MAX_BYTES) {
-  const blocks = [];
-  let index = 0;
-  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(`--- ${path2}
-${diff}`);
-    index += 1;
-  }
-  const whole = blocks.join("\n\n");
-  if (Buffer.byteLength(whole, "utf8") <= maxBytes) return whole;
-  const room = Math.max(0, maxBytes - Buffer.byteLength(WATCHDOG_TRUNCATION_MARKER, "utf8"));
-  const buffer = Buffer.from(whole, "utf8");
-  let cut = Math.min(room, buffer.byteLength);
-  while (cut > 0) {
-    const next = buffer[cut];
-    if (next === void 0 || (next & 192) !== 128) break;
-    cut -= 1;
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isRecord2(value)) {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
   }
-  return `${buffer.subarray(0, cut).toString("utf8")}${WATCHDOG_TRUNCATION_MARKER}`;
+  return JSON.stringify(value) ?? "null";
 }
-var WATCHDOG_TASK = "Review the coalesced diff in the briefing against the scope it names. Report one check per concern: a change outside the stated scope, a change the scope required that the diff does not make, or a defect visible in the diff itself. Run no commands and change nothing.";
-function watchdogBriefing(trigger) {
-  const scope = trigger.scope === null ? "(no task board; scope is unstated)" : trigger.scope;
-  const paths = trigger.paths.length === 0 ? "(none)" : trigger.paths.join("\n");
-  return [
-    "## Current scope",
-    scope,
-    "",
-    "## Changed paths",
-    paths,
-    "",
-    "## Coalesced diff for this turn",
-    trigger.diff
-  ].join("\n");
+function readStringArray(value) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.length === 0) return null;
+    out.push(item);
+  }
+  return out;
 }
-function createWatchdogRegistration(deps) {
-  const diffByPath = /* @__PURE__ */ new Map();
-  let toolCalls = 0;
-  let dropped = 0;
-  let inFlight = false;
-  let outstanding = Promise.resolve();
-  const active = () => {
-    if (deps.firesOnThisSurface === false) return null;
-    let settings;
-    try {
-      settings = deps.getSettings();
-    } catch {
+function normalizeCommandSpec(raw, options, issues) {
+  const argv = readStringArray(raw.argv);
+  if (!argv || argv.length === 0) {
+    issues.push("command.argv must be a non-empty array of non-empty strings");
+    return null;
+  }
+  const spec = {
+    kind: "command",
+    argv,
+    cwd: resolve(options.workspaceRoot),
+    timeoutMs: USER_HOOK_COMMAND_TIMEOUT_DEFAULT_MS,
+    as: "annotate"
+  };
+  if (raw.cwd !== void 0) {
+    if (typeof raw.cwd !== "string" || raw.cwd.length === 0) {
+      issues.push("command.cwd must be a non-empty string");
       return null;
     }
-    return settings.enabled ? settings : null;
-  };
-  const resetTurn = () => {
-    diffByPath.clear();
-    toolCalls = 0;
-  };
-  const fire = (reason) => {
-    if (diffByPath.size === 0) return;
-    if (inFlight) {
-      dropped += 1;
-      return;
+    const resolved = isAbsolute(raw.cwd) ? resolve(raw.cwd) : resolve(options.workspaceRoot, raw.cwd);
+    if (!isWithin(resolved, options.workspaceRoot)) {
+      issues.push("command.cwd must resolve under the workspace root");
+      return null;
     }
-    const trigger = {
-      reason,
-      diff: coalesceTurnDiff(diffByPath),
-      paths: [...diffByPath.keys()].slice(0, WATCHDOG_PATHS_MAX),
-      scope: scopeNow(),
-      toolCalls
-    };
-    inFlight = true;
-    let started;
-    try {
-      started = deps.run(trigger);
-    } catch {
-      inFlight = false;
-      return;
+    spec.cwd = resolved;
+  }
+  if (raw.timeoutMs !== void 0) {
+    if (typeof raw.timeoutMs !== "number" || !Number.isFinite(raw.timeoutMs)) {
+      issues.push("command.timeoutMs must be a number");
+      return null;
     }
-    outstanding = started.catch(() => {
-    }).finally(() => {
-      inFlight = false;
-    });
-  };
-  const scopeNow = () => {
-    try {
-      return deps.getScope?.() ?? null;
-    } catch {
+    spec.timeoutMs = Math.min(
+      USER_HOOK_COMMAND_TIMEOUT_MAX_MS,
+      Math.max(USER_HOOK_COMMAND_TIMEOUT_MIN_MS, Math.floor(raw.timeoutMs))
+    );
+  }
+  if (raw.as !== void 0) {
+    if (raw.as !== "annotate" && raw.as !== "reminder") {
+      issues.push('command.as must be "annotate" or "reminder"');
       return null;
     }
-  };
-  return {
-    id: WATCHDOG_REGISTRATION_ID,
-    description: "review a mutating turn's coalesced diff against the board scope with a read-only verifier run",
-    hooks: ["after_tool", "turn_end"],
-    evaluate(input) {
-      const settings = active();
-      if (settings === null) {
-        if (input.hook === "turn_end") resetTurn();
-        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_EFFECTS5;
+    spec.as = raw.as;
+  }
+  return spec;
+}
+function normalizePromptSpec(raw, issues) {
+  if (typeof raw.message !== "string" || raw.message.trim().length === 0) {
+    issues.push("prompt.message must be a non-empty string");
+    return null;
+  }
+  let severity = "info";
+  if (raw.severity !== void 0) {
+    if (typeof raw.severity !== "string" || !isMiddlewareReminderSeverity(raw.severity)) {
+      issues.push("prompt.severity must be info, advisory, warn, or hard-block");
+      return null;
+    }
+    severity = raw.severity;
+  }
+  return { kind: "prompt", message: raw.message.slice(0, USER_HOOK_PROMPT_MAX_CHARS), severity };
+}
+function normalizeEffectSpec(raw, issues) {
+  const result = validateMiddlewareEffect(raw.effect ?? raw, "effect");
+  if (!result.valid) {
+    for (const issue of result.issues) issues.push(`effect: ${issue.message}`);
+    return null;
+  }
+  return { kind: "effect", effect: result.effect };
+}
+function isWithin(child, parent) {
+  const rel = resolve(child);
+  const base = resolve(parent);
+  return rel === base || rel.startsWith(`${base}/`);
+}
+function normalizeUserHook(raw, source, options) {
+  const issues = [];
+  if (!isRecord2(raw)) {
+    return { issues: ["hook declaration must be an object"] };
+  }
+  if (raw.on === void 0 || typeof raw.on !== "string" || !isMiddlewareHook(raw.on)) {
+    issues.push("on must be one of before_tool, after_tool, turn_start, turn_end, on_compaction");
+  }
+  let tools;
+  if (raw.tools !== void 0) {
+    const parsed = readStringArray(raw.tools);
+    if (!parsed) issues.push("tools must be an array of non-empty tool names");
+    else tools = parsed;
+  }
+  let enabled = true;
+  if (raw.enabled !== void 0) {
+    if (typeof raw.enabled !== "boolean") issues.push("enabled must be a boolean");
+    else enabled = raw.enabled;
+  }
+  let spec = null;
+  if (raw.kind === "command") spec = normalizeCommandSpec(raw, options, issues);
+  else if (raw.kind === "prompt") spec = normalizePromptSpec(raw, issues);
+  else if (raw.kind === "effect") spec = normalizeEffectSpec(raw, issues);
+  else issues.push('kind must be "command", "prompt", or "effect"');
+  if (issues.length > 0 || spec === null || raw.on === void 0 || typeof raw.on !== "string") {
+    return { issues };
+  }
+  const on = raw.on;
+  const hash = stableHash({ on, tools: tools ?? null, spec });
+  const id = typeof raw.id === "string" && raw.id.length > 0 ? raw.id : `${source.sourceId ?? source.origin}.${spec.kind}.${hash}`;
+  const hook = { id, source, hash, on, enabled, spec };
+  if (tools !== void 0) hook.tools = tools;
+  return { hook, issues };
+}
+function declarationsArray(declarations) {
+  if (Array.isArray(declarations)) return declarations;
+  if (isRecord2(declarations) && Array.isArray(declarations.hooks)) return declarations.hooks;
+  return [];
+}
+function loadUserHooks(batches, options) {
+  const ordered = [...batches].sort(
+    (a, b) => USER_HOOK_ORIGIN_ORDER.indexOf(a.source.origin) - USER_HOOK_ORIGIN_ORDER.indexOf(b.source.origin)
+  );
+  const byId = /* @__PURE__ */ new Map();
+  const overridden = [];
+  const issues = [];
+  for (const batch of ordered) {
+    const declarations = declarationsArray(batch.declarations);
+    declarations.forEach((raw, index) => {
+      const result = normalizeUserHook(raw, batch.source, options);
+      if (!result.hook) {
+        issues.push({ source: batch.source, index, issues: result.issues });
+        return;
       }
-      if (input.hook !== "turn_end") return NO_EFFECTS5;
-      fire("turn_end");
-      resetTurn();
-      return NO_EFFECTS5;
-    },
-    droppedTriggers: () => dropped,
-    runInFlight: () => inFlight,
-    whenIdle: () => outstanding
-  };
-  function recordMutation(input) {
-    if (input.metadata?.resultKind !== "ok") return;
-    if (input.toolName === void 0 || !MUTATING_TOOL_NAMES.has(input.toolName)) return;
-    const diff = stringValue2(input.toolResultDetails?.diff);
-    if (diff === null) return;
-    diffByPath.set(firstPath(input.toolResultDetails) ?? input.toolName, diff);
+      const existing = byId.get(result.hook.id);
+      if (existing) overridden.push({ winner: batch.source, loser: existing });
+      byId.set(result.hook.id, result.hook);
+    });
   }
+  return { hooks: [...byId.values()], overridden, issues };
 }
-
-// src/domains/middleware/index.ts
-init_esm_shims();
-
-// src/domains/middleware/extension.ts
-init_esm_shims();
-
-// src/domains/middleware/snapshot.ts
-init_esm_shims();
-function createMiddlewareSnapshot(rules = listMiddlewareRules()) {
-  return {
-    version: 1,
-    rules: rules.map(cloneMiddlewareRule)
-  };
+function reminderEffect(message, severity) {
+  return severity === "info" ? { kind: "inject_reminder", message } : { kind: "inject_reminder", message, severity };
 }
-function createMiddlewareContractFromSnapshot(snapshot) {
-  const builtinById = new Map(listMiddlewareRuleDefinitions().map((definition) => [definition.rule.id, definition]));
-  const definitions = snapshot.rules.map((rule) => {
-    const builtin = builtinById.get(rule.id);
-    const definition = {
-      rule: cloneMiddlewareRule(rule),
-      effects: builtin === void 0 ? [] : builtin.effects.map(cloneMiddlewareEffect)
-    };
-    if (builtin?.toolNames !== void 0) definition.toolNames = [...builtin.toolNames];
-    if (builtin?.predicate !== void 0) definition.predicate = builtin.predicate;
-    return definition;
-  });
-  const registrations = definitions.map(registrationFromRuleDefinition);
-  const registeredIds = new Set(registrations.map((registration) => registration.id));
-  const budgetTracker = createHookBudgetTracker({
-    budgets: resolveHookBudgetsFromEnv(),
-    ...resolveHookBudgetTunablesFromEnv()
+function commandEffect(hook, output) {
+  const message = output.slice(0, USER_HOOK_COMMAND_OUTPUT_MAX_CHARS);
+  return hook.as === "reminder" ? { kind: "inject_reminder", message } : { kind: "annotate_tool_result", message };
+}
+function userHookToRegistration(hook, deps) {
+  const now = deps.now ?? Date.now;
+  const extension = hook.source.extension === void 0 ? void 0 : receiptExtension(hook.source.extension);
+  const baseReceipt = (input) => ({
+    at: now(),
+    hookId: hook.id,
+    origin: hook.source.origin,
+    sourcePath: hook.source.sourcePath,
+    hash: hook.hash,
+    hook: hook.on,
+    kind: hook.spec.kind,
+    ...extension !== void 0 ? { extension: { ...extension } } : {},
+    ...input.toolName !== void 0 ? { toolName: input.toolName } : {}
   });
-  let diagnosticSink;
-  return {
-    runHook(input) {
-      return runMiddlewareRegistrations(input, registrations, {
-        budgetTracker,
-        ...diagnosticSink !== void 0 ? { onDiagnostic: diagnosticSink } : {}
-      });
-    },
-    listRules() {
-      return definitions.map((definition) => cloneMiddlewareRule(definition.rule));
-    },
-    snapshot() {
-      return createMiddlewareSnapshot(definitions.map((definition) => definition.rule));
-    },
-    registerHook(registration) {
-      if (registeredIds.has(registration.id)) return;
-      registeredIds.add(registration.id);
-      registrations.push(registration);
-    },
-    setDiagnosticSink(sink) {
-      diagnosticSink = sink;
+  const registration = {
+    id: hook.id,
+    description: `${hook.spec.kind} hook from ${hook.source.origin} (${hook.source.sourcePath})`,
+    hooks: [hook.on],
+    evaluate: (input) => {
+      if (!hook.enabled) return [];
+      try {
+        return evaluateHook(hook, deps, baseReceipt(input));
+      } catch {
+        deps.recordReceipt({ ...baseReceipt(input), outcome: "skipped" });
+        return [];
+      }
     }
   };
+  if (hook.tools !== void 0) registration.toolNames = [...hook.tools];
+  return registration;
 }
-
-// src/domains/middleware/extension.ts
-function createEnvHookBudgetTracker(env = process.env) {
-  return createHookBudgetTracker({ budgets: resolveHookBudgetsFromEnv(env), ...resolveHookBudgetTunablesFromEnv(env) });
-}
-function createMiddlewareBundle(options = {}) {
-  const ruleDefinitions = combineRuleDefinitions(listMiddlewareRuleDefinitions(), options.ruleDefinitions ?? []);
-  const registrations = combineRegistrations(ruleDefinitions, options.registrations ?? []);
-  const registeredIds = new Set(registrations.map((registration) => registration.id));
-  let diagnosticSink = options.onDiagnostic;
-  const budgetTracker = options.budgetTracker ?? createEnvHookBudgetTracker();
-  const contract = {
-    runHook(input) {
-      return runMiddlewareRegistrations(input, registrations, {
-        budgetTracker,
-        ...diagnosticSink !== void 0 ? { onDiagnostic: diagnosticSink } : {}
-      });
-    },
-    runAsyncHook(input, priorEffects = []) {
-      return runMiddlewareAsyncRegistrations(input, registrations, priorEffects, {
-        ...diagnosticSink !== void 0 ? { onDiagnostic: diagnosticSink } : {}
-      });
-    },
-    listRules() {
-      return ruleDefinitions.map((definition) => cloneMiddlewareRule(definition.rule));
-    },
-    snapshot() {
-      return createMiddlewareSnapshot(ruleDefinitions.map((definition) => definition.rule));
-    },
-    registerHook(registration) {
-      if (registeredIds.has(registration.id)) return;
-      registeredIds.add(registration.id);
-      registrations.push(registration);
-    },
-    setDiagnosticSink(sink) {
-      diagnosticSink = sink;
-    }
-  };
+function receiptExtension(source) {
   return {
-    extension: {
-      start() {
-        return void 0;
-      }
-    },
-    contract
+    id: source.provenance.id,
+    scope: source.provenance.scope,
+    canonicalRoot: source.provenance.canonicalRoot,
+    manifestDigest: source.provenance.manifestDigest,
+    contentDigest: source.provenance.contentDigest,
+    declarationsDigest: source.declarationsDigest,
+    generation: source.generation
   };
 }
-function combineRuleDefinitions(builtin, registered) {
-  const seen = /* @__PURE__ */ new Set();
-  const combined = [];
-  for (const definition of [...builtin, ...registered]) {
-    if (seen.has(definition.rule.id)) continue;
-    seen.add(definition.rule.id);
-    combined.push(definition);
+function evaluateHook(hook, deps, base) {
+  if (hook.spec.kind === "prompt") {
+    const effect2 = reminderEffect(hook.spec.message, hook.spec.severity);
+    deps.recordReceipt({ ...base, outcome: "emitted", effectKinds: ["inject_reminder"] });
+    return [effect2];
   }
-  return combined;
-}
-function combineRegistrations(ruleDefinitions, coded) {
-  const seen = new Set(ruleDefinitions.map((definition) => definition.rule.id));
-  const combined = ruleDefinitions.map(registrationFromRuleDefinition);
-  for (const registration of coded) {
-    if (seen.has(registration.id)) continue;
-    seen.add(registration.id);
-    combined.push(registration);
+  if (hook.spec.kind === "effect") {
+    deps.recordReceipt({ ...base, outcome: "emitted", effectKinds: [hook.spec.effect.kind] });
+    return [hook.spec.effect];
   }
-  return combined;
+  const result = deps.runCommand(hook.spec.argv, {
+    timeoutMs: hook.spec.timeoutMs,
+    ...hook.spec.cwd !== void 0 ? { cwd: hook.spec.cwd } : {}
+  });
+  const output = (result.stdout || result.stderr || "").trim();
+  if (result.timedOut) {
+    deps.recordReceipt({ ...base, outcome: "command-timeout", exitCode: result.code ?? -1, outputChars: output.length });
+    return [];
+  }
+  const outcome = result.code === 0 ? "command-ok" : "command-failed";
+  deps.recordReceipt({ ...base, outcome, exitCode: result.code ?? -1, outputChars: output.length });
+  if (output.length === 0) return [];
+  const effect = commandEffect(hook.spec, output);
+  return [effect];
 }
 
-// src/domains/middleware/manifest.ts
+// src/domains/middleware/hooks-io.ts
 init_esm_shims();
-var MiddlewareManifest = {
-  name: "middleware",
-  dependsOn: []
-};
+var import_yaml = __toESM(require_dist(), 1);
+import { spawnSync } from "node:child_process";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join } from "node:path";
+var COMMAND_OUTPUT_MAX_BYTES = 1024 * 1024;
+function readBatch(source, filePath, fileIssues) {
+  let text;
+  try {
+    text = readFileSync3(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = (0, import_yaml.parse)(text);
+    return { source, declarations: parsed ?? [] };
+  } catch (err) {
+    fileIssues.push({
+      source,
+      message: `failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return null;
+  }
+}
+function readHookSources(options) {
+  const fileIssues = [];
+  const batches = [];
+  const captured = options.capturedSources;
+  for (const entry of captured?.sources ?? []) {
+    const source = {
+      origin: "extension",
+      sourcePath: `${entry.provenance.id}:hooks.yaml`,
+      sourceId: entry.provenance.id,
+      extension: {
+        provenance: entry.provenance,
+        generation: captured?.generation ?? 0,
+        declarationsDigest: entry.declarationsDigest
+      }
+    };
+    if (entry.parseError !== void 0) {
+      fileIssues.push({ source, message: `failed to parse ${source.sourcePath}: ${entry.parseError}` });
+      continue;
+    }
+    batches.push({ source, declarations: entry.declarations });
+  }
+  const projectBatch = readBatch(
+    { origin: "project", sourcePath: ".clio-coder/hooks.yaml" },
+    join(options.cwd, ".clio-coder", "hooks.yaml"),
+    fileIssues
+  );
+  if (projectBatch) batches.push(projectBatch);
+  const localBatch = readBatch(
+    { origin: "project.local", sourcePath: ".clio-coder/hooks.local.yaml" },
+    join(options.cwd, ".clio-coder", "hooks.local.yaml"),
+    fileIssues
+  );
+  if (localBatch) batches.push(localBatch);
+  return { batches, fileIssues };
+}
+function buildUserHookRegistrations(options) {
+  const workspaceRoot = options.workspaceRoot ?? options.cwd;
+  const readOptions = { cwd: options.cwd };
+  if (options.capturedSources !== void 0) readOptions.capturedSources = options.capturedSources;
+  const { batches, fileIssues } = readHookSources(readOptions);
+  const loaded = loadUserHooks(batches, { workspaceRoot });
+  const runCommand = options.runCommand ?? spawnSyncCommandRunner();
+  const registrations = loaded.hooks.map(
+    (hook) => userHookToRegistration(hook, {
+      recordReceipt: options.recordReceipt,
+      runCommand,
+      ...options.now !== void 0 ? { now: options.now } : {}
+    })
+  );
+  return { ...loaded, fileIssues, registrations };
+}
+function spawnSyncCommandRunner() {
+  return (argv, options) => {
+    const [command, ...args] = argv;
+    const attribution = withManagedGitCommitAttributionEnvironment(process.env, {
+      cwd: options.cwd ?? process.cwd(),
+      evidence: {}
+    });
+    reportCommitAttributionDiagnostic(attribution.diagnostic);
+    const result = spawnSync(command ?? "", args, {
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+      timeout: options.timeoutMs,
+      maxBuffer: COMMAND_OUTPUT_MAX_BYTES,
+      encoding: "utf8",
+      shell: false,
+      env: attribution.env
+    });
+    const timedOut = result.error !== void 0 && result.error.code === "ETIMEDOUT";
+    return {
+      code: result.status,
+      timedOut,
+      stdout: typeof result.stdout === "string" ? result.stdout : "",
+      stderr: typeof result.stderr === "string" ? result.stderr : ""
+    };
+  };
+}
 
 // src/domains/middleware/index.ts
 var MiddlewareDomainModule = {
@@ -2754,15 +2980,18 @@ export {
   MIDDLEWARE_HOOK_TEXT_MAX_CHARS,
   shouldRequestStalledTurnContinuation,
   writeMiddlewareDiagnosticToStderr,
+  formatRegistrationConflict,
   createMiddlewareContractFromSnapshot,
   createReadOnlyExplorationNudgeRegistration,
   createUnbackedWorkerClaimRegistration,
   openDetachedBatchViews,
   createDetachedDispatchNudgeRegistration,
+  HOOK_RECEIPT_LOG_CAPACITY,
   createHookReceiptLog,
+  readPersistedHookReceipts,
   loadUserHooks,
   readHookSources,
-  installUserHooks,
+  buildUserHookRegistrations,
   createSkillsReminderRegistration,
   createMarketplaceOfferRegistration,
   createMemoryInterventionRegistration,
@@ -2775,4 +3004,4 @@ export {
   createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-JA5QWE4Z.js.map
+//# sourceMappingURL=chunk-UBRFI4HS.js.map