@iowarp/clio-coder 0.3.0 → 0.3.2

package/dist/chunk-WMSVI4G2.js

@@ -0,0 +1,2095 @@
+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,
+  runTaskMemoryPolicy,
+  taskMemoryBankDelta
+} from "./chunk-OAO4GE4M.js";
+import {
+  isTerminalRunEnvelope,
+  taskBoardCounts
+} from "./chunk-MQSRRFWA.js";
+import {
+  SKILL_SUGGESTION_ANCHOR
+} from "./chunk-T6YILFSB.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  ceilChars
+} from "./chunk-LZSJBIVT.js";
+import {
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-X75S7HFS.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/middleware/runtime.ts
+init_esm_shims();
+
+// src/domains/middleware/budget.ts
+init_esm_shims();
+
+// src/domains/middleware/types.ts
+init_esm_shims();
+var MIDDLEWARE_HOOKS = ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"];
+var MIDDLEWARE_EFFECT_KINDS = [
+  "inject_reminder",
+  "annotate_tool_result",
+  "block_tool",
+  "protect_path",
+  "request_continuation",
+  "require_tool",
+  "lock_tools"
+];
+var MIDDLEWARE_REMINDER_SEVERITIES = ["info", "advisory", "warn", "hard-block"];
+var MIDDLEWARE_ANNOTATION_SEVERITIES = ["info", "warn"];
+var MIDDLEWARE_HOOK_TEXT_MAX_CHARS = 16e3;
+function metadataNumber(input, key) {
+  const value = input.metadata?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isMiddlewareHook(value) {
+  return MIDDLEWARE_HOOKS.includes(value);
+}
+function isMiddlewareEffectKind(value) {
+  return MIDDLEWARE_EFFECT_KINDS.includes(value);
+}
+function isMiddlewareReminderSeverity(value) {
+  return MIDDLEWARE_REMINDER_SEVERITIES.includes(value);
+}
+function isMiddlewareAnnotationSeverity(value) {
+  return MIDDLEWARE_ANNOTATION_SEVERITIES.includes(value);
+}
+
+// src/domains/middleware/budget.ts
+var DEFAULT_MIDDLEWARE_HOOK_BUDGETS_MS = {
+  before_tool: 25,
+  after_tool: 25,
+  turn_start: 50,
+  turn_end: 75,
+  on_compaction: 150
+};
+var DEFAULT_HOOK_BUDGET_WARMUP_CALLS = 1;
+var DEFAULT_HOOK_BUDGET_WINDOW = 5;
+var DEFAULT_HOOK_BUDGET_THRESHOLD = 3;
+function parsePositiveMs(raw) {
+  if (raw === void 0) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+function parsePositiveInt(raw) {
+  if (raw === void 0) return null;
+  const value = Number(raw);
+  return Number.isInteger(value) && value > 0 ? value : null;
+}
+function parseNonNegativeInt(raw) {
+  if (raw === void 0) return null;
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 0 ? value : null;
+}
+function hookEnvSuffix(hook) {
+  return hook.toUpperCase();
+}
+function resolveHookBudgetsFromEnv(env = process.env) {
+  const global = parsePositiveMs(env.CLIO_CODER_HOOK_BUDGET_MS);
+  const map = {};
+  for (const hook of MIDDLEWARE_HOOKS) {
+    const perPhase = parsePositiveMs(env[`CLIO_CODER_HOOK_BUDGET_${hookEnvSuffix(hook)}_MS`]);
+    map[hook] = perPhase ?? global ?? DEFAULT_MIDDLEWARE_HOOK_BUDGETS_MS[hook];
+  }
+  return map;
+}
+function resolveHookBudgetTunablesFromEnv(env = process.env) {
+  return {
+    warmupCalls: parseNonNegativeInt(env.CLIO_CODER_HOOK_BUDGET_WARMUP_CALLS) ?? DEFAULT_HOOK_BUDGET_WARMUP_CALLS,
+    windowSize: parsePositiveInt(env.CLIO_CODER_HOOK_BUDGET_WINDOW) ?? DEFAULT_HOOK_BUDGET_WINDOW,
+    threshold: parsePositiveInt(env.CLIO_CODER_HOOK_BUDGET_THRESHOLD) ?? DEFAULT_HOOK_BUDGET_THRESHOLD
+  };
+}
+function percentile(sortedAscending, p) {
+  if (sortedAscending.length === 0) return 0;
+  const rank = Math.ceil(p / 100 * sortedAscending.length);
+  const index = Math.min(sortedAscending.length - 1, Math.max(0, rank - 1));
+  return sortedAscending[index] ?? 0;
+}
+function createHookBudgetTracker(options = {}) {
+  const budgets = { ...DEFAULT_MIDDLEWARE_HOOK_BUDGETS_MS, ...options.budgets ?? {} };
+  const warmupCalls = Math.max(0, options.warmupCalls ?? DEFAULT_HOOK_BUDGET_WARMUP_CALLS);
+  const windowSize = Math.max(1, options.windowSize ?? DEFAULT_HOOK_BUDGET_WINDOW);
+  const threshold = Math.min(windowSize, Math.max(1, options.threshold ?? DEFAULT_HOOK_BUDGET_THRESHOLD));
+  const states = /* @__PURE__ */ new Map();
+  function statsFor(state, budgetMs) {
+    const sorted = [...state.window].sort((a, b) => a - b);
+    const overCount = state.window.reduce((count, ms) => ms > budgetMs ? count + 1 : count, 0);
+    return {
+      sampleCount: state.postWarmupCalls,
+      window: state.window.length,
+      overCount,
+      p50Ms: percentile(sorted, 50),
+      p95Ms: percentile(sorted, 95)
+    };
+  }
+  return {
+    budgetFor(hook) {
+      return budgets[hook];
+    },
+    record(registrationId, hook, elapsedMs) {
+      const budgetMs = budgets[hook];
+      const exceeded = elapsedMs > budgetMs;
+      const key = `${registrationId}\0${hook}`;
+      let state = states.get(key);
+      if (state === void 0) {
+        state = { calls: 0, postWarmupCalls: 0, window: [] };
+        states.set(key, state);
+      }
+      state.calls += 1;
+      if (state.calls <= warmupCalls) {
+        return {
+          budgetMs,
+          exceeded,
+          warmup: true,
+          warn: false,
+          stats: { sampleCount: 0, window: 0, overCount: 0, p50Ms: 0, p95Ms: 0 }
+        };
+      }
+      state.postWarmupCalls += 1;
+      state.window.push(elapsedMs);
+      if (state.window.length > windowSize) state.window.shift();
+      const stats = statsFor(state, budgetMs);
+      return {
+        budgetMs,
+        exceeded,
+        warmup: false,
+        warn: exceeded && stats.overCount >= threshold,
+        stats
+      };
+    }
+  };
+}
+
+// src/domains/middleware/rules.ts
+init_esm_shims();
+
+// src/domains/middleware/stalled-turn.ts
+init_esm_shims();
+var STALLED_TURN_REGISTRATION_ID = "nudge.stalled-turn";
+var STALLED_TURN_REQUEST_CONTINUATION_MESSAGE = "You ended your turn after announcing an action without executing it: no tools were called. Continue now and perform the announced action, or state plainly that you are finished and waiting for the user.";
+var INTENT_PATTERN = /\b(let me|i['’]ll|i will|i am going to|i['’]m going to|now i|next i|let's|let us)\b/i;
+var LET_ME_KNOW_PATTERN = /\blet me know\b/i;
+var COMPLETION_PATTERN = /^\s*(?:all\s+done|done|complete|completed|all\s+set)\b|^\s*(?:here(?:'s| is)\s+)?(?:a\s+)?summary\b|^\s*summary\s*:?$/i;
+var STALLED_TURN_RULE_DEFINITION = {
+  rule: {
+    id: STALLED_TURN_REGISTRATION_ID,
+    source: "builtin",
+    description: "request an automatic continuation when a turn announces work but calls no tools",
+    enabled: true,
+    hooks: ["turn_end"],
+    effectKinds: ["request_continuation"]
+  },
+  effects: [{ kind: "request_continuation", message: STALLED_TURN_REQUEST_CONTINUATION_MESSAGE }],
+  predicate: shouldRequestStalledTurnContinuation
+};
+function shouldRequestStalledTurnContinuation(input) {
+  if (input.hook !== "turn_end") return false;
+  if (input.metadata?.turnToolCalls !== 0) return false;
+  if (!isNormalStopReason(input.metadata?.stopReason)) return false;
+  const lastLine = lastNonEmptyLine(input.text ?? "");
+  if (lastLine === null) return false;
+  const finalSentence = lastSentence(lastLine);
+  if (finalSentence.length === 0) return false;
+  if (isQuestion(finalSentence)) return false;
+  if (LET_ME_KNOW_PATTERN.test(finalSentence)) return false;
+  if (COMPLETION_PATTERN.test(lastLine) || COMPLETION_PATTERN.test(finalSentence)) return false;
+  return finalSentence.endsWith(":") || INTENT_PATTERN.test(finalSentence);
+}
+function isNormalStopReason(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  return normalized === "stop" || normalized === "end_turn" || normalized.startsWith("stop_sequence");
+}
+function lastNonEmptyLine(text) {
+  const lines = text.split(/\r?\n/);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]?.trim();
+    if (line && line.length > 0) return line;
+  }
+  return null;
+}
+function lastSentence(line) {
+  const matches = line.match(/[^.!?]+[.!?]+(?:["')\]]+)?|[^.!?]+$/g);
+  const sentence = matches?.at(-1)?.trim() ?? line.trim();
+  return sentence.replace(/^[\s"'([{-]+/, "").trim();
+}
+function isQuestion(sentence) {
+  return /[?]["')\]]*$/.test(sentence.trim());
+}
+
+// src/domains/middleware/rules.ts
+var BUILTIN_MIDDLEWARE_RULE_DEFINITIONS = [STALLED_TURN_RULE_DEFINITION];
+var BUILTIN_MIDDLEWARE_RULE_IDS = BUILTIN_MIDDLEWARE_RULE_DEFINITIONS.map((definition) => definition.rule.id);
+function listMiddlewareRuleDefinitions() {
+  return BUILTIN_MIDDLEWARE_RULE_DEFINITIONS.map(cloneRuleDefinition);
+}
+function listMiddlewareRules() {
+  return BUILTIN_MIDDLEWARE_RULE_DEFINITIONS.map((definition) => cloneMiddlewareRule(definition.rule));
+}
+function cloneMiddlewareRule(rule) {
+  return {
+    id: rule.id,
+    source: rule.source,
+    description: rule.description,
+    enabled: rule.enabled,
+    hooks: [...rule.hooks],
+    effectKinds: [...rule.effectKinds]
+  };
+}
+function cloneRuleDefinition(definition) {
+  const cloned = {
+    rule: cloneMiddlewareRule(definition.rule),
+    effects: [...definition.effects]
+  };
+  if (definition.toolNames !== void 0) cloned.toolNames = [...definition.toolNames];
+  if (definition.predicate !== void 0) cloned.predicate = definition.predicate;
+  return cloned;
+}
+
+// src/domains/middleware/runtime.ts
+function writeMiddlewareDiagnosticToStderr(diagnostic) {
+  if (diagnostic.kind === "hook_failed") {
+    process.stderr.write(
+      `[clio:middleware] registration '${diagnostic.registrationId}' failed on '${diagnostic.hook}': ${diagnostic.message}
+`
+    );
+    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)` : "";
+  process.stderr.write(
+    `[clio:middleware] registration '${diagnostic.registrationId}' exceeded budget on '${diagnostic.hook}': ${diagnostic.elapsedMs.toFixed(1)}ms > ${diagnostic.budgetMs}ms${trend}
+`
+  );
+}
+function registrationFromRuleDefinition(definition) {
+  const registration = {
+    id: definition.rule.id,
+    description: definition.rule.description,
+    hooks: [...definition.rule.hooks],
+    evaluate: (input) => evaluateRuleDefinition(definition, input)
+  };
+  if (definition.toolNames !== void 0) registration.toolNames = [...definition.toolNames];
+  return registration;
+}
+function runMiddlewareRegistrations(input, registrations, options = {}) {
+  const onDiagnostic = options.onDiagnostic ?? writeMiddlewareDiagnosticToStderr;
+  const now = options.now ?? (() => performance.now());
+  const budgetTracker = options.budgetTracker ?? createHookBudgetTracker();
+  const effects = [];
+  const ruleIds = [];
+  for (const registration of registrations) {
+    if (!registration.hooks.includes(input.hook)) continue;
+    if (registration.toolNames !== void 0) {
+      if (input.toolName === void 0) continue;
+      if (!registration.toolNames.includes(input.toolName)) continue;
+    }
+    let emitted;
+    const startedAt = now();
+    try {
+      emitted = registration.evaluate(cloneHookInput(input), { priorEffects: [...effects] });
+    } catch (err) {
+      emitDiagnostic(onDiagnostic, {
+        kind: "hook_failed",
+        registrationId: registration.id,
+        hook: input.hook,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    const elapsedMs = now() - startedAt;
+    const outcome = budgetTracker.record(registration.id, input.hook, elapsedMs);
+    if (outcome.exceeded && !outcome.warmup) {
+      emitDiagnostic(onDiagnostic, {
+        kind: "budget_exceeded",
+        registrationId: registration.id,
+        hook: input.hook,
+        elapsedMs,
+        budgetMs: outcome.budgetMs,
+        steadyStateWarn: outcome.warn,
+        stats: outcome.stats
+      });
+    }
+    if (emitted.length === 0) continue;
+    for (const effect of emitted) {
+      effects.push(cloneMiddlewareEffect(effect));
+    }
+    if (!ruleIds.includes(registration.id)) ruleIds.push(registration.id);
+  }
+  return {
+    hook: input.hook,
+    input: cloneHookInput(input),
+    effects,
+    ruleIds
+  };
+}
+async function runMiddlewareAsyncRegistrations(input, registrations, priorEffects = [], options = {}) {
+  const onDiagnostic = options.onDiagnostic ?? writeMiddlewareDiagnosticToStderr;
+  const effects = [];
+  const ruleIds = [];
+  for (const registration of registrations) {
+    if (registration.evaluateAsync === void 0 || !registration.hooks.includes(input.hook)) continue;
+    if (registration.toolNames !== void 0) {
+      if (input.toolName === void 0 || !registration.toolNames.includes(input.toolName)) continue;
+    }
+    let emitted;
+    try {
+      emitted = await registration.evaluateAsync(cloneHookInput(input), {
+        priorEffects: [...priorEffects, ...effects]
+      });
+    } catch (err) {
+      emitDiagnostic(onDiagnostic, {
+        kind: "hook_failed",
+        registrationId: registration.id,
+        hook: input.hook,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    for (const effect of emitted) effects.push(cloneMiddlewareEffect(effect));
+    if (emitted.length > 0) ruleIds.push(registration.id);
+  }
+  return { hook: input.hook, input: cloneHookInput(input), effects, ruleIds };
+}
+function emitDiagnostic(sink, diagnostic) {
+  try {
+    sink(diagnostic);
+  } catch {
+  }
+}
+function evaluateRuleDefinition(definition, input) {
+  const rule = definition.rule;
+  if (!rule.enabled) return [];
+  if (!rule.hooks.includes(input.hook)) return [];
+  if (definition.toolNames !== void 0) {
+    if (input.toolName === void 0) return [];
+    if (!definition.toolNames.includes(input.toolName)) return [];
+  }
+  if (definition.predicate !== void 0 && !definition.predicate(input)) return [];
+  const declaredKinds = new Set(rule.effectKinds);
+  const emitted = [];
+  for (const effect of definition.effects) {
+    if (!declaredKinds.has(effect.kind)) continue;
+    emitted.push(cloneMiddlewareEffect(effect));
+  }
+  return emitted;
+}
+function cloneMiddlewareEffect(effect) {
+  switch (effect.kind) {
+    case "inject_reminder": {
+      const cloned = { kind: "inject_reminder", message: effect.message };
+      if (effect.severity !== void 0) cloned.severity = effect.severity;
+      return cloned;
+    }
+    case "annotate_tool_result": {
+      const cloned = { kind: "annotate_tool_result", message: effect.message };
+      if (effect.severity !== void 0) cloned.severity = effect.severity;
+      return cloned;
+    }
+    case "block_tool":
+      return { kind: "block_tool", reason: effect.reason, severity: effect.severity };
+    case "protect_path":
+      return { kind: "protect_path", path: effect.path, reason: effect.reason };
+    case "request_continuation":
+      return { kind: "request_continuation", message: effect.message };
+    case "require_tool":
+      return { kind: "require_tool", toolName: effect.toolName };
+    case "lock_tools":
+      return { kind: "lock_tools" };
+  }
+}
+function cloneHookInput(input) {
+  const cloned = { hook: input.hook };
+  if (input.runId !== void 0) cloned.runId = input.runId;
+  if (input.sessionId !== void 0) cloned.sessionId = input.sessionId;
+  if (input.turnId !== void 0) cloned.turnId = input.turnId;
+  if (input.toolCallId !== void 0) cloned.toolCallId = input.toolCallId;
+  if (input.correlationId !== void 0) cloned.correlationId = input.correlationId;
+  if (input.toolName !== void 0) cloned.toolName = input.toolName;
+  if (input.modelId !== void 0) cloned.modelId = input.modelId;
+  if (input.metadata !== void 0) cloned.metadata = { ...input.metadata };
+  if (input.toolArgs !== void 0) cloned.toolArgs = { ...input.toolArgs };
+  if (input.toolResultDetails !== void 0) cloned.toolResultDetails = { ...input.toolResultDetails };
+  if (input.text !== void 0) cloned.text = input.text.slice(0, MIDDLEWARE_HOOK_TEXT_MAX_CHARS);
+  return cloned;
+}
+
+// src/domains/middleware/dispatch-nudge.ts
+init_esm_shims();
+var DETACHED_DISPATCH_NUDGE_REGISTRATION_ID = "nudge.detached-dispatch";
+var READ_ONLY_EXPLORATION_NUDGE_REGISTRATION_ID = "nudge.read-only-exploration";
+var READ_ONLY_EXPLORATION_NUDGE_CALL_THRESHOLD = 9;
+var UNBACKED_WORKER_CLAIM_REGISTRATION_ID = "rail.unbacked-worker-claim";
+var SCOUT_AGENT_ID = "scout";
+var EXPLORATION_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ToolNames.Read,
+  ToolNames.Grep,
+  ToolNames.Find,
+  ToolNames.Ls,
+  ToolNames.CodeNav,
+  ToolNames.Context,
+  ToolNames.Git
+]);
+var EXPLORATION_NUDGE_TURN_LIMIT = 32;
+var NO_TURN = "no-turn";
+var READ_ONLY_SHELL_COMMAND_PATTERN = /^\s*(?:awk|cat|fd|find|git|grep|head|jq|ls|rg|sed|tail|tree|wc)\b/;
+function buildReadOnlyExplorationMessage() {
+  return `[Clio Coder] This turn used ${READ_ONLY_EXPLORATION_NUDGE_CALL_THRESHOLD}+ read-only exploration calls without a successful Scout dispatch; delegate broad repository reconnaissance to Scout.`;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function recordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function ordinaryDispatchAgents(args) {
+  if (!args || args.list === true || args.apply_winner !== void 0 || args.review !== void 0 && args.review !== false || args.mode === "compete") {
+    return null;
+  }
+  let tasks = args.tasks;
+  if (typeof tasks === "string") {
+    const raw = tasks.trim();
+    if (raw.startsWith("[") || raw.startsWith("{")) {
+      try {
+        tasks = JSON.parse(raw);
+      } catch {
+      }
+    }
+  }
+  if (recordValue(tasks) !== null || typeof tasks === "string") tasks = [tasks];
+  if (tasks === void 0 && typeof args.task === "string") tasks = [{ task: args.task }];
+  if (!Array.isArray(tasks) || tasks.length === 0) return null;
+  const sharedAgent = stringValue(args.agent) ?? stringValue(args.agent_id) ?? "coder";
+  const agents = [];
+  for (const task of tasks) {
+    if (typeof task === "string") {
+      if (stringValue(task) === null) return null;
+      agents.push(sharedAgent);
+      continue;
+    }
+    const record = recordValue(task);
+    if (!record || stringValue(record.task) === null) return null;
+    agents.push(stringValue(record.agent) ?? stringValue(record.agent_id) ?? sharedAgent);
+  }
+  return agents;
+}
+function dispatchTargetsScout(args) {
+  return ordinaryDispatchAgents(args)?.some((agent) => agent.toLowerCase() === SCOUT_AGENT_ID) === true;
+}
+function isNonRepositoryContextCall(input) {
+  if (input.toolName !== ToolNames.Context) return false;
+  const scope = stringValue(input.toolArgs?.scope)?.toLowerCase();
+  return scope !== null && scope !== "workspace";
+}
+function isReadOnlyExplorationCall(input) {
+  if (isNonRepositoryContextCall(input)) return false;
+  if (input.toolName && EXPLORATION_TOOL_NAMES.has(input.toolName)) return true;
+  if (input.toolName !== ToolNames.Bash) return false;
+  const command = input.toolArgs?.command;
+  return typeof command === "string" && READ_ONLY_SHELL_COMMAND_PATTERN.test(command);
+}
+function hasActiveTool(input, toolName) {
+  const activeToolNames = input.metadata?.activeToolNames;
+  return typeof activeToolNames === "string" && activeToolNames.split(",").map((name) => name.trim()).includes(toolName);
+}
+function newExplorationTurnState(advised = false) {
+  return {
+    readOnlyCalls: 0,
+    scoutSucceeded: false,
+    advised
+  };
+}
+function markScoutSuccess(state) {
+  state.scoutSucceeded = true;
+}
+function createReadOnlyExplorationNudgeRegistration() {
+  const byTurn = /* @__PURE__ */ new Map();
+  const turnKey = (input) => {
+    const userTurnId = input.hook === "turn_end" ? input.metadata?.userTurnId : void 0;
+    return (typeof userTurnId === "string" && userTurnId.length > 0 ? userTurnId : input.turnId) ?? input.runId ?? NO_TURN;
+  };
+  const remember = (key, state) => {
+    if (byTurn.size >= EXPLORATION_NUDGE_TURN_LIMIT && !byTurn.has(key)) {
+      const oldest = byTurn.keys().next().value;
+      if (oldest !== void 0) byTurn.delete(oldest);
+    }
+    byTurn.set(key, state);
+    return state;
+  };
+  const stateForTool = (key) => byTurn.get(key) ?? remember(key, newExplorationTurnState());
+  const takeTurnEndState = (key) => {
+    const bound = byTurn.get(key);
+    if (bound === void 0) return null;
+    byTurn.set(key, newExplorationTurnState(bound.advised));
+    return bound;
+  };
+  const markAdvised = (key) => {
+    const carried = byTurn.get(key);
+    if (carried) carried.advised = true;
+  };
+  return {
+    id: READ_ONLY_EXPLORATION_NUDGE_REGISTRATION_ID,
+    description: "advise Scout delegation after prolonged read-only repository exploration",
+    hooks: ["before_tool", "after_tool", "turn_end"],
+    evaluate(input) {
+      const key = turnKey(input);
+      if (input.hook === "before_tool" || input.hook === "after_tool") {
+        const state2 = stateForTool(key);
+        if (input.toolName === ToolNames.Dispatch) {
+          if (input.hook === "after_tool" && dispatchTargetsScout(input.toolArgs)) {
+            if (input.metadata?.resultKind === "ok") markScoutSuccess(state2);
+          }
+          return [];
+        }
+        if (input.hook === "after_tool" || !isReadOnlyExplorationCall(input)) return [];
+        state2.readOnlyCalls += 1;
+        return [];
+      }
+      if (input.hook !== "turn_end") return [];
+      const state = takeTurnEndState(key);
+      const stopReason = input.metadata?.stopReason;
+      if (stopReason !== void 0 && stopReason !== "stop") return [];
+      if (!hasActiveTool(input, ToolNames.Dispatch)) return [];
+      if (!state || state.advised || state.scoutSucceeded || state.readOnlyCalls < READ_ONLY_EXPLORATION_NUDGE_CALL_THRESHOLD) {
+        return [];
+      }
+      markAdvised(key);
+      return [{ kind: "inject_reminder", message: buildReadOnlyExplorationMessage(), severity: "info" }];
+    }
+  };
+}
+var WORKER_NOUN = "(?:scouts?|shadow (?:agent|worker)s?|sub-?agents?|workers?)";
+var RESULT_VERB = "(?:found|reported|returned|investigated|explored|concluded|confirmed|discovered|surfaced|completed|is complete|came back)";
+var WORKER_CLAIM_PATTERNS = [
+  // "the scout found ...", "the scout investigation is complete", "workers came back ..."
+  new RegExp(`\\b${WORKER_NOUN}\\b[^.\\n]{0,40}?\\b${RESULT_VERB}\\b`, "i"),
+  // "... reported by the scout"
+  new RegExp(`\\b${RESULT_VERB}\\b[^.\\n]{0,24}\\bby\\s+(?:the\\s+|a\\s+|our\\s+)?${WORKER_NOUN}\\b`, "i"),
+  // A titled worker deliverable: "Scout Shadow Report", "Worker findings".
+  /\b(?:scout|shadow|worker)\b[^\n]{0,20}\b(?:report|findings|summary)\b/i
+];
+function claimsWorkerResults(text) {
+  if (typeof text !== "string" || text.trim().length === 0) return false;
+  return WORKER_CLAIM_PATTERNS.some((pattern) => pattern.test(text));
+}
+function buildUnbackedWorkerClaimMessage() {
+  return "[Clio Coder] no dispatch ran this turn; worker results named above are not backed by a receipt. Dispatch the work or state plainly that you did it inline.";
+}
+function createUnbackedWorkerClaimRegistration() {
+  const dispatchedTurns = /* @__PURE__ */ new Set();
+  const turnKey = (input) => {
+    const userTurnId = input.hook === "turn_end" ? input.metadata?.userTurnId : void 0;
+    return (typeof userTurnId === "string" && userTurnId.length > 0 ? userTurnId : input.turnId) ?? input.runId ?? NO_TURN;
+  };
+  const remember = (key) => {
+    if (dispatchedTurns.size >= EXPLORATION_NUDGE_TURN_LIMIT && !dispatchedTurns.has(key)) {
+      const oldest = dispatchedTurns.values().next().value;
+      if (oldest !== void 0) dispatchedTurns.delete(oldest);
+    }
+    dispatchedTurns.add(key);
+  };
+  return {
+    id: UNBACKED_WORKER_CLAIM_REGISTRATION_ID,
+    description: "contradict a worker/scout result claim that no dispatch call in the turn backs",
+    hooks: ["after_tool", "turn_end"],
+    evaluate(input) {
+      const key = turnKey(input);
+      if (input.hook === "after_tool") {
+        if (input.toolName === ToolNames.Dispatch) remember(key);
+        return [];
+      }
+      if (input.hook !== "turn_end") return [];
+      const dispatched = dispatchedTurns.delete(key);
+      const stopReason = input.metadata?.stopReason;
+      if (stopReason !== void 0 && stopReason !== "stop") return [];
+      if (!hasActiveTool(input, ToolNames.Dispatch)) return [];
+      if (input.metadata?.sharedWorkerNote === true) return [];
+      if (dispatched || !claimsWorkerResults(input.text)) return [];
+      return [{ kind: "inject_reminder", message: buildUnbackedWorkerClaimMessage(), severity: "warn" }];
+    }
+  };
+}
+var TERMINAL_OUTCOME_ORDER = [
+  "succeeded",
+  "canceled",
+  "failed",
+  "timed_out",
+  "stalled",
+  "denied_by_policy",
+  "spawn_failed",
+  "missing",
+  "unknown"
+];
+function terminalOutcomeLabel(outcome) {
+  switch (outcome) {
+    case "timed_out":
+      return "timed out";
+    case "denied_by_policy":
+      return "denied by policy";
+    case "spawn_failed":
+      return "spawn failed";
+    case "missing":
+      return "ledger row missing";
+    case "unknown":
+      return "outcome unknown";
+    default:
+      return outcome;
+  }
+}
+function incrementTerminalOutcome(counts, outcome) {
+  counts[outcome] = (counts[outcome] ?? 0) + 1;
+}
+function openDetachedBatchViews(dispatch) {
+  const detached = dispatch.detached;
+  if (!detached) return [];
+  let records;
+  try {
+    records = detached.list();
+  } catch {
+    return [];
+  }
+  return records.map((record) => {
+    let terminal = 0;
+    const terminalOutcomes = {};
+    for (const run of record.runs) {
+      const row = dispatch.getRun(run.runId);
+      if (row === null) {
+        terminal += 1;
+        incrementTerminalOutcome(terminalOutcomes, "missing");
+      } else if (isTerminalRunEnvelope(row)) {
+        terminal += 1;
+        incrementTerminalOutcome(terminalOutcomes, row.outcome ?? "unknown");
+      }
+    }
+    return { id: record.id, total: record.runs.length, terminal, terminalOutcomes };
+  });
+}
+function detachedBatchProgress(view) {
+  const terminalOutcomes = view.terminalOutcomes ?? {};
+  if (view.terminal === view.total && terminalOutcomes.succeeded === view.total) {
+    return `${view.terminal}/${view.total} run(s) done`;
+  }
+  let accountedFor = 0;
+  const breakdown = TERMINAL_OUTCOME_ORDER.flatMap((outcome) => {
+    const count = terminalOutcomes[outcome] ?? 0;
+    accountedFor += count;
+    return count > 0 ? [`${count} ${terminalOutcomeLabel(outcome)}`] : [];
+  });
+  const unavailable = Math.max(0, view.terminal - accountedFor);
+  if (unavailable > 0) breakdown.push(`${unavailable} outcome unknown`);
+  return `${view.terminal}/${view.total} run(s) terminal (${breakdown.join(", ")})`;
+}
+function buildDetachedBatchesMessage(ready, running) {
+  const rows = ready.map((view) => `  - batch ${view.id}: ${detachedBatchProgress(view)}`);
+  const runningNote = running.length > 0 ? `
+${running.length} other detached batch(es) are still running; leave those for later.` : "";
+  return `[Clio Coder] ${ready.length} detached dispatch batch(es) finished and are uncollected:
+${rows.join("\n")}
+Collect each with monitor mode="collect" batch_id=<id> before final synthesis and act on the results. A batch stays open (and keeps nudging) until it is collected.${runningNote}`;
+}
+function createDetachedDispatchNudgeRegistration(options) {
+  return {
+    id: DETACHED_DISPATCH_NUDGE_REGISTRATION_ID,
+    description: "carry the turn onward when detached dispatch results are ready to collect",
+    hooks: ["turn_end"],
+    evaluate(input) {
+      if (input.hook !== "turn_end") return [];
+      const stopReason = input.metadata?.stopReason;
+      if (stopReason !== void 0 && stopReason !== "stop") return [];
+      const activeToolNames = input.metadata?.activeToolNames;
+      if (typeof activeToolNames === "string" && !activeToolNames.split(",").includes(ToolNames.Monitor)) return [];
+      let views;
+      try {
+        views = options.getOpenBatches();
+      } catch {
+        return [];
+      }
+      const ready = views.filter((view) => view.total > 0 && view.terminal >= view.total);
+      if (ready.length === 0) return [];
+      const running = views.filter((view) => view.total > 0 && view.terminal < view.total);
+      const message = buildDetachedBatchesMessage(ready, running);
+      return [
+        { kind: "request_continuation", message },
+        { kind: "inject_reminder", message, severity: "warn" }
+      ];
+    }
+  };
+}
+
+// src/domains/middleware/hook-receipts.ts
+init_esm_shims();
+var HOOK_RECEIPT_LOG_CAPACITY = 200;
+var PERSIST_THROTTLE_MS = 2e3;
+function createHookReceiptLog(options = {}) {
+  const capacity = options.capacity ?? HOOK_RECEIPT_LOG_CAPACITY;
+  const now = options.now ?? Date.now;
+  const throttleMs = options.throttleMs ?? PERSIST_THROTTLE_MS;
+  const ring = [];
+  let lastPersistAt = 0;
+  let dirty = false;
+  const persist = () => {
+    if (options.persistPath === void 0) return;
+    const payload = { version: 1, receipts: ring };
+    try {
+      safeResourceWrite(options.persistPath, `${JSON.stringify(payload, null, 2)}
+`, { encoding: "utf8" });
+      dirty = false;
+    } catch {
+    }
+  };
+  return {
+    record(receipt) {
+      ring.push(receipt);
+      while (ring.length > capacity) ring.shift();
+      dirty = true;
+      if (now() - lastPersistAt >= throttleMs) {
+        lastPersistAt = now();
+        persist();
+      }
+    },
+    list() {
+      return [...ring];
+    },
+    flush() {
+      if (dirty) persist();
+    }
+  };
+}
+
+// src/domains/middleware/hooks-io.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";
+
+// src/domains/middleware/hooks.ts
+init_esm_shims();
+import { createHash } 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 readMiddlewareEffect(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "expected middleware effect object" });
+    return null;
+  }
+  const kindValue = value.kind;
+  if (typeof kindValue !== "string" || !isMiddlewareEffectKind(kindValue)) {
+    issues.push({ path: `${path}.kind`, message: "expected known middleware effect kind" });
+    return null;
+  }
+  switch (kindValue) {
+    case "inject_reminder":
+      return readInjectReminder(value, path, issues);
+    case "annotate_tool_result":
+      return readAnnotateToolResult(value, path, issues);
+    case "block_tool":
+      return readBlockTool(value, path, issues);
+    case "protect_path":
+      return readProtectPath(value, path, issues);
+    case "request_continuation":
+      return readRequestContinuation(value, path, issues);
+    case "require_tool":
+      return readRequireTool(value, path, issues);
+    case "lock_tools":
+      rejectUnexpectedFields(value, path, ["kind"], issues);
+      return { kind: "lock_tools" };
+  }
+}
+function readRequireTool(record, path, issues) {
+  rejectUnexpectedFields(record, path, ["kind", "toolName"], issues);
+  const toolName = readRequiredString(record, `${path}.toolName`, issues);
+  return toolName === null ? null : { kind: "require_tool", toolName };
+}
+function readInjectReminder(record, path, issues) {
+  rejectUnexpectedFields(record, path, ["kind", "message", "severity"], issues);
+  const message = readRequiredString(record, `${path}.message`, issues);
+  const severity = readOptionalString(record, `${path}.severity`, issues);
+  if (severity !== void 0 && !isMiddlewareReminderSeverity(severity)) {
+    issues.push({ path: `${path}.severity`, message: "expected info, advisory, warn, or hard-block" });
+  }
+  if (message === null) return null;
+  const effect = { kind: "inject_reminder", message };
+  if (severity !== void 0 && isMiddlewareReminderSeverity(severity)) effect.severity = severity;
+  return effect;
+}
+function readAnnotateToolResult(record, path, issues) {
+  rejectUnexpectedFields(record, path, ["kind", "message", "severity"], issues);
+  const message = readRequiredString(record, `${path}.message`, issues);
+  const severity = readOptionalString(record, `${path}.severity`, issues);
+  if (severity !== void 0 && !isMiddlewareAnnotationSeverity(severity)) {
+    issues.push({ path: `${path}.severity`, message: "expected info or warn" });
+  }
+  if (message === null) return null;
+  const effect = { kind: "annotate_tool_result", message };
+  if (severity !== void 0 && isMiddlewareAnnotationSeverity(severity)) effect.severity = severity;
+  return effect;
+}
+function readBlockTool(record, path, issues) {
+  rejectUnexpectedFields(record, path, ["kind", "reason", "severity"], issues);
+  const reason = readRequiredString(record, `${path}.reason`, issues);
+  const severity = readRequiredString(record, `${path}.severity`, issues);
+  if (severity !== null && severity !== "hard-block") {
+    issues.push({ path: `${path}.severity`, message: "expected hard-block" });
+  }
+  if (reason === null || severity !== "hard-block") return null;
+  return { kind: "block_tool", reason, severity };
+}
+function readProtectPath(record, path, issues) {
+  rejectUnexpectedFields(record, path, ["kind", "path", "reason"], issues);
+  const protectedPath = readRequiredString(record, `${path}.path`, issues);
+  const reason = readRequiredString(record, `${path}.reason`, issues);
+  if (protectedPath === null || reason === null) return null;
+  return { kind: "protect_path", path: protectedPath, reason };
+}
+function readRequestContinuation(record, path, issues) {
+  rejectUnexpectedFields(record, path, ["kind", "message"], issues);
+  const message = readRequiredString(record, `${path}.message`, issues);
+  if (message === null) return null;
+  return { kind: "request_continuation", message };
+}
+function readRequiredString(record, path, issues) {
+  const value = record[pathField(path)];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push({ path, message: "expected non-empty string" });
+    return null;
+  }
+  return value;
+}
+function readOptionalString(record, path, issues) {
+  const field = pathField(path);
+  if (!Object.hasOwn(record, field)) return void 0;
+  const value = record[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push({ path, message: "expected non-empty string" });
+    return void 0;
+  }
+  return value;
+}
+function rejectUnexpectedFields(record, path, allowedFields, issues) {
+  const allowed = new Set(allowedFields);
+  for (const field of Object.keys(record).sort((a, b) => a.localeCompare(b))) {
+    if (!allowed.has(field)) issues.push({ path: `${path}.${field}`, message: "unexpected field" });
+  }
+}
+function pathField(path) {
+  return path.slice(path.lastIndexOf(".") + 1);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// 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 stableHash(value) {
+  return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 16);
+}
+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 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);
+  }
+  return out;
+}
+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;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+      }
+      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 };
+}
+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 [];
+      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;
+}
+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 (hook.spec.kind === "effect") {
+    deps.recordReceipt({ ...base, outcome: "emitted", effectKinds: [hook.spec.effect.kind] });
+    return [hook.spec.effect];
+  }
+  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/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;
+  }
+  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 = [];
+  for (const extension of options.extensions ?? []) {
+    const source = {
+      origin: "extension",
+      sourcePath: `${extension.id}:hooks.yaml`,
+      sourceId: extension.id
+    };
+    const batch = readBatch(source, join(extension.rootPath, "hooks.yaml"), fileIssues);
+    if (batch) batches.push(batch);
+  }
+  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 } : {}
+      })
+    );
+  }
+  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/memory-intervention.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+var MEMORY_INTERVENTION_REGISTRATION_ID = "observer.memory-intervention";
+var MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS = 8;
+var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 400;
+var MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS = 10;
+var MEMORY_INTERVENTION_ACTIVITY_LIMIT = 20;
+var RESULT_DIGEST_MAX_CHARS = 240;
+var CALL_DESCRIPTION_MAX_CHARS = 180;
+var NO_EFFECTS = [];
+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 lastInjectedFingerprint = 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;
+  return {
+    id: MEMORY_INTERVENTION_REGISTRATION_ID,
+    description: "maintain bounded task execution memory and selectively remind after repeated failures or compaction",
+    hooks: ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"],
+    evaluate(input) {
+      if (!settings().enabled) return NO_EFFECTS;
+      try {
+        switch (input.hook) {
+          case "before_tool":
+            observeBeforeTool(input);
+            return NO_EFFECTS;
+          case "after_tool":
+            return observeAfterTool(input);
+          case "turn_end": {
+            if (toolStep <= lastTurnEndStep) return NO_EFFECTS;
+            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":
+            reactivateAfterCompaction = true;
+            return NO_EFFECTS;
+          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_EFFECTS;
+      }
+    },
+    /**
+     * 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_EFFECTS;
+      const boundary = input.turnId ?? input.metadata?.userTurnId?.toString() ?? `tool-step:${toolStep}`;
+      if (boundary === lastPromptedBoundary) return NO_EFFECTS;
+      if (deps.deliversDeferredReminders === false) {
+        emitTelemetry([...pendingTriggers], "rules", "silent", "no_consumer", 0, 0, 0, process.hrtime.bigint());
+        pendingTriggers.clear();
+        return NO_EFFECTS;
+      }
+      if (promptedStepInFlight) {
+        emitTelemetry(
+          [...pendingTriggers],
+          promptedStepTier,
+          "dropped",
+          "step_in_flight",
+          0,
+          0,
+          0,
+          process.hrtime.bigint()
+        );
+        return NO_EFFECTS;
+      }
+      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_EFFECTS;
+    },
+    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,
+      effects: NO_EFFECTS
+    });
+    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;
+    try {
+      const client = deps.getModelClient?.() ?? null;
+      if (client === null) {
+        promptedResult = silent("no_client");
+      } else {
+        tier = "llm";
+        promptedStepTier = tier;
+        promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
+          task: input.task?.trim() || currentTask,
+          trajectory: [...trajectory],
+          deterministicTrigger: input.deterministicTrigger,
+          maxTokens: live.maxTokens,
+          ...input.suppressIntervention === void 0 ? {} : { suppressIntervention: input.suppressIntervention },
+          previousReminder: lastInjectedMessage,
+          timeoutMs: live.timeoutMs,
+          ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
+        });
+      }
+    } 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"
+      });
+    }
+    lastDecision = promptedResult.decision;
+    emitTelemetry(
+      triggers,
+      tier,
+      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_EFFECTS : [{ kind: "inject_reminder", message: promptedResult.reminder, severity: "advisory" }]
+    };
+  }
+  function emitTelemetry(triggerReasons, tier, decision, reason, citedEntries, 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,
+        inputTokens,
+        outputTokens,
+        latencyMs
+      });
+    } catch {
+    }
+    const event = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      triggerReasons: [...new Set(triggerReasons)],
+      tier,
+      decision,
+      reason,
+      citedEntries,
+      bankWrites: countBankWrites(bankDelta),
+      latencyMs
+    };
+    activity.unshift(event);
+    if (activity.length > MEMORY_INTERVENTION_ACTIVITY_LIMIT) activity.length = MEMORY_INTERVENTION_ACTIVITY_LIMIT;
+  }
+  function citedEntryCount(message) {
+    if (message === null) return 0;
+    const snapshot = deps.bank.snapshot();
+    return [...snapshot.knowledge, ...snapshot.procedural].filter((entry) => message.includes(`[${entry.id}]`)).length;
+  }
+  function observeBeforeTool(input) {
+    const prepared = prepareToolStep(input);
+    if (prepared === null) return;
+    setBounded(pending, pendingKey(input, prepared.fingerprint), prepared, settings().windowSteps);
+  }
+  function observeAfterTool(input) {
+    const fallback = prepareToolStep(input);
+    if (fallback === null) return NO_EFFECTS;
+    const key = pendingKey(input, fallback.fingerprint);
+    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 step = {
+      ...prepared,
+      step: toolStep,
+      outcome,
+      resultDigest: resultDigest(input, outcome)
+    };
+    trajectory.push(step);
+    if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
+    if (outcome !== "error") return NO_EFFECTS;
+    rememberFailure(step);
+    return annotateRepeatedFailure(step);
+  }
+  function annotateRepeatedFailure(step) {
+    if (annotatedThisTurn.has(step.fingerprint)) return NO_EFFECTS;
+    const occurrences = trajectory.filter(
+      (candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint
+    ).length;
+    const failure = failures.get(step.fingerprint);
+    if (occurrences < 2 || failure === void 0) return NO_EFFECTS;
+    const message = boundedReminder(
+      `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}. Change the approach rather than repeating it.`,
+      settings().maxTokens
+    );
+    if (message.length === 0) return NO_EFFECTS;
+    annotatedThisTurn.add(step.fingerprint);
+    lastInjectedFingerprint = step.fingerprint;
+    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.fingerprint);
+    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;
+      }
+    }
+    setBounded(
+      failures,
+      step.fingerprint,
+      {
+        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.fingerprint === lastInjectedFingerprint) {
+          continue;
+        }
+        const occurrences = trajectory.filter(
+          (candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint
+        ).length;
+        const failure = failures.get(step.fingerprint);
+        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_EFFECTS;
+        lastInjectedFingerprint = step.fingerprint;
+        lastInjectedMessage = message;
+        lastDecision = "injected";
+        rulesInjectedSincePromptedStep = true;
+        deps.bank.recordInjection([failure.entryId]);
+        return [{ kind: "inject_reminder", message, severity: "advisory" }];
+      }
+      lastDecision = "silent";
+      return NO_EFFECTS;
+    } finally {
+      lastTurnEndStep = toolStep;
+    }
+  }
+  function reactivateKnowledge() {
+    if (!reactivateAfterCompaction) return NO_EFFECTS;
+    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_EFFECTS;
+    }
+    const message = boundedReminder(`${prefix}${rendered}`, maxTokens);
+    if (message.length === 0) {
+      lastDecision = "silent";
+      return NO_EFFECTS;
+    }
+    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" }];
+  }
+}
+function prepareToolStep(input) {
+  const toolName = input.toolName?.trim();
+  if (!toolName) return null;
+  const canonical = hashToolCall(toolName, input.toolArgs ?? {});
+  return {
+    toolName,
+    fingerprint: createHash2("sha256").update(canonical).digest("hex").slice(0, 16),
+    callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS)
+  };
+}
+function pendingKey(input, fingerprint) {
+  return input.toolCallId ?? `anonymous:${fingerprint}`;
+}
+function resultDigest(input, outcome) {
+  if (outcome === "error") {
+    const metadataMessage = input.metadata?.errorMessage;
+    if (typeof metadataMessage === "string" && metadataMessage.trim().length > 0) {
+      return shortText(diagnosticLine(metadataMessage), RESULT_DIGEST_MAX_CHARS);
+    }
+    for (const key of ["error", "message"]) {
+      const value = input.toolResultDetails?.[key];
+      if (typeof value === "string" && value.trim().length > 0) {
+        return shortText(diagnosticLine(value), RESULT_DIGEST_MAX_CHARS);
+      }
+    }
+    return "an unknown tool error";
+  }
+  const resultFingerprint = input.metadata?.resultFingerprint;
+  return typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok";
+}
+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;
+}
+function countBankWrites(delta) {
+  return [delta.status, delta.knowledge, delta.procedural].reduce(
+    (total, entry) => total + entry.added + entry.updated + entry.deleted,
+    0
+  );
+}
+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);
+  }
+  map.set(key, value);
+}
+
+// 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 wait for the operator; load only on operator request, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
+}
+var NO_EFFECTS2 = [];
+var GREETING_WORDS = /* @__PURE__ */ new Set([
+  "hi",
+  "hello",
+  "hey",
+  "heya",
+  "hiya",
+  "howdy",
+  "yo",
+  "sup",
+  "hola",
+  "greetings",
+  "gm",
+  "gn",
+  "morning",
+  "afternoon",
+  "evening",
+  "good",
+  "day",
+  "night",
+  "there",
+  "you",
+  "clio",
+  "thanks",
+  "thank",
+  "thankyou",
+  "thx",
+  "ty",
+  "ok",
+  "okay",
+  "k",
+  "cool",
+  "nice",
+  "test",
+  "testing",
+  "ping",
+  "pong"
+]);
+function isSubstantiveUserTurn(text) {
+  const normalized = (text ?? "").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
+  if (normalized.length === 0) return false;
+  const tokens = normalized.split(" ");
+  if (tokens.length > 4) return true;
+  return tokens.some((token) => !GREETING_WORDS.has(token));
+}
+function createSkillsReminderRegistration(deps) {
+  let lastSeenSessionId;
+  let spentForActiveSession = false;
+  let observedFreshStart = false;
+  let observedAnyTurn = false;
+  return {
+    id: SKILLS_REMINDER_REGISTRATION_ID,
+    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol",
+    hooks: ["turn_start"],
+    evaluate(input) {
+      const sessionId = input.sessionId ?? null;
+      if (lastSeenSessionId === void 0) {
+        lastSeenSessionId = sessionId;
+      } else if (lastSeenSessionId === null && sessionId !== null) {
+        lastSeenSessionId = sessionId;
+      } else if (sessionId !== lastSeenSessionId) {
+        lastSeenSessionId = sessionId;
+        spentForActiveSession = false;
+        observedFreshStart = false;
+        observedAnyTurn = false;
+      }
+      if (spentForActiveSession) return NO_EFFECTS2;
+      const conversationMessages = metadataNumber(input, "conversationMessages");
+      if (!observedAnyTurn) {
+        observedAnyTurn = true;
+        if (conversationMessages === null || conversationMessages > 0) {
+          spentForActiveSession = true;
+          return NO_EFFECTS2;
+        }
+        observedFreshStart = true;
+      }
+      if (!observedFreshStart) {
+        spentForActiveSession = true;
+        return NO_EFFECTS2;
+      }
+      if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS2;
+      spentForActiveSession = true;
+      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
+      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS2;
+      let installed = 0;
+      let installable = 0;
+      try {
+        installed = deps.countModelVisibleSkills();
+        installable = deps.countInstallableSkills?.() ?? 0;
+      } catch {
+        return NO_EFFECTS2;
+      }
+      if (installed <= 0 && installable <= 0) return NO_EFFECTS2;
+      return [{ kind: "inject_reminder", severity: "info", message: skillsReminderMessage(installed, installable) }];
+    }
+  };
+}
+
+// src/domains/middleware/task-board-reminder.ts
+init_esm_shims();
+var TASK_BOARD_REMINDER_REGISTRATION_ID = "observer.task-board-reminder";
+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_EFFECTS3 = [];
+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_EFFECTS3;
+      const steps = countEnumeratedSteps(input.text);
+      if (steps < 3) return NO_EFFECTS3;
+      spentForActiveSession = true;
+      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
+      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS3;
+      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 [];
+      }
+      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/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" };
+    }
+  };
+}
+
+// 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 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()
+  });
+  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;
+    }
+  };
+}
+
+// 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;
+    }
+  };
+  return {
+    extension: {
+      start() {
+        return void 0;
+      }
+    },
+    contract
+  };
+}
+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);
+  }
+  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);
+  }
+  return combined;
+}
+
+// src/domains/middleware/manifest.ts
+init_esm_shims();
+var MiddlewareManifest = {
+  name: "middleware",
+  dependsOn: []
+};
+
+// src/domains/middleware/index.ts
+var MiddlewareDomainModule = {
+  manifest: MiddlewareManifest,
+  createExtension: () => createMiddlewareBundle()
+};
+
+export {
+  MIDDLEWARE_HOOK_TEXT_MAX_CHARS,
+  shouldRequestStalledTurnContinuation,
+  writeMiddlewareDiagnosticToStderr,
+  createMiddlewareContractFromSnapshot,
+  createReadOnlyExplorationNudgeRegistration,
+  createUnbackedWorkerClaimRegistration,
+  openDetachedBatchViews,
+  createDetachedDispatchNudgeRegistration,
+  createHookReceiptLog,
+  loadUserHooks,
+  readHookSources,
+  installUserHooks,
+  createMemoryInterventionRegistration,
+  createSkillsReminderRegistration,
+  createTaskBoardReminderRegistration,
+  createTaskNudgeRegistration,
+  createMiddlewareToolChoiceControl,
+  MiddlewareDomainModule
+};
+//# sourceMappingURL=chunk-WMSVI4G2.js.map