@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-VPWGADBG.js

@@ -1,3151 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  TASK_MEMORY_DEFAULT_PROCEDURAL_CAP,
-  TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
-  isTerminalRunEnvelope,
-  runTaskMemoryPolicy,
-  taskMemoryBankDelta
-} from "./chunk-4ATBOFRP.js";
-import {
-  taskBoardCounts
-} from "./chunk-KOAHT3N2.js";
-import {
-  hashToolCall
-} from "./chunk-AY4XE6GN.js";
-import {
-  registerForegroundStream
-} from "./chunk-4HFJKRGZ.js";
-import {
-  ceilChars
-} from "./chunk-SJMNU4ZS.js";
-import {
-  BusChannels
-} from "./chunk-W5RM7YAH.js";
-import {
-  legacyToolResultDigest,
-  sanitizeToolResultDigest
-} from "./chunk-ZKQ63XZ5.js";
-import {
-  captureProjectSurface,
-  projectSurfaceTrustNotice
-} from "./chunk-X6FLVUM5.js";
-import {
-  INSTRUCTION_SHAPED_WARNING
-} from "./chunk-WXA2CFJO.js";
-import {
-  ToolNames
-} from "./chunk-V4XJWDHR.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  buildSafeToolEnv
-} from "./chunk-XTQ7MEJG.js";
-import {
-  gitCommitAttributionEnabled,
-  reportCommitAttributionDiagnostic,
-  withManagedGitCommitAttributionEnvironment
-} from "./chunk-LTR5QCLS.js";
-import {
-  SKILL_INSTALL_OFFER_OPTION_NEVER,
-  SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
-  SKILL_INSTALL_OFFER_OPTION_PROJECT,
-  SKILL_INSTALL_OFFER_OPTION_USER,
-  SKILL_SUGGESTION_ANCHOR,
-  SKILL_SUGGESTION_PREFIX
-} from "./chunk-NBPA5QM6.js";
-import {
-  clioConfigDir
-} from "./chunk-CTTI7G3T.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-ECBHH7LU.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 metadataString(input, key) {
-  const value = input.metadata?.[key];
-  return typeof value === "string" ? 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/injection-screen.ts
-init_esm_shims();
-var INJECTION_SCREEN_RULE = {
-  rule: {
-    id: "safety.untrusted-instructions",
-    source: "builtin",
-    description: "Warn when external tool data contains instruction-shaped markers",
-    enabled: true,
-    hooks: ["after_tool"],
-    effectKinds: ["annotate_tool_result"]
-  },
-  toolNames: ["web_fetch", "read", "bash", "dispatch", "monitor"],
-  predicate: (input) => input.metadata?.untrustedInstructionMarkers === true,
-  effects: [
-    {
-      kind: "annotate_tool_result",
-      severity: "warn",
-      message: INSTRUCTION_SHAPED_WARNING
-    }
-  ]
-};
-
-// 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 SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE = "You ended your turn on a skill suggestion without doing the task. The suggestion line has already made the offer and only the operator loads a skill, so the skill choice needs nothing from them before you proceed. Continue the already-authorized task now without the skill. This continuation is not an operator answer to any other question: if the remaining work is a proposal awaiting an explicit operator go-ahead, park it on the task board and say so instead of implementing.";
-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 CONCRETE_ACTION_STEMS = [
-  "add",
-  "analyse",
-  "analyze",
-  "apply",
-  "audit",
-  "build",
-  "change",
-  "check",
-  "compare",
-  "compile",
-  "create",
-  "debug",
-  "delete",
-  "edit",
-  "execute",
-  "explore",
-  "find",
-  "fix",
-  "format",
-  "grep",
-  "implement",
-  "inspect",
-  "install",
-  "investigate",
-  "list",
-  "load",
-  "look",
-  "modify",
-  "open",
-  "patch",
-  "query",
-  "read",
-  "refactor",
-  "remove",
-  "rename",
-  "replace",
-  "review",
-  "run",
-  "scan",
-  "search",
-  "test",
-  "trace",
-  "update",
-  "validate",
-  "verify",
-  "write"
-];
-var DOUBLED_CONSONANT_STEMS = /* @__PURE__ */ new Set(["debug", "format", "run", "scan"]);
-function concreteActionForms(stem) {
-  const forms = /* @__PURE__ */ new Set([stem, `${stem}s`, `${stem}ed`, `${stem}ing`]);
-  if (/(?:ch|sh|s|x|z)$/.test(stem)) forms.add(`${stem}es`);
-  if (stem.endsWith("e")) {
-    forms.add(`${stem}d`);
-    forms.add(`${stem.slice(0, -1)}ing`);
-  }
-  if (stem.endsWith("y")) {
-    forms.add(`${stem.slice(0, -1)}ies`);
-    forms.add(`${stem.slice(0, -1)}ied`);
-  }
-  if (DOUBLED_CONSONANT_STEMS.has(stem)) {
-    const doubled = `${stem}${stem.slice(-1)}`;
-    forms.add(`${doubled}ed`);
-    forms.add(`${doubled}ing`);
-  }
-  return [...forms];
-}
-var CONCRETE_ACTION_PATTERN = new RegExp(
-  `\\b(?:${CONCRETE_ACTION_STEMS.flatMap(concreteActionForms).join("|")})\\b`,
-  "giu"
-);
-var NAMED_PATH_EXTENSIONS = "c|cc|cfg|cjs|cmake|conf|cpp|cs|css|csv|env|go|h|hpp|html|ini|java|jl|js|json|jsx|lock|log|lua|md|mjs|nc|php|py|rb|rs|rst|sh|sql|toml|ts|tsx|txt|yaml|yml";
-var NAMED_PATH_PATTERN = new RegExp(
-  `(?:^|[\\s\`"'(\\[])(?:[\\w@.\\-/]*[\\w@\\-]\\.(?:${NAMED_PATH_EXTENSIONS})\\b|(?:\\.{1,2}|~)\\/[\\w@.\\-/]+)`,
-  "iu"
-);
-var NAMED_COMMAND_PATTERN = /\b(?:npm|npx|pnpm|yarn|bun|git|cargo|rustc|cmake|ctest|ninja|meson|bazel|gradle|mvn|pytest|pip|python3?|node|deno|tsc|biome|eslint|prettier|jest|vitest|ruff|mypy|docker|kubectl|mpirun|srun|sbatch|gcc|clang)\s+[-\w./]/iu;
-var ACTION_OBJECT_CONNECTOR_PATTERN = /^(?:at|for|in|into|on|through|to)\s+/i;
-var ACTION_OBJECT_DETERMINER_PATTERN = /^(?:a|an|my|our|that|the|their|these|this|those|your)\s+/i;
-var ACTION_OBJECT_PATTERN = /^(?!(?:again|everyone|later|next|now|soon|then|you)\b)[`"'./~]*[\p{L}\p{N}_-]/iu;
-var CONDITIONAL_LEAD_IN_PATTERN = /\b(?:if|once|unless|until|when|whenever)\b/i;
-var CONDITIONAL_INVITATION_PATTERN = /\b(?:answer|approve|ask|confirm|give|point|reply|respond|say|send|share|tell|type)\b[\s\S]*\b(?:and|then)\s*$/i;
-var CONDITIONAL_OFFER_SUFFIX_PATTERN = /\b(?:if\s+(?:needed|necessary|requested|approved|confirmed)\b|(?:if|after|once|until|unless|when(?:ever)?|as\s+soon\s+as|provided|assuming)\b[^.!?]*\byou\b|(?:upon|on|after|with|pending|awaiting|following)\s+(?:your\s+|the\s+operator(?:'s)?\s+)?(?:approval|go-?ahead|confirmation|sign-?off|decision|word|green\s+light|okay|ok)\b)/i;
-var OPERATOR_WAIT_LEAD_PATTERN = /\b(?:await(?:ing)?|pending|waiting\s+(?:for|on))\b/i;
-var NEGATED_OR_HYPOTHETICAL_CLAUSE_PATTERN = /^\s*(?:not|never|would|could|might|may)\b/i;
-var LET_ME_KNOW_PATTERN = /\blet me know\b/i;
-var DEFERRAL_LEAD_PATTERN = /^\s*(?:just\s+|simply\s+|now\s+)?(?:wait|hold\s+off|hold|stand\s+by|pause|defer)\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
-};
-var SKILL_WAIT_PATTERN = /\/skill\b|\bskills?\b|\bskip\b/i;
-function isSkillSuggestionWait(input) {
-  if (input.hook !== "turn_end") return false;
-  if (!isNormalStopReason(input.metadata?.stopReason)) return false;
-  const text = input.text ?? "";
-  if (!text.includes(SKILL_SUGGESTION_PREFIX)) return false;
-  const toolNames = metadataString(input, "turnToolNames");
-  if (toolNames === null) {
-    if ((metadataNumber(input, "turnToolCalls") ?? 0) !== 0) return false;
-  } else if (toolNames.split(",").filter((name) => name.length > 0).some((name) => name !== ToolNames.Context)) {
-    return false;
-  }
-  const lastLine = lastNonEmptyLine(text);
-  if (lastLine === null) return false;
-  const finalSentence = lastSentence(lastLine);
-  if (finalSentence.length === 0) return false;
-  return SKILL_WAIT_PATTERN.test(finalSentence) || isQuestion(finalSentence) || LET_ME_KNOW_PATTERN.test(finalSentence);
-}
-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 announcesConcreteAction(finalSentence);
-}
-function announcesConcreteAction(sentence) {
-  const intent = INTENT_PATTERN.exec(sentence);
-  if (intent) {
-    const leadIn = sentence.slice(0, intent.index);
-    if (CONDITIONAL_LEAD_IN_PATTERN.test(leadIn) || CONDITIONAL_INVITATION_PATTERN.test(leadIn) || OPERATOR_WAIT_LEAD_PATTERN.test(leadIn) || CONDITIONAL_OFFER_SUFFIX_PATTERN.test(sentence)) {
-      return false;
-    }
-    const clause = sentence.slice(intent.index + intent[0].length);
-    if (DEFERRAL_LEAD_PATTERN.test(clause)) return false;
-    if (NEGATED_OR_HYPOTHETICAL_CLAUSE_PATTERN.test(clause)) return false;
-    if (hasActionWithObject(clause)) return true;
-    if (CONDITIONAL_LEAD_IN_PATTERN.test(clause)) return false;
-    return namesToolTarget(clause);
-  }
-  return sentence.endsWith(":") && hasActionWithObject(sentence);
-}
-function namesToolTarget(clause) {
-  return NAMED_PATH_PATTERN.test(clause) || NAMED_COMMAND_PATTERN.test(clause);
-}
-function hasActionWithObject(clause) {
-  for (const action of clause.matchAll(CONCRETE_ACTION_PATTERN)) {
-    const remainder = clause.slice((action.index ?? 0) + action[0].length).trimStart();
-    const withoutConnector = remainder.replace(ACTION_OBJECT_CONNECTOR_PATTERN, "");
-    const object = withoutConnector.replace(ACTION_OBJECT_DETERMINER_PATTERN, "");
-    if (ACTION_OBJECT_PATTERN.test(object)) return true;
-  }
-  return false;
-}
-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;
-}
-var SENTENCE_TERMINATOR_PATTERN = /[.!?]+["'’)\]]*(?=\s|$)/gu;
-function lastSentence(line) {
-  const trimmed = line.trimEnd();
-  let start = 0;
-  for (const terminator of trimmed.matchAll(SENTENCE_TERMINATOR_PATTERN)) {
-    const end = (terminator.index ?? 0) + terminator[0].length;
-    if (end >= trimmed.length) break;
-    start = end;
-  }
-  return trimmed.slice(start).replace(/^[\s"'([{-]+/, "").trim();
-}
-function isQuestion(sentence) {
-  return /[?]["')\]]*$/.test(sentence.trim());
-}
-
-// src/domains/middleware/rules.ts
-var BUILTIN_MIDDLEWARE_RULE_DEFINITIONS = [
-  STALLED_TURN_RULE_DEFINITION,
-  INJECTION_SCREEN_RULE
-];
-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-coder:middleware] registration '${diagnostic.registrationId}' failed on '${diagnostic.hook}': ${diagnostic.message}
-`
-    );
-    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)` : "";
-  process.stderr.write(
-    `[clio-coder:middleware] registration '${diagnostic.registrationId}' exceeded budget on '${diagnostic.hook}': ${diagnostic.elapsedMs.toFixed(1)}ms > ${diagnostic.budgetMs}ms${trend}
-`
-  );
-}
-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,
-    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.toolResultDigest !== void 0) {
-    cloned.toolResultDigest = {
-      text: input.toolResultDigest.text,
-      provenance: { ...input.toolResultDigest.provenance }
-    };
-  }
-  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();
-import { readFileSync } from "node:fs";
-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();
-    }
-  };
-}
-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/skills-reminder.ts
-init_esm_shims();
-var SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
-function skillsReminderMessage(installed, installable = 0, modelActivation = false) {
-  const counts = installable > 0 ? `${installed} installed, ${installable} installable from the marketplace` : `${installed} installed`;
-  if (modelActivation) {
-    return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, load it with context(scope="skills", name="<name>") and continue the task in the same turn. A marketplace skill is not installed and is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
-  }
-  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;
-      let modelActivation = false;
-      try {
-        modelActivation = deps.modelMayActivateSkills?.() ?? false;
-      } catch {
-      }
-      return [
-        {
-          kind: "inject_reminder",
-          severity: "info",
-          message: skillsReminderMessage(installed, installable, modelActivation)
-        }
-      ];
-    }
-  };
-}
-
-// src/domains/middleware/marketplace-offer.ts
-init_esm_shims();
-import { randomUUID } from "node:crypto";
-
-// src/domains/resources/skills/promotion.ts
-init_esm_shims();
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import path from "node:path";
-var TOKEN_STOPWORDS = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "and",
-  "or",
-  "for",
-  "with",
-  "this",
-  "that",
-  "when",
-  "what",
-  "how",
-  "into",
-  "from",
-  "use",
-  "used",
-  "using",
-  "one",
-  "not",
-  "skill",
-  "skills",
-  "clio",
-  "please",
-  "can",
-  "you",
-  "should",
-  "would",
-  "about",
-  "need",
-  "want",
-  "help",
-  "make",
-  "file",
-  "files",
-  "code"
-]);
-function normalize(text) {
-  return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
-}
-function distinctiveTokens(text) {
-  return new Set(
-    normalize(text).split(" ").filter((token) => token.length >= 4 && !TOKEN_STOPWORDS.has(token))
-  );
-}
-var TRIGGER_SCORE = 4;
-var TOKEN_FIRE_THRESHOLD = 3;
-function scorePromotionEntry(userText, entry) {
-  const haystack = ` ${normalize(userText)} `;
-  if (haystack.trim().length === 0) return null;
-  for (const trigger of entry.triggers ?? []) {
-    const phrase = normalize(trigger);
-    if (phrase.length >= 4 && haystack.includes(` ${phrase} `)) {
-      return { entry, score: TRIGGER_SCORE, matchedTrigger: trigger };
-    }
-  }
-  const requestTokens = distinctiveTokens(userText);
-  if (requestTokens.size === 0) return null;
-  const entryTokens = distinctiveTokens(`${entry.name.replace(/-/g, " ")} ${entry.description}`);
-  let overlap = 0;
-  for (const token of requestTokens) if (entryTokens.has(token)) overlap += 1;
-  return overlap >= TOKEN_FIRE_THRESHOLD ? { entry, score: overlap } : null;
-}
-function matchMarketplaceSkills(userText, entries, excludedNames) {
-  const matches = [];
-  for (const entry of entries) {
-    if (entry.kind !== "skill" || excludedNames.has(entry.name)) continue;
-    const match = scorePromotionEntry(userText, entry);
-    if (match) matches.push(match);
-  }
-  return matches.sort(
-    (a, b) => Number(b.matchedTrigger !== void 0) - Number(a.matchedTrigger !== void 0) || 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 library install if intended.`
-  );
-}
-var PROMOTION_DECLINES_FILE = "skill-promotion-declines.json";
-function declineKey(name, version) {
-  return `${name}@${version ?? ""}`;
-}
-function declinesPath(configDir) {
-  return path.join(configDir ?? clioConfigDir(), PROMOTION_DECLINES_FILE);
-}
-function readPromotionDeclines(configDir) {
-  const file = declinesPath(configDir);
-  if (!existsSync(file)) return { never: {} };
-  try {
-    const parsed = JSON.parse(readFileSync2(file, "utf8"));
-    const never = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed.never : void 0;
-    if (never && typeof never === "object" && !Array.isArray(never)) {
-      const entries = Object.entries(never).filter(
-        (pair) => typeof pair[1] === "string"
-      );
-      return { never: Object.fromEntries(entries) };
-    }
-  } catch {
-  }
-  return { never: {} };
-}
-function recordPromotionNeverDecline(name, version, configDir) {
-  const store = readPromotionDeclines(configDir);
-  store.never[declineKey(name, version)] = (/* @__PURE__ */ new Date()).toISOString();
-  safeResourceWrite(declinesPath(configDir), `${JSON.stringify(store, null, 2)}
-`, { encoding: "utf8" });
-}
-
-// src/domains/middleware/marketplace-offer.ts
-var MARKETPLACE_OFFER_REGISTRATION_ID = "observer.marketplace-offer";
-var NO_EFFECTS2 = [];
-function offerBindingTag(offerTag) {
-  return `[clio-install:${offerTag}]`;
-}
-function boundedDescription(text) {
-  return text.replace(/\[[^[\]]*\]/gu, " ").replace(/\s+/gu, " ").trim().slice(0, 200);
-}
-function marketplaceOfferReminder(entry, offerTag) {
-  return `[Marketplace] This request may need expertise no installed skill covers. The local marketplace has "${entry.name}" (not installed): ${boundedDescription(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 answersFromDetails(details) {
-  const raw = details?.answers;
-  if (!Array.isArray(raw)) return [];
-  return raw.filter(
-    (entry) => typeof entry === "object" && entry !== null && typeof entry.question === "string" && typeof entry.answer === "string"
-  );
-}
-function chosenOfferOption(answer) {
-  const labels = [
-    SKILL_INSTALL_OFFER_OPTION_PROJECT,
-    SKILL_INSTALL_OFFER_OPTION_USER,
-    SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
-    SKILL_INSTALL_OFFER_OPTION_NEVER
-  ];
-  for (const label of labels) {
-    if (answer.options?.includes(label)) return label;
-  }
-  for (const label of labels) {
-    if (answer.answer.includes(label)) return label;
-  }
-  return null;
-}
-function createMarketplaceOfferRegistration(deps) {
-  const declines = deps.declines ?? {
-    readNever: () => readPromotionDeclines().never,
-    recordNever: (name, version) => recordPromotionNeverDecline(name, version)
-  };
-  const newOfferTag = deps.newOfferTag ?? (() => randomUUID());
-  let lastSeenSessionId;
-  let offeredNames = /* @__PURE__ */ new Set();
-  let sessionDeclines = /* @__PURE__ */ new Set();
-  let installedNamesCache = null;
-  let marketplaceEntriesCache = null;
-  let pendingOffer = null;
-  const trackSession = (input) => {
-    const sessionId = input.sessionId ?? null;
-    if (lastSeenSessionId === void 0 || lastSeenSessionId === null && sessionId !== null) {
-      lastSeenSessionId = sessionId;
-      return;
-    }
-    if (sessionId !== lastSeenSessionId) {
-      lastSeenSessionId = sessionId;
-      offeredNames = /* @__PURE__ */ new Set();
-      sessionDeclines = /* @__PURE__ */ new Set();
-      pendingOffer = null;
-      installedNamesCache = null;
-      marketplaceEntriesCache = null;
-    }
-  };
-  const bestMatch = (text) => {
-    const installedWasCached = installedNamesCache !== null;
-    let never;
-    try {
-      installedNamesCache ??= new Set(deps.listInstalledSkillNames());
-      marketplaceEntriesCache ??= deps.listMarketplaceEntries();
-      never = declines.readNever();
-    } catch {
-      return null;
-    }
-    const declinedKeys = /* @__PURE__ */ new Set([...Object.keys(never), ...sessionDeclines]);
-    const findMatch = () => matchMarketplaceSkills(
-      text,
-      marketplaceEntriesCache ?? [],
-      /* @__PURE__ */ new Set([...installedNamesCache ?? [], ...offeredNames])
-    ).find((candidate) => !declinedKeys.has(declineKey(candidate.entry.name, candidate.entry.version))) ?? null;
-    let match = findMatch();
-    if (match && installedWasCached) {
-      try {
-        installedNamesCache = new Set(deps.listInstalledSkillNames());
-      } catch {
-        return null;
-      }
-      match = findMatch();
-    }
-    return match;
-  };
-  const installGated = (entry, scope) => {
-    assertPromotionInstallSource(entry);
-    const result = deps.installEntry(entry, scope);
-    installedNamesCache?.add(entry.name);
-    return result;
-  };
-  const evaluateAskUserAnswers = (input) => {
-    const offer = pendingOffer;
-    if (!offer) return NO_EFFECTS2;
-    const marker = offerBindingTag(offer.tag);
-    if (input.toolResultDetails?.cancelled === true) {
-      return NO_EFFECTS2;
-    }
-    for (const answer of answersFromDetails(input.toolResultDetails)) {
-      if (!answer.question.includes(marker)) continue;
-      const option = chosenOfferOption(answer);
-      if (option === null) continue;
-      pendingOffer = null;
-      const offerKey = declineKey(offer.entry.name, offer.entry.version);
-      if (option === SKILL_INSTALL_OFFER_OPTION_NOT_NOW) {
-        sessionDeclines.add(offerKey);
-        return NO_EFFECTS2;
-      }
-      if (option === SKILL_INSTALL_OFFER_OPTION_NEVER) {
-        sessionDeclines.add(offerKey);
-        try {
-          declines.recordNever(offer.entry.name, offer.entry.version);
-        } catch {
-        }
-        return NO_EFFECTS2;
-      }
-      const scope = option === SKILL_INSTALL_OFFER_OPTION_USER ? "user" : "project";
-      try {
-        const result = installGated(offer.entry, scope);
-        return [
-          {
-            kind: "annotate_tool_result",
-            severity: "info",
-            message: `[Marketplace] Installed skill "${offer.entry.name}" (${scope} scope) to ${result.path}. It is installed but not active; the operator activates it with /skill ${offer.entry.name}.`
-          }
-        ];
-      } catch (error) {
-        sessionDeclines.add(offerKey);
-        return [
-          {
-            kind: "annotate_tool_result",
-            severity: "warn",
-            message: `[Marketplace] Install of "${offer.entry.name}" failed: ${error instanceof Error ? error.message : String(error)}. Continue the task without it.`
-          }
-        ];
-      }
-    }
-    return NO_EFFECTS2;
-  };
-  return {
-    id: MARKETPLACE_OFFER_REGISTRATION_ID,
-    description: "offers an uninstalled marketplace skill via ask_user when the request matches it; consented installs run gated to Clio's own marketplace, declines are remembered",
-    hooks: ["turn_start", "after_tool"],
-    evaluate(input) {
-      trackSession(input);
-      if (input.hook === "after_tool") {
-        return input.toolName === ToolNames.AskUser ? evaluateAskUserAnswers(input) : NO_EFFECTS2;
-      }
-      if (input.hook !== "turn_start") return NO_EFFECTS2;
-      if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS2;
-      const pendingSkillRequests = metadataNumber(input, "pendingSkillRequests");
-      if (pendingSkillRequests !== null && pendingSkillRequests > 0) return NO_EFFECTS2;
-      const match = bestMatch(input.text ?? "");
-      if (!match) return NO_EFFECTS2;
-      offeredNames.add(match.entry.name);
-      if (deps.interactive === false) {
-        return [
-          {
-            kind: "inject_reminder",
-            severity: "info",
-            message: `[Marketplace] Skill "${match.entry.name}" matches this request; install with clio-coder library install ${match.entry.name}.`
-          }
-        ];
-      }
-      const tag = newOfferTag();
-      pendingOffer = { entry: match.entry, tag };
-      return [{ kind: "inject_reminder", severity: "info", message: marketplaceOfferReminder(match.entry, tag) }];
-    }
-  };
-}
-
-// src/domains/middleware/memory-intervention.ts
-init_esm_shims();
-import { createHash } 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) {
-  let generation = 0;
-  let generationController = new AbortController();
-  let observedSessionId;
-  let disposed = false;
-  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 {
-    reset,
-    dispose() {
-      disposed = true;
-      reset();
-    },
-    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) {
-      observeSession(input);
-      if (disposed || !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;
-      }
-    },
-    /**
-     * 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) {
-      observeSession(input);
-      if (disposed || !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;
-      const stepGeneration = generation;
-      promptedStepInFlight = true;
-      outstandingStep = runPromptedStep({
-        deterministicTrigger: triggers.some((trigger) => trigger !== "interval"),
-        suppressIntervention: rulesAlreadySpoke,
-        triggerReasons: triggers
-      }).then((result) => {
-        if (stepGeneration !== generation || disposed) return;
-        if (rulesAlreadySpoke && result.decision === "silent") lastDecision = "injected";
-        if (result.reminder === null) return;
-        lastInjectedMessage = result.reminder;
-        deps.onDeferredReminder?.(result.reminder);
-      }).catch(() => {
-      }).finally(() => {
-        if (stepGeneration === generation) promptedStepInFlight = false;
-      });
-      return NO_EFFECTS3;
-    },
-    runPromptedStep,
-    signalLoop() {
-      if (!disposed && settings().enabled) pendingTriggers.add("loop_signal");
-    },
-    lastDecision: () => lastDecision,
-    recentActivity: () => [...activity],
-    stepInFlight: () => promptedStepInFlight,
-    whenIdle: () => outstandingStep
-  };
-  function observeSession(input) {
-    if (input.sessionId === void 0) return;
-    if (observedSessionId !== void 0 && observedSessionId !== input.sessionId) reset();
-    observedSessionId = input.sessionId;
-  }
-  function reset() {
-    generation += 1;
-    generationController.abort();
-    generationController = new AbortController();
-    deps.bank.clear();
-    pending.clear();
-    trajectory.length = 0;
-    failures.clear();
-    toolStep = 0;
-    lastTurnEndStep = 0;
-    reactivateAfterCompaction = false;
-    lastInjectedOperationFingerprint = null;
-    currentTask = "(current task unavailable)";
-    toolsSinceMemoryStep = 0;
-    consecutiveErrors = 0;
-    lastPromptedBoundary = null;
-    lastInjectedMessage = null;
-    lastDecision = null;
-    pendingTriggers.clear();
-    activity.length = 0;
-    annotatedThisTurn.clear();
-    telemetryBankSnapshot = deps.bank.snapshot();
-    promptedStepInFlight = false;
-    promptedStepTier = "rules";
-    outstandingStep = Promise.resolve();
-    rulesInjectedSincePromptedStep = false;
-    annotatedSinceTurnEnd = false;
-    consecutiveLlmTimeouts = 0;
-    observedSessionId = void 0;
-  }
-  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();
-    const stepGeneration = generation;
-    const isCurrent = () => !disposed && stepGeneration === generation;
-    const usageSink = deps.captureStepUsage?.();
-    if (disposed || !live.enabled) {
-      const result = silent("no_client");
-      lastDecision = result.decision;
-      return result;
-    }
-    const started = process.hrtime.bigint();
-    let attemptStarted = started;
-    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;
-          const runClient = (selected, timeoutMs) => runTaskMemoryPolicy(deps.bank, selected, {
-            isCurrent,
-            signal: generationController.signal,
-            onStepUsage: (usage) => {
-              if (usageSink) usageSink(usage, isCurrent());
-              else deps.onStepUsage?.(usage);
-            },
-            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,
-            ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
-          });
-          const remainingMs = () => Math.floor(live.timeoutMs - Number(process.hrtime.bigint() - started) / 1e6);
-          const initialTimeoutMs = remainingMs();
-          promptedResult = initialTimeoutMs <= 0 ? { ...silent("deadline"), decision: "timeout" } : await runClient(client, initialTimeoutMs);
-          if (promptedResult.reason === "client_error" && isCurrent() && remainingMs() > 0) {
-            let fallback = null;
-            let fallbackReady = false;
-            try {
-              fallback = deps.getFallbackModelClient?.() ?? null;
-              fallbackReady = fallback !== null && deps.backgroundEndpointBusy?.() !== true;
-            } catch {
-            }
-            const fallbackTimeoutMs = remainingMs();
-            if (fallback !== null && fallbackReady && isCurrent() && fallbackTimeoutMs > 0) {
-              emitTelemetry(
-                triggers,
-                tier,
-                promptedResult.decision,
-                promptedResult.reason,
-                0,
-                promptedResult.inputTokens,
-                promptedResult.outputTokens,
-                started,
-                { bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations }
-              );
-              attemptStarted = process.hrtime.bigint();
-              promptedResult = await runClient(fallback, fallbackTimeoutMs);
-            }
-          }
-        }
-      }
-    } 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 (!isCurrent()) return { ...promptedResult, reminder: null, effects: NO_EFFECTS3 };
-    if (promptedResult.reason === "endpoint_busy") telemetryDecision = "dropped";
-    if (tier === "llm" && promptedResult.decision === "timeout") consecutiveLlmTimeouts += 1;
-    else if (tier === "llm" && telemetryDecision !== "dropped") consecutiveLlmTimeouts = 0;
-    lastDecision = promptedResult.decision;
-    if (promptedResult.decision === "injected") reportInjectedEntries(promptedResult.reminder);
-    emitTelemetry(
-      triggers,
-      tier,
-      telemetryDecision ?? promptedResult.decision,
-      promptedResult.reason,
-      citedEntryCount(promptedResult.reminder),
-      promptedResult.inputTokens,
-      promptedResult.outputTokens,
-      attemptStarted,
-      { 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;
-  }
-  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;
-    try {
-      deps.onInjectedEntries(entries);
-    } catch {
-    }
-  }
-  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;
-    }
-    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" }];
-  }
-  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;
-      }
-    }
-    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;
-    }
-  }
-  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" }];
-  }
-}
-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 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 });
-      }
-    }
-    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;
-}
-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/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 {
-      return await complete(request);
-    } finally {
-      releaseEndpointSlot();
-      if (bus !== null) {
-        try {
-          bus.emit(BusChannels.MemoryStepCompleted, { endpointKey, targetId });
-        } catch {
-        }
-      }
-    }
-  };
-}
-
-// 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 authorized step, then work them one at a time ("start", then "done" with an evidence note). A plan does not authorize implementation: for proposed work awaiting an operator go-ahead, use action="block" with a note naming the pending operator decision, or action="drop", and wait.`;
-}
-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: 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) }];
-    }
-  };
-}
-
-// 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 only work already authorized by the operator. This reminder and a self-created plan are not authorization to implement a proposal. If implementation awaits an operator decision, use tasks action="block" with a note naming that pending operator decision, or action="drop"; then wait for an explicit operator go-ahead. A skill-install choice does not authorize implementation. Otherwise 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/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;
-  }
-  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 {
-      settings = deps.getSettings();
-    } catch {
-      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 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;
-    }
-    outstanding = started.catch(() => {
-    }).finally(() => {
-      inFlight = false;
-    });
-  };
-  const scopeNow = () => {
-    try {
-      return deps.getScope?.() ?? null;
-    } catch {
-      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;
-      }
-      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);
-  }
-}
-
-// 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]);
-    }
-    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 {
-      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;
-        }
-        seen.add(registration.id);
-        accepted.push(registration);
-      }
-      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;
-    }
-  };
-  return table;
-}
-
-// 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;
-  });
-  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);
-    }
-  };
-}
-
-// 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 ?? []);
-  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 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;
-}
-
-// src/domains/middleware/manifest.ts
-init_esm_shims();
-var MiddlewareManifest = {
-  name: "middleware",
-  dependsOn: []
-};
-
-// src/domains/middleware/hooks.ts
-init_esm_shims();
-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 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" };
-  }
-}
-function readRequireTool(record, path2, issues) {
-  rejectUnexpectedFields(record, path2, ["kind", "toolName"], issues);
-  const toolName = readRequiredString(record, `${path2}.toolName`, issues);
-  return toolName === null ? null : { kind: "require_tool", toolName };
-}
-function readInjectReminder(record, 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 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 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 };
-}
-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/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 createHash2("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 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 } : {}
-  });
-  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 {
-        if (deps.isTrusted?.() === false) {
-          deps.recordReceipt({ ...baseReceipt(input), outcome: "skipped" });
-          return [];
-        }
-        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 receiptExtension(source) {
-  return {
-    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 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
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { spawnSync } from "node:child_process";
-var COMMAND_OUTPUT_MAX_BYTES = 1024 * 1024;
-function readBatch(source, filePath, text, fileIssues) {
-  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 projectSurface = captureProjectSurface(options.cwd, "hooks");
-  for (const [index, file] of projectSurface.files.entries()) {
-    const source = {
-      origin: index === 0 ? "project" : "project.local",
-      sourcePath: index === 0 ? ".clio-coder/hooks.yaml" : ".clio-coder/hooks.local.yaml"
-    };
-    if (file.error !== void 0) fileIssues.push({ source, message: file.error });
-    if (file.text === null) continue;
-    if (projectSurface.verdict !== "trusted") {
-      fileIssues.push({ source, message: projectSurfaceTrustNotice(projectSurface, file.path) });
-      continue;
-    }
-    const batch = readBatch(source, file.path, file.text, fileIssues);
-    if (batch) batches.push(batch);
-  }
-  return { batches, fileIssues, projectSurface };
-}
-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, projectSurface } = readHookSources(readOptions);
-  const loaded = loadUserHooks(batches, { workspaceRoot });
-  const runCommand = options.runCommand ?? spawnSyncCommandRunner();
-  let reportedUntrusted = false;
-  const projectStillTrusted = () => {
-    const current = captureProjectSurface(options.cwd, "hooks");
-    if (current.verdict === "trusted" && current.contentHash === projectSurface.contentHash) return true;
-    if (!reportedUntrusted) {
-      reportedUntrusted = true;
-      options.report?.(
-        `[clio-coder:hooks] project hooks changed or trust was revoked; hooks skipped. Review with clio-coder config trust hooks, then reload extensions.`
-      );
-    }
-    return false;
-  };
-  const registrations = loaded.hooks.map(
-    (hook) => userHookToRegistration(hook, {
-      recordReceipt: options.recordReceipt,
-      runCommand,
-      ...hook.source.origin === "project" || hook.source.origin === "project.local" ? { isTrusted: projectStillTrusted } : {},
-      ...options.now !== void 0 ? { now: options.now } : {}
-    })
-  );
-  return { ...loaded, fileIssues, registrations };
-}
-function spawnSyncCommandRunner() {
-  return (argv, options) => {
-    const [command, ...args] = argv;
-    const attribution = withManagedGitCommitAttributionEnvironment(buildSafeToolEnv(), {
-      cwd: options.cwd ?? process.cwd(),
-      enabled: gitCommitAttributionEnabled(process.env),
-      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 = {
-  manifest: MiddlewareManifest,
-  createExtension: () => createMiddlewareBundle()
-};
-
-export {
-  MIDDLEWARE_HOOK_TEXT_MAX_CHARS,
-  shouldRequestStalledTurnContinuation,
-  writeMiddlewareDiagnosticToStderr,
-  formatRegistrationConflict,
-  createMiddlewareContractFromSnapshot,
-  createReadOnlyExplorationNudgeRegistration,
-  createUnbackedWorkerClaimRegistration,
-  openDetachedBatchViews,
-  createDetachedDispatchNudgeRegistration,
-  HOOK_RECEIPT_LOG_CAPACITY,
-  createHookReceiptLog,
-  readPersistedHookReceipts,
-  loadUserHooks,
-  readHookSources,
-  buildUserHookRegistrations,
-  createSkillsReminderRegistration,
-  createMarketplaceOfferRegistration,
-  createMemoryInterventionRegistration,
-  announceMemoryStepEndpoint,
-  createTaskBoardReminderRegistration,
-  createTaskNudgeRegistration,
-  createMiddlewareToolChoiceControl,
-  WATCHDOG_TASK,
-  watchdogBriefing,
-  createWatchdogRegistration,
-  MiddlewareDomainModule
-};
-//# sourceMappingURL=chunk-VPWGADBG.js.map