@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-T6YILFSB.js

@@ -0,0 +1,80 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/skill-activation.ts
+init_esm_shims();
+var SKILL_SUGGESTION_ANCHOR = "Suggested skill: /skill <name>";
+var SKILL_SUGGESTION_PREFIX = SKILL_SUGGESTION_ANCHOR.slice(0, SKILL_SUGGESTION_ANCHOR.indexOf("<name>"));
+var SKILL_SURFACE_EXEMPT_TOOLS = /* @__PURE__ */ new Set(["context", "ask_user"]);
+function evaluateSkillToolSurface(policy, tool) {
+  if (!policy || policy.loadedSkillPolicies.size === 0) return null;
+  if (SKILL_SURFACE_EXEMPT_TOOLS.has(tool)) return null;
+  const entries = [...policy.loadedSkillPolicies.entries()];
+  const skills = entries.map(([name]) => name);
+  const disallowedBy = entries.filter(([, declared]) => declared.disallowedTools?.includes(tool) === true).map(([name]) => name);
+  if (disallowedBy.length > 0) return { skills, mergedAllowedTools: null, disallowedBy };
+  const allowLists = entries.map(([, declared]) => declared.allowedTools);
+  if (allowLists.some((list) => list === void 0 || list.length === 0)) return null;
+  const merged = [...new Set(allowLists.flatMap((list) => [...list ?? []]))];
+  if (merged.includes(tool)) return null;
+  return { skills, mergedAllowedTools: merged, disallowedBy: [] };
+}
+function agentSkillToolPolicy(skillNames) {
+  const allowedSkillNames = [...new Set(skillNames.map((name) => name.trim()).filter((name) => name.length > 0))];
+  if (allowedSkillNames.length === 0) return void 0;
+  return {
+    allowedSkillNames,
+    requests: allowedSkillNames.map((name) => ({ name, args: "", source: "recipe", installed: true })),
+    loadedSkillNames: /* @__PURE__ */ new Set(),
+    loadedSkillPolicies: /* @__PURE__ */ new Map()
+  };
+}
+function trimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function skillActivationFromSource(source, triggeredBy, turnId) {
+  const sourceOrigin = trimmedString(source.sourceOrigin) ?? trimmedString(source.sourceInfo?.source);
+  return {
+    name: source.name,
+    filePath: source.filePath,
+    hash: source.hash,
+    source: source.source,
+    ...sourceOrigin ? { sourceOrigin } : {},
+    triggeredBy,
+    ...turnId ? { turnId } : {}
+  };
+}
+function skillActivationFromToolDetails(details, turnId) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return null;
+  const record = details;
+  const name = trimmedString(record.name);
+  const filePath = trimmedString(record.filePath) ?? trimmedString(record.path);
+  const hash = trimmedString(record.hash);
+  const source = trimmedString(record.source);
+  const sourceOrigin = trimmedString(record.sourceOrigin) ?? trimmedString(record.origin);
+  if (!name || !filePath || !hash || !source) return null;
+  const activation = skillActivationFromSource(
+    { name, filePath, hash, source, ...sourceOrigin ? { sourceOrigin } : {} },
+    "tool",
+    turnId
+  );
+  if (record.drift === "match" || record.drift === "mismatch") activation.drift = record.drift;
+  return activation;
+}
+function isSkillActivation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.name === "string" && typeof record.filePath === "string" && typeof record.hash === "string" && typeof record.source === "string" && (record.sourceOrigin === void 0 || typeof record.sourceOrigin === "string") && (record.triggeredBy === "slash-command" || record.triggeredBy === "tool") && (record.turnId === void 0 || typeof record.turnId === "string") && (record.runId === void 0 || typeof record.runId === "string");
+}
+
+export {
+  SKILL_SUGGESTION_ANCHOR,
+  SKILL_SUGGESTION_PREFIX,
+  evaluateSkillToolSurface,
+  agentSkillToolPolicy,
+  skillActivationFromToolDetails,
+  isSkillActivation
+};
+//# sourceMappingURL=chunk-T6YILFSB.js.map

package/dist/chunk-TZK7PACC.js

@@ -0,0 +1,174 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  VERIFICATION_SCRIPT_FAMILY_HINT
+} from "./chunk-7MNJORFF.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  combineSafeOutput,
+  runCommandVector
+} from "./chunk-VPAYEGVX.js";
+import {
+  StringEnum
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/verify/surface.ts
+init_esm_shims();
+var BROWSER_MODES = ["auto", "required", "off"];
+function prepareVerifyArguments(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  const next = { ...args };
+  if (typeof next.args === "string") {
+    try {
+      const parsed = JSON.parse(next.args);
+      if (Array.isArray(parsed)) next.args = parsed;
+    } catch {
+    }
+  }
+  return next;
+}
+var verifyToolSurface = {
+  name: ToolNames.Verify,
+  description: 'Run a declared verification check: no arguments lists checks, check=<package.json script> runs it, check="frontend" with path validates an HTML/CSS/JS artifact.',
+  parameters: typebox_exports.Object({
+    check: typebox_exports.Optional(
+      typebox_exports.String({
+        description: `Declared script name (${VERIFICATION_SCRIPT_FAMILY_HINT}) or "frontend". Omit to list available checks.`
+      })
+    ),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "check=frontend: artifact file under the workspace root." })),
+    args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Extra arguments passed after --." })),
+    browser: typebox_exports.Optional(
+      StringEnum(BROWSER_MODES, { description: "check=frontend: headless browser mode (default auto)." })
+    ),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout in ms (default 120000)." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "execute",
+  executionMode: "sequential",
+  prepareArguments: prepareVerifyArguments
+};
+
+// src/tools/safe-exec.ts
+init_esm_shims();
+var TRUNCATION_MARKER = "\n[output truncated]\n";
+function timeoutArg(args, fallback = SAFE_EXEC_DEFAULT_TIMEOUT_MS) {
+  return typeof args.timeout_ms === "number" && args.timeout_ms > 0 ? Math.floor(args.timeout_ms) : fallback;
+}
+function cwdArg(args) {
+  return typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : void 0;
+}
+function maxOutputArg(args) {
+  return typeof args.max_output_bytes === "number" && args.max_output_bytes > 0 ? Math.floor(args.max_output_bytes) : SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
+}
+function resultDetails(result) {
+  return {
+    command: [result.file, ...result.args].join(" "),
+    cwd: result.cwd,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs,
+    timedOut: result.timedOut,
+    outputCapped: result.outputCapped
+  };
+}
+async function runVectorTool(action, file, vectorArgs, args, options) {
+  const timeoutMs = timeoutArg(args);
+  const maxOutputBytes = maxOutputArg(args);
+  try {
+    const runOptions = { timeoutMs, maxOutputBytes };
+    const cwd = cwdArg(args);
+    if (cwd !== void 0) runOptions.cwd = cwd;
+    if (options?.signal !== void 0) runOptions.signal = options.signal;
+    const result = await runCommandVector(file, vectorArgs, runOptions);
+    const output = truncateUtf8(combineSafeOutput(result), maxOutputBytes, TRUNCATION_MARKER);
+    const details = resultDetails(result);
+    if (result.aborted) return { kind: "error", message: `${action}: aborted`, details };
+    if (result.timedOut) {
+      const status = `${action}: timed out after ${timeoutMs}ms`;
+      return { kind: "error", message: output.trim().length > 0 ? `${status}
+
+${output.trim()}` : status, details };
+    }
+    if (result.outputCapped)
+      return {
+        kind: "error",
+        message: output.trim().length > 0 ? `${action}: output exceeded ${maxOutputBytes} bytes
+
+${output.trim()}` : `${action}: output exceeded ${maxOutputBytes} bytes`,
+        details
+      };
+    if (result.exitCode !== 0) {
+      return {
+        kind: "error",
+        message: `${action}: exited with code ${result.exitCode ?? "?"}: ${output.trim()}`,
+        details
+      };
+    }
+    return { kind: "ok", output, details };
+  } catch (err) {
+    return { kind: "error", message: `${action}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var gitTool = {
+  name: ToolNames.Git,
+  description: "Read-only git inspection: op=status (short status), diff, or log (oneline).",
+  parameters: typebox_exports.Object({
+    op: StringEnum(["status", "diff", "log"], { description: "Inspection to run." }),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "Limit diff/log to one path." })),
+    cached: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: staged changes (--cached)." })),
+    stat: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: summary only (--stat)." })),
+    name_only: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: file names only." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "log: commits to show (default 20, max 200)." })),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout in ms (default 120000)." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel",
+  async run(args, options) {
+    const op = typeof args.op === "string" ? args.op : "";
+    const pathArg = typeof args.path === "string" && args.path.length > 0 ? args.path : null;
+    if (op === "status") {
+      return runVectorTool("git", "git", ["status", "--short", "--branch"], args, options);
+    }
+    if (op === "diff") {
+      const vector = ["diff"];
+      if (args.cached === true) vector.push("--cached");
+      if (args.stat === true) vector.push("--stat");
+      if (args.name_only === true) vector.push("--name-only");
+      if (pathArg) vector.push("--", pathArg);
+      return runVectorTool("git", "git", vector, args, options);
+    }
+    if (op === "log") {
+      const limit = typeof args.limit === "number" && args.limit > 0 ? Math.min(200, Math.floor(args.limit)) : 20;
+      const vector = ["log", "--oneline", "-n", String(limit)];
+      if (pathArg) vector.push("--", pathArg);
+      return runVectorTool("git", "git", vector, args, options);
+    }
+    return { kind: "error", message: `git: op must be status, diff, or log; got '${op}'` };
+  }
+};
+
+export {
+  timeoutArg,
+  maxOutputArg,
+  runVectorTool,
+  gitTool,
+  BROWSER_MODES,
+  prepareVerifyArguments,
+  verifyToolSurface
+};
+//# sourceMappingURL=chunk-TZK7PACC.js.map

package/dist/chunk-TZTZS7QK.js

@@ -0,0 +1,227 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  BusChannels,
+  getSharedBus
+} from "./chunk-OQ33BKR3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/termination.ts
+init_esm_shims();
+var DEFAULT_SHUTDOWN_HOOK_MS = 500;
+var SIGNAL_EXIT_CODES = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGTERM: 143
+};
+function wrapToWidth(text, width) {
+  if (!Number.isFinite(width) || width < 1) return [text];
+  const lines = [];
+  let current = "";
+  for (const word of text.split(/\s+/).filter((w) => w.length > 0)) {
+    let token = word;
+    while (token.length > width) {
+      if (current) {
+        lines.push(current);
+        current = "";
+      }
+      lines.push(token.slice(0, width));
+      token = token.slice(width);
+    }
+    if (!current) current = token;
+    else if (current.length + 1 + token.length <= width) current = `${current} ${token}`;
+    else {
+      lines.push(current);
+      current = token;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [""];
+}
+function writeShutdownNotice(text) {
+  const width = process.stderr.columns ?? process.stdout.columns;
+  const lines = width === void 0 ? [text] : wrapToWidth(text, width);
+  process.stderr.write(`${lines.join("\n")}
+`);
+}
+function resolveShutdownHookBudgetMs() {
+  const raw = process.env.CLIO_CODER_SHUTDOWN_HOOK_MS;
+  if (raw === void 0) return DEFAULT_SHUTDOWN_HOOK_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SHUTDOWN_HOOK_MS;
+  return parsed;
+}
+async function runWithBudget(op, budgetMs, onError) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), budgetMs);
+  });
+  try {
+    const done = Promise.resolve().then(() => op()).then(() => "done").catch((err) => {
+      onError?.(err);
+      return "done";
+    });
+    const outcome = await Promise.race([done, timeout]);
+    return outcome === "done";
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var TerminationCoordinator = class {
+  phase = "idle";
+  drainHooks = [];
+  terminateHooks = [];
+  persistHooks = [];
+  exitCode = 0;
+  started = false;
+  drained = false;
+  pendingNotices = [];
+  signalHandler = null;
+  getPhase() {
+    return this.phase;
+  }
+  /**
+   * The process exit code this shutdown will use. Set before any hook runs,
+   * so a hook sealing terminal accounting records the same status the process
+   * reports (130 for SIGINT, 143 for SIGTERM).
+   */
+  getExitCode() {
+    return this.exitCode;
+  }
+  onDrain(hook) {
+    this.drainHooks.push(hook);
+  }
+  onTerminate(hook) {
+    this.terminateHooks.push(hook);
+  }
+  onPersist(hook) {
+    this.persistHooks.push(hook);
+  }
+  async shutdown(code = 0) {
+    if (this.started) return;
+    this.started = true;
+    this.exitCode = code;
+    const bus = getSharedBus();
+    const debug = process.env.CLIO_CODER_DEBUG_SHUTDOWN === "1";
+    const budgetMs = resolveShutdownHookBudgetMs();
+    const mark = debug ? process.hrtime.bigint() : 0n;
+    const log = (msg) => {
+      if (!debug) return;
+      const ms = Number(process.hrtime.bigint() - mark) / 1e6;
+      process.stderr.write(`[clio:shutdown] +${ms.toFixed(1)}ms ${msg}
+`);
+    };
+    this.phase = "draining";
+    bus.emit(BusChannels.ShutdownRequested, { phase: this.phase });
+    log("drain:start");
+    await this.runHooks(this.drainHooks, "drain", budgetMs, log);
+    log("drain:end");
+    this.drained = true;
+    this.flushNotices();
+    bus.emit(BusChannels.ShutdownDrained, {});
+    this.phase = "terminating";
+    log("terminate:start");
+    await this.runHooks(this.terminateHooks, "terminate", budgetMs, log);
+    log("terminate:end");
+    bus.emit(BusChannels.ShutdownTerminated, {});
+    this.phase = "persisting";
+    log("persist:start");
+    await this.runHooks(this.persistHooks, "persist", budgetMs, log);
+    log("persist:end");
+    bus.emit(BusChannels.ShutdownPersisted, {});
+    this.phase = "exiting";
+    bus.emit(BusChannels.SessionEnd, { exitCode: this.exitCode });
+    log("process.exit");
+    process.exit(this.exitCode);
+  }
+  async runHooks(hooks, phase, budgetMs, log) {
+    for (let i = 0; i < hooks.length; i++) {
+      const hook = hooks[i];
+      if (!hook) continue;
+      const t0 = process.hrtime.bigint();
+      const completed = await runWithBudget(hook, budgetMs, (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        writeShutdownNotice(`[clio:termination] ${phase}[${i}] failed: ${message}`);
+        if (err instanceof Error && err.stack) log(err.stack);
+      });
+      const dt = Number(process.hrtime.bigint() - t0) / 1e6;
+      if (!completed) {
+        writeShutdownNotice(`[clio:termination] ${phase}[${i}] exceeded ${budgetMs}ms budget; shutdown continues`);
+      }
+      log(`  ${phase}[${i}] ${dt.toFixed(1)}ms${completed ? "" : " (timed out)"}`);
+    }
+  }
+  /**
+   * SIGHUP is here for the same reason as SIGTERM. Without a listener Node
+   * takes its default action and the process dies with no shutdown at all,
+   * which on a TUI session means the terminal is never given back. Exit codes
+   * follow the 128+signal convention.
+   */
+  installSignalHandlers() {
+    if (this.signalHandler) return;
+    const handler = (signal) => {
+      this.notice(`Clio Coder: received ${signal}, shutting down...`);
+      void this.shutdown(SIGNAL_EXIT_CODES[signal] ?? 143);
+    };
+    this.signalHandler = handler;
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+    process.once("SIGHUP", handler);
+  }
+  /**
+   * Report something the operator should read after the process is gone,
+   * such as which signal ended it. Nothing here knows whether a TUI is on
+   * screen, but it does know that the terminal teardown is a drain hook: so
+   * until drain has finished the notice is held, and the moment it has, the
+   * notice goes to the terminal the TUI just handed back. Written straight
+   * away once drain is over, which is the case for a re-armed SIGINT arriving
+   * mid-shutdown. A second SIGTERM or SIGHUP inside the drain window takes
+   * Node's default action and the held notice dies with the process; that
+   * window is bounded by the per-hook budget and the shell reports the kill.
+   */
+  notice(text) {
+    if (this.drained) {
+      writeShutdownNotice(text);
+      return;
+    }
+    this.pendingNotices.push(text);
+  }
+  flushNotices() {
+    for (const text of this.pendingNotices.splice(0)) writeShutdownNotice(text);
+  }
+  /**
+   * Hand SIGINT to a foreground owner and return the call that takes it back.
+   *
+   * Boot arms this coordinator before any interactive surface exists, and Node
+   * runs signal listeners in registration order, so a TUI that merely added its
+   * own listener would lose every first press to a shutdown already underway.
+   * One owner holds the interrupt at a time and the transfer is explicit.
+   * SIGTERM is not part of the handover; it is never an interactive gesture.
+   */
+  releaseInterruptOwnership() {
+    const handler = this.signalHandler;
+    if (!handler) return () => {
+    };
+    process.off("SIGINT", handler);
+    let restored = false;
+    return () => {
+      if (restored) return;
+      restored = true;
+      process.once("SIGINT", handler);
+    };
+  }
+};
+var coordinator = null;
+function getTerminationCoordinator() {
+  if (!coordinator) coordinator = new TerminationCoordinator();
+  return coordinator;
+}
+
+export {
+  writeShutdownNotice,
+  resolveShutdownHookBudgetMs,
+  runWithBudget,
+  getTerminationCoordinator
+};
+//# sourceMappingURL=chunk-TZTZS7QK.js.map

package/dist/{chunk-ASND7OZK.js → chunk-UFIIWP2H.js}

@@ -1,32 +1,32 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  loadSkills
+} from "./chunk-4BPJXDWC.js";
 import {
   getVersionInfo
 } from "./chunk-XPLRXC72.js";
-import {
-  loadSkills
-} from "./chunk-474KN5II.js";
 import {
   detectInteropAgents,
   fingerprintNativeRuntime,
   resolveOnPath
-} from "./chunk-PV4JUBVJ.js";
+} from "./chunk-2TLUCQVG.js";
 import {
   initializeClioHome
-} from "./chunk-673JJUWJ.js";
-import {
-  interopAgentKind
-} from "./chunk-IHXBNWMM.js";
+} from "./chunk-BMEMKKIT.js";
 import {
   formatSettingsIssues,
   readSettings,
   validateSettingsFile
-} from "./chunk-KY56HMHH.js";
+} from "./chunk-A3CYT5EX.js";
 import {
   openAuthStorage
-} from "./chunk-GB6QRBXN.js";
+} from "./chunk-4VP4KH3K.js";
 import {
   readSessionFileEntries
-} from "./chunk-HQQID6OA.js";
+} from "./chunk-M6SHUN7Q.js";
+import {
+  interopAgentKind
+} from "./chunk-IHXBNWMM.js";
 import {
   clioStatePath,
   resolveClioDirs
@@ -337,7 +337,7 @@ async function runDoctorFleetChecks(projectRoot = process.cwd()) {
   }
   const nodes = settings.fleet?.nodes ?? [];
   if (nodes.length === 0) return [];
-  const { recordFleetPreflight, runFleetNodePreflight } = await import("./fleet-preflight-DSNT37JK.js");
+  const { recordFleetPreflight, runFleetNodePreflight } = await import("./fleet-preflight-DDN536IT.js");
   const targets = (settings.targets ?? []).map((target) => ({
     id: target.id,
     runtimeId: target.runtime,
@@ -437,4 +437,4 @@ export {
   runDoctorInteropChecks,
   runDoctorRuntimeChecks
 };
-//# sourceMappingURL=chunk-ASND7OZK.js.map
+//# sourceMappingURL=chunk-UFIIWP2H.js.map

package/dist/chunk-UOV2BYIW.js

@@ -0,0 +1,107 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/loop-detector.ts
+init_esm_shims();
+var DEFAULT_WINDOW_MS = 3e4;
+var DEFAULT_MAX_REPEATS = 3;
+var DEFAULT_KEEP_LAST_ATTEMPTS = 4;
+function createLoopState(opts) {
+  const windowMs = opts?.windowMs ?? DEFAULT_WINDOW_MS;
+  const maxRepeats = opts?.maxRepeats ?? DEFAULT_MAX_REPEATS;
+  const keepLastAttempts = opts?.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
+  return { recent: [], windowMs, maxRepeats, keepLastAttempts };
+}
+function hashToolCall(tool, args) {
+  let argPart;
+  try {
+    argPart = canonicalSerialize(args ?? {}, /* @__PURE__ */ new WeakSet());
+  } catch {
+    argPart = "<unrepresentable>";
+  }
+  return `${tool}${argPart}`;
+}
+function canonicalSerialize(value, seen) {
+  if (value === null) return "null";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`canonicalSerialize: non-finite number ${String(value)} is not representable`);
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") {
+    throw new Error("canonicalSerialize: bigint is not representable");
+  }
+  if (typeof value === "symbol" || typeof value === "function" || value === void 0) {
+    throw new Error(`canonicalSerialize: ${typeof value} is not representable`);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
+    seen.add(value);
+    try {
+      const parts = [];
+      for (let i = 0; i < value.length; i++) {
+        if (!(i in value) || value[i] === void 0) {
+          parts.push("null");
+          continue;
+        }
+        parts.push(canonicalSerialize(value[i], seen));
+      }
+      return `[${parts.join(",")}]`;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  if (typeof value === "object") {
+    if (value instanceof Date) {
+      const jsonValue = value.toJSON();
+      return jsonValue === null ? "null" : JSON.stringify(jsonValue);
+    }
+    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
+    seen.add(value);
+    const obj = value;
+    try {
+      const keys = Object.keys(obj).sort();
+      const parts = [];
+      for (const key of keys) {
+        const child = obj[key];
+        if (child === void 0) continue;
+        parts.push(`${JSON.stringify(key)}:${canonicalSerialize(child, seen)}`);
+      }
+      return `{${parts.join(",")}}`;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  throw new Error(`canonicalSerialize: unsupported value of type ${typeof value}`);
+}
+function observe(state, key, now) {
+  const cutoff = now - state.windowMs;
+  const keepLast = state.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
+  const appended = [...state.recent, { key, at: now }];
+  const floorStart = Math.max(0, appended.length - keepLast);
+  const next = appended.filter((entry, index) => index >= floorStart || entry.at >= cutoff);
+  let count = 0;
+  for (const entry of next) {
+    if (entry.key === key) count += 1;
+  }
+  const looping = count >= state.maxRepeats;
+  const newState = {
+    recent: next,
+    windowMs: state.windowMs,
+    maxRepeats: state.maxRepeats
+  };
+  return [newState, { looping, key, count }];
+}
+
+export {
+  createLoopState,
+  hashToolCall,
+  observe
+};
+//# sourceMappingURL=chunk-UOV2BYIW.js.map