howtofixcli 0.7.8 → 0.7.9

package/dist/hud-line.js

@@ -1,153 +0,0 @@
-import { formatAge } from "./workflow-progress.js";
-import { levelInk } from "./level-style.js";
-import { fg } from "./theme.js";
-const RESET = "\x1b[0m";
-const DIM = "\x1b[2m";
-const BOLD = "\x1b[1m";
-const RED = "\x1b[31m";
-const GREEN = "\x1b[32m";
-const YELLOW = "\x1b[33m";
-const MAGENTA = "\x1b[35m";
-const CYAN = "\x1b[36m";
-function paint(text, color) {
-    return `${color}${text}${RESET}`;
-}
-/**
- * Paint a thinking level in its own colour.
- *
- * Goes through `fg()` rather than emitting an escape here, so the level obeys the
- * same colour mode as the rest of the interface: on a terminal without 24-bit
- * colour it becomes the nearest 256-cube index instead of an escape the terminal
- * ignores. Split out from `sessionLine` because the caller may already have styled
- * the level (a shimmer band sweeps it at the ceiling) and must pass that through
- * untouched — re-colouring a string that already carries escapes nests them.
- */
-export function paintLevel(text, level) {
-    return fg(text, levelInk(level));
-}
-function contextColor(percent) {
-    if (percent >= 85)
-        return RED;
-    if (percent >= 70)
-        return YELLOW;
-    return GREEN;
-}
-/**
- * The mark before the thinking level, in place of the word "thinking".
- *
- * Not 🧠: U+1F9E0 carries the Unicode Emoji property and is present in **no**
- * monospace font on this box (only Apple Color Emoji and LastResort), so it
- * renders as a colour glyph at best and tofu at worst. `✦` (U+2726) is outside
- * the Emoji set, comes from Menlo/Courier and the other monospace faces here, and
- * reads as "the model is thinking" without a word.
- */
-export const THINKING_MARK = "✦";
-/**
- * The session row: model, thinking level, project, branch.
- *
- * `thinking` arrives already styled. That is the caller's job because the level
- * has two looks — its own colour, and a shimmer band when it is at the model's
- * ceiling — and only the caller knows which one applies. What this function owns
- * is the mark and where the level sits on the line.
- */
-export function sessionLine(model, thinking, folder, git) {
-    const badge = paint(`[${model}]`, CYAN);
-    const level = `${paint(THINKING_MARK, DIM)} ${thinking}`;
-    const project = paint(folder, YELLOW);
-    const branch = git ? ` ${paint("git:(", MAGENTA)}${paint(git.replace(/^git:\(/, "").replace(/\)$/, ""), CYAN)}${paint(")", MAGENTA)}` : "";
-    return `${badge}${paint(" │ ", DIM)}${level}${paint(" │ ", DIM)}${project}${branch}`;
-}
-/**
- * Prefix a HUD row with the running spinner and how long it has been running.
- *
- * It sits on the row that already carries the model, so the two facts that change
- * during a run — what the model is, and that it is working — are read together,
- * and the spinner glyph is painted here, at draw time, from the caller's clock. A
- * glyph captured when an event arrived is frozen exactly while the model is
- * quiet, which is the one stretch a spinner is for.
- *
- * `waitedMs` is a duration, not a formatted string: the unit switch (seconds →
- * minutes → hours) belongs with the rest of the duration formatting, and this
- * function is about where the clock sits on the line.
- */
-export function withSpinner(line, frame, waitedMs) {
-    if (!frame)
-        return line;
-    const clock = waitedMs === undefined ? frame : `${frame} ${paint(formatAge(waitedMs), DIM)}`;
-    return `${paint(clock, CYAN)} ${paint("│", DIM)} ${line}`;
-}
-/**
- * The context meter and whatever segments belong beside it.
- *
- * Segments are variadic and empty ones are dropped, so a caller passes the
- * rows it has and never has to know which of them are showing anything right
- * now: the balance arrives asynchronously and the spend is zero until the
- * first turn, and both would otherwise need a conditional at every call site.
- */
-export function contextLine(percent, ...segments) {
-    const safe = Number.isFinite(percent) ? Math.min(100, Math.max(0, percent)) : 0;
-    const filled = Math.round(safe / 10);
-    const color = contextColor(safe);
-    const bar = `${color}${"█".repeat(filled)}${DIM}${"░".repeat(10 - filled)}${RESET}`;
-    const value = paint(`${Math.round(safe)}%`, color);
-    const balance = segments.filter(Boolean).join(paint(" │ ", DIM));
-    return `${paint("Context", DIM)} ${bar} ${value}${balance ? `${paint(" │ ", DIM)}${balance}` : ""}`;
-}
-/**
- * The session's spend so far, as a segment of the context row.
- *
- * A fresh session draws nothing: "$0.000" is a number nobody asked for, and a
- * value that is always present is a value that stops being read. The precision
- * is the SDK footer's (`$0.123`) rather than `/stats`'s four digits - this is
- * read at a glance while the model works, and a session rarely spends enough
- * for the last digit to mean anything.
- */
-export function costSegment(costUsd) {
-    if (!Number.isFinite(costUsd) || costUsd <= 0)
-        return "";
-    return `${paint("Spent", DIM)} ${paint(`$${costUsd.toFixed(3)}`, GREEN)}`;
-}
-/**
- * The `/usage` panel: the account's quota as a bar, the way the context line
- * shows the window.
- *
- * A number alone ("6.50 USD left") makes the reader do the division before they
- * can tell whether it matters. The bar is the answer to that question, and the
- * percentage is its exact form; the two belong together for the same reason the
- * context line carries both.
- *
- * The thresholds are `contextColor`'s, so "how full is this" reads the same on
- * both rows: green under 70%, yellow to 84%, red at 85% and above. A quota that
- * is 85% spent is the one worth acting on, and a colour that meant something
- * different here would be worse than no colour.
- *
- * There is deliberately no reset countdown. Claude Code has one because its
- * windows expire on a schedule; howtofix.id reports a balance and no window
- * end, so a countdown would have to be invented rather than read.
- */
-export function quotaLines(provider, limit, used, unit) {
-    const safeLimit = Number.isFinite(limit) && limit > 0 ? limit : 0;
-    const safeUsed = Number.isFinite(used) ? Math.max(0, used) : 0;
-    const remaining = Math.max(0, safeLimit - safeUsed);
-    // A zero limit is the unlimited case at the call site, but a division here
-    // would still produce NaN and paint "NaN%" on the row.
-    const percent = safeLimit > 0 ? Math.min(100, (safeUsed / safeLimit) * 100) : 0;
-    const filled = Math.round(percent / 10);
-    const color = contextColor(percent);
-    const bar = `${color}${"█".repeat(filled)}${DIM}${"░".repeat(10 - filled)}${RESET}`;
-    const money = (value) => `${value.toFixed(2)} ${unit}`;
-    // The widths are fixed so the numbers line up between the two states of the
-    // panel; a ragged column is harder to scan than a padded one.
-    return [
-        `${paint(provider, BOLD)}${paint(" account", DIM)}`,
-        `  ${paint("used", DIM)}       ${bar} ${paint(`${percent.toFixed(1)}%`, color)}`,
-        `  ${paint("granted", DIM)}    ${money(safeLimit)}`,
-        `  ${paint("spent", DIM)}      ${money(safeUsed)}`,
-        `  ${paint("remaining", DIM)}  ${paint(money(remaining), color)}`,
-    ];
-}
-export function usageSegment(balance, unit, latencyMs) {
-    const latency = latencyMs === null ? "" : paint(` ${latencyMs}ms`, DIM);
-    const label = unit && unit !== "USD" ? `${unit} ` : "";
-    return `${paint("Balance", DIM)} ${paint(`${label}${balance}`, GREEN)}${latency}`;
-}

package/dist/hwid.js

@@ -1,130 +0,0 @@
-/**
- * The machine's own id, where the OS keeps one.
- *
- * The panel already receives a fingerprint, but until now that fingerprint was
- * built from the hostname, the platform, the username and the CPU model — none
- * of which is hardware. Two different machines built from the same image
- * produce the same value, and one machine changes it by renaming itself. That
- * leaves the panel's device list unable to answer the one question it exists
- * for: is this the same computer as before, or a different one?
- *
- * Measured on the live panel: one physical box had already produced two device
- * sessions and two access tokens under the same fingerprint, because each
- * sign-in mints a fresh `device_id` and nothing tied it back to the machine.
- *
- * So this module reads the identifier the OS keeps for the machine itself:
- *
- *   linux   /etc/machine-id, then /var/lib/dbus/machine-id, then the DMI
- *           product UUID (a firmware value, not a name)
- *   win32   HKLM\SOFTWARE\Microsoft\Cryptography\MachineGuid
- *   darwin  IOPlatformUUID from `ioreg`
- *
- * The value never leaves the process raw. What is hashed into the fingerprint
- * is an HMAC over it, so the panel can match a machine across runs without ever
- * being handed the machine's serial number.
- *
- * The honest limits, stated where they belong:
- *
- *   - A container that mounts no machine-id and exposes no DMI falls back to the
- *     hostname hash, and that is weak. The source is reported rather than
- *     hidden, so a weak id is visibly weak instead of silently indistinguishable
- *     from a strong one.
- *   - Anyone with root can change /etc/machine-id. This raises the cost of
- *     passing one machine off as many; it is not a wall. A wall needs a secret
- *     the panel issues once, which is what the device session already is.
- */
-import { execFileSync } from "node:child_process";
-import { createHmac } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { arch, cpus, hostname, platform, userInfo } from "node:os";
-/**
- * Domain separation for the HMAC. A digest computed for one purpose must never
- * be presentable as another, and this keeps the hwid out of the same space as
- * the panel's other HMACs.
- */
-const HWID_DOMAIN = "howtofix-cli-hwid-v1";
-/** Read a file and return its trimmed contents, or undefined. Never throws. */
-function readTrimmed(path) {
-    try {
-        const value = readFileSync(path, "utf8").trim();
-        return value.length > 0 ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Run a command and return its stdout, or undefined. Never throws, never waits long. */
-function run(command, args) {
-    try {
-        const out = execFileSync(command, args, { encoding: "utf8", timeout: 3_000, stdio: ["ignore", "pipe", "ignore"] });
-        return out.trim().length > 0 ? out.trim() : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * The raw machine identifier, with its source, or undefined when the OS exposes
- * none.
- *
- * Order matters: a machine-id is the OS's own identity for the install, a DMI
- * product UUID is the firmware's for the board, and both outrank a name.
- */
-export function readMachineIdentity() {
-    const os = platform();
-    if (os === "linux") {
-        // The canonical install id. Present on systemd hosts and on most container
-        // images; on a host without it, dbus keeps its own copy of the same value.
-        const machineId = readTrimmed("/etc/machine-id");
-        if (machineId)
-            return { value: machineId, source: "machine-id", strong: true };
-        const dbusId = readTrimmed("/var/lib/dbus/machine-id");
-        if (dbusId)
-            return { value: dbusId, source: "dbus-machine-id", strong: true };
-        // The firmware's id for the board. Readable without root on most kernels.
-        const productUuid = readTrimmed("/sys/class/dmi/id/product_uuid");
-        if (productUuid)
-            return { value: productUuid, source: "dmi-product-uuid", strong: true };
-        return undefined;
-    }
-    if (os === "win32") {
-        // The value Windows itself uses as the machine identity. `reg query` prints
-        // "    MachineGuid    REG_SZ    <guid>", so the guid is the last field.
-        const out = run("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"]);
-        const match = out?.match(/MachineGuid\s+REG_SZ\s+(\S+)/i);
-        if (match?.[1])
-            return { value: match[1], source: "windows-machine-guid", strong: true };
-        return undefined;
-    }
-    if (os === "darwin") {
-        // IOPlatformUUID is the Mac's hardware identity.
-        const out = run("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
-        const match = out?.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
-        if (match?.[1])
-            return { value: match[1], source: "platform-uuid", strong: true };
-        return undefined;
-    }
-    return undefined;
-}
-/**
- * The machine id this build reports, with the strength of its source.
- *
- * The fallback is the same hostname/platform/CPU tuple the fingerprint used
- * before this module existed, so a machine with no OS identity behaves exactly
- * as it did — but it is now labelled `strong: false` instead of being
- * indistinguishable from a hardware id.
- */
-export function resolveHwid() {
-    const identity = readMachineIdentity();
-    const raw = identity?.value ?? [hostname(), platform(), arch(), userInfo().username].join("\u0000");
-    const source = identity?.source ?? "hostname";
-    return {
-        id: createHmac("sha256", HWID_DOMAIN).update(raw).digest("hex").slice(0, 32),
-        source,
-        strong: identity?.strong ?? false,
-    };
-}
-/** The parts the fingerprint hashes, with the machine id first so it dominates. */
-export function fingerprintParts(hwid) {
-    return [hwid.id, hwid.source, hostname(), platform(), arch(), userInfo().username, String(cpus().length), cpus()[0]?.model ?? ""];
-}

package/dist/interrupt.js

@@ -1,60 +0,0 @@
-/**
- * Whether a raw terminal sequence is a Ctrl+C, in every form a terminal sends it.
- *
- * The workbench runs in raw mode and handles Ctrl+C itself, so Node never sees
- * the SIGINT it would otherwise raise. That only holds for the form the key
- * matcher recognises. Three forms are in use:
- *
- *   - the raw byte 0x03, which is what a terminal sends with no keyboard
- *     protocol negotiated;
- *   - Kitty's CSI-u sequence, `\x1b[<codepoint>;<modifier>u`, where 99 is "c"
- *     and 5 is the ctrl modifier;
- *   - xterm's modifyOtherKeys, `\x1b[27;<modifier>;<codepoint>~`, same numbers.
- *
- * A Windows terminal that reports the enhanced form sends a sequence the key
- * matcher does not know. The byte never matches, the handler never consumes it,
- * and the process is left to Node's default, which is to exit. That is the
- * close that looks like a Ctrl+C nobody pressed twice.
- *
- * The check is deliberately wider than the key matcher: a false positive here
- * costs one keystroke, a miss costs the whole session.
- */
-const CTRL_C_BYTE = String.fromCharCode(3);
-/** "c" is codepoint 99, and the ctrl modifier is reported as 5. */
-const CTRL_MODIFIER = 5;
-const C_CODEPOINT = 99;
-export function isInterrupt(data) {
-    if (data === CTRL_C_BYTE)
-        return true;
-    // Kitty keyboard protocol: CSI codepoint ; modifier u.
-    const kitty = /^\x1b\[(\d+);(\d+)u$/.exec(data);
-    if (kitty && Number(kitty[1]) === C_CODEPOINT && (Number(kitty[2]) & CTRL_MODIFIER) !== 0)
-        return true;
-    // xterm modifyOtherKeys: CSI 27 ; modifier ; codepoint ~.
-    const modifyOther = /^\x1b\[27;(\d+);(\d+)~$/.exec(data);
-    if (modifyOther && Number(modifyOther[2]) === C_CODEPOINT && (Number(modifyOther[1]) & CTRL_MODIFIER) !== 0)
-        return true;
-    return false;
-}
-/**
- * Keep a SIGINT from killing the process outright.
- *
- * Raw mode is supposed to stop the terminal sending SIGINT at all, but a
- * Windows console and a terminal that resets its mode on resize both still do.
- * Node's default for an unhandled SIGINT is to exit immediately, which skips
- * the shutdown path: no MCP servers are stopped, no session is disposed, and
- * the screen is left in raw mode. Handing it to the same function a keypress
- * uses means the close looks the same however it arrived.
- *
- * Idempotent: a second signal while the first shutdown is running must not
- * start another.
- */
-export function catchInterrupt(onInterrupt) {
-    let handled = false;
-    process.on("SIGINT", () => {
-        if (handled)
-            return;
-        handled = true;
-        onInterrupt();
-    });
-}

package/dist/json-events.js

@@ -1,50 +0,0 @@
-function isAssistantMessageUpdate(event) {
-    return event.type === "message_update";
-}
-/**
- * A delta event, with the cumulative `partial` removed. `toolcall_start` keeps
- * the tool's id and name, which the delta itself does not carry.
- */
-function toJsonAssistantMessageEvent(event) {
-    if (event.type === "toolcall_start") {
-        const index = event.contentIndex;
-        const part = index === undefined ? undefined : event.partial?.content[index];
-        const toolCall = part;
-        if (toolCall?.type !== "toolCall") {
-            // Dropped rather than thrown: see the module comment.
-            return undefined;
-        }
-        const { partial: _partial, ...delta } = event;
-        return { ...delta, id: toolCall.id, toolName: toolCall.name };
-    }
-    if (!("partial" in event))
-        return event;
-    const { partial: _partial, ...delta } = event;
-    return delta;
-}
-/**
- * One session event in the wire shape. Returns `undefined` for the events that
- * cannot be represented (a malformed update), so the caller skips them instead
- * of writing a line that is not JSON.
- */
-export function toJsonEvent(event) {
-    if (!isAssistantMessageUpdate(event))
-        return event;
-    if (event.message.role !== "assistant")
-        return undefined;
-    const assistantMessageEvent = toJsonAssistantMessageEvent(event.assistantMessageEvent);
-    if (assistantMessageEvent === undefined)
-        return undefined;
-    return {
-        type: "message_update",
-        usage: event.message.usage,
-        assistantMessageEvent,
-    };
-}
-/** The line to write for an event, or `undefined` when it has no wire shape. */
-export function jsonLine(event) {
-    const shaped = toJsonEvent(event);
-    if (shaped === undefined)
-        return undefined;
-    return `${JSON.stringify(shaped)}\n`;
-}

package/dist/level-style.js

@@ -1,112 +0,0 @@
-/**
- * How a thinking level looks: its colour, and how it answers a change.
- *
- * The level used to be one thing — the word, painted dim, identical at `off` and
- * at `max`. That is a reading problem, not a decoration problem: the level is the
- * one setting that changes what every request costs, and the HUD is where it is
- * read. Colouring it means a glance tells you where you are.
- *
- * Three rules hold this together, and each of them is here because the obvious
- * alternative is wrong:
- *
- * 1. **The word stays.** Colour is a second cue, never the only one. The word is
- *    legible in a monochrome terminal, in `screen`, in a screenshot, and to a
- *    reader with red-green colour vision deficiency — the colour is not.
- *
- * 2. **The ramp is in OKHSL, not RGB.** Interpolating hue in RGB is what produces
- *    the muddy, "off" middle that makes a gradient look cheap. OKHSL keeps
- *    perceptual lightness even as hue swings from blue to orange, which is why the
- *    steps below read as one family rather than as seven unrelated colours.
- *
- * 3. **No new glyphs.** A gauge of dots beside the level was the obvious design
- *    and it was measured and dropped: the HUD line already reaches 89 columns with
- *    a real model name, so a four-column gauge pushes it past 80 and wraps the
- *    footer on a default terminal. The level's own width is already paid for.
- *
- * The 256-colour indices below were not chosen by eye — they were computed by
- * quantising each value through the terminal's own cube, because the first
- * hand-picked ramp collapsed to *six* distinct colours with `medium` and `high`
- * both landing on 68. A ramp that is beautiful in truecolor and ambiguous in 256
- * is a regression for exactly the terminals this had to stay safe on.
- */
-import { parseColor } from "@netrodev/hxf-tui";
-/**
- * One colour per level, low to high: a desaturated slate at `off`, then blue →
- * indigo → violet → magenta → orange.
- *
- * `off` is deliberately outside the ramp. It is not "the lowest amount of
- * thinking", it is thinking switched off, and giving it the ramp's first hue
- * would invite reading it as a low setting.
- */
-const LEVEL_INK = {
-    // `off` is lifted to 46% rather than the ramp's darker end: at 36% it measured a
-    // 2.35:1 contrast ratio against the panel background, which is below the 3:1
-    // floor for legible text — the one level that is *most* often the current one was
-    // also the hardest to read.
-    off: parseColor("okhsl(230 12% 46%)"),
-    minimal: parseColor("okhsl(240 55% 49%)"),
-    low: parseColor("okhsl(252 60% 55%)"),
-    medium: parseColor("okhsl(270 64% 60%)"),
-    high: parseColor("okhsl(298 70% 64%)"),
-    xhigh: parseColor("okhsl(332 80% 66%)"),
-    max: parseColor("okhsl(42 95% 64%)"),
-};
-/**
- * The same hues, lifted and desaturated: what a level flashes as the moment it
- * changes.
- *
- * A change has to be visible without the word being re-read, and the change is
- * often a single keypress. Mixing toward this rather than toward white keeps the
- * flash inside the ramp's own character — a white flash is how several themes
- * read an error, and raising the effort is not an error.
- */
-const LEVEL_FLASH = {
-    off: parseColor("okhsl(230 14% 64%)"),
-    minimal: parseColor("okhsl(240 60% 64%)"),
-    low: parseColor("okhsl(252 64% 68%)"),
-    medium: parseColor("okhsl(270 68% 72%)"),
-    high: parseColor("okhsl(298 74% 76%)"),
-    xhigh: parseColor("okhsl(332 82% 78%)"),
-    max: parseColor("okhsl(42 96% 76%)"),
-};
-/** The colour a level is drawn in. Unknown names fall back to `medium`. */
-export function levelInk(level) {
-    return LEVEL_INK[level] ?? LEVEL_INK.medium;
-}
-/**
- * The ramp as a sequence, low to high, for surfaces that want to show the whole
- * ladder at once rather than one rung of it.
- *
- * `off` is not in it: it is not the bottom of the ladder, it is the ladder put
- * away, and a spectrum that started at a desaturated slate would read as a dim
- * ramp rather than as "no thinking".
- */
-export const LEVEL_RAMP = [LEVEL_INK.minimal, LEVEL_INK.low, LEVEL_INK.medium, LEVEL_INK.high, LEVEL_INK.xhigh, LEVEL_INK.max];
-/** The colour a level flashes toward while a change is still fresh. */
-export function levelFlash(level) {
-    return LEVEL_FLASH[level] ?? LEVEL_FLASH.medium;
-}
-/**
- * How long a level change stays lit.
- *
- * The glint crosses a span of `word + 2 * GLIMMER_PAD` characters, one character
- * per frame, so the travel is `span * tick`. The workbench repaints at 30 fps, so
- * a six-letter level is 14 steps of 33 ms — about 460 ms, with the light on the
- * word for most of it. The first version was 320 ms, set for a blurred band,
- * which made the sharper one a flicker — long enough to see that something
- * happened, too short to see what it was. It still finishes well inside the pause
- * between two keystrokes of a run up the ladder.
- */
-export const LEVEL_FLASH_MS = 460;
-/**
- * How far through the flash we are, 1 at the instant of the change down to 0.
- *
- * `ageMs` is passed in rather than read from the clock so the caller owns time:
- * this is called from `render()`, which must not depend on when it was called for
- * anything but the effect.
- */
-export function flashLevel(ageMs) {
-    if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs >= LEVEL_FLASH_MS)
-        return 0;
-    return 1 - ageMs / LEVEL_FLASH_MS;
-}

package/dist/loop-guard.js

@@ -1,95 +0,0 @@
-/**
- * Stops an agent from repeating the same tool call until the budget is gone.
- *
- * Why this exists: every harness in this space has the same field report. The
- * most-discussed agent-quality complaints on the competitor trackers are loops,
- * not crashes — "stuck in loop of verification", "gemini stuck in thinking loop
- * for hours", "agent repeatedly runs broad searches causing massive context
- * overflow", "auto-compaction infinite loop". A model that re-issues an identical
- * call is not making progress, and nothing in the SDK or the session stops it: it
- * will happily burn the whole context and the whole budget first.
- *
- * The shape: guard the same failure with a small retry cap and a "no-progress
- * dead end" that gives up instead of retrying forever. Applied to tool calls, which
- * is where the user actually pays for it.
- *
- * The rule: the same tool called with the same arguments `REPEAT_LIMIT` times in
- * a row is refused, with a reason that says what to do instead. A call with
- * different arguments is progress and resets that tool's counter, and the whole
- * guard resets when a new run starts, so repeating something across two prompts
- * is fine.
- *
- * Deliberately exempt: `think`. It is a pure reasoning channel with no side
- * effect, and re-using the same thought is sometimes how a model gets unstuck.
- *
- * Pure state, no session needed — the policy is testable on its own.
- */
-/** Consecutive identical calls allowed before the guard refuses. */
-export const REPEAT_LIMIT = 3;
-/** Tools whose repetition is harmless and sometimes deliberate. */
-const EXEMPT = new Set(["think"]);
-/**
- * The last non-exempt call, and how many times in a row it has been issued.
- *
- * Only *uninterrupted* repetition counts. A single counter (rather than one per
- * tool) is deliberate: `read → edit → read` to verify an edit is a normal
- * workflow, and a per-tool counter would see two reads and keep counting toward
- * a refusal. Any call that differs from the last one is progress and restarts
- * the chain.
- */
-let last;
-/**
- * A stable key for a call. Argument key order is normalised, because the same
- * call can arrive with its keys in a different order and must still count as a
- * repeat.
- */
-function signatureOf(input) {
-    const seen = new WeakSet();
-    const normalise = (value) => {
-        if (value === null || typeof value !== "object")
-            return value;
-        if (seen.has(value))
-            return "[circular]";
-        seen.add(value);
-        if (Array.isArray(value))
-            return value.map(normalise);
-        const record = value;
-        const sorted = {};
-        for (const key of Object.keys(record).sort())
-            sorted[key] = normalise(record[key]);
-        return sorted;
-    };
-    try {
-        return JSON.stringify(normalise(input)) ?? "";
-    }
-    catch {
-        return "";
-    }
-}
-/**
- * Record a call and report whether it has now repeated too often.
- *
- * Returns `undefined` while the call may proceed. Once the same call has been
- * issued `REPEAT_LIMIT` times without anything else in between, returns the
- * count so the caller can refuse it and say why.
- */
-export function noteToolCall(toolName, input) {
-    // An exempt tool is invisible to the guard: it neither counts as a repeat nor
-    // breaks a chain, so `think → read → think → read` is still a read loop.
-    if (EXEMPT.has(toolName))
-        return undefined;
-    const signature = `${toolName}\u0000${signatureOf(input)}`;
-    const count = last && last.signature === signature ? last.count + 1 : 1;
-    last = { signature, count };
-    return count >= REPEAT_LIMIT ? { repeats: count } : undefined;
-}
-/** Forget the chain. Called when a new run starts, so a new prompt starts clean. */
-export function resetLoopGuard() {
-    last = undefined;
-}
-/** The refusal message. It must tell the model what to do differently, not just "no". */
-export function repeatRefusal(toolName, repeats) {
-    return (`Refused: ${toolName} has been called ${repeats} times in a row with identical arguments, ` +
-        "so the last attempt cannot have changed anything. Do not repeat it. Either use different " +
-        "arguments, use a different tool, or stop and report what you found and what is blocking you.");
-}

package/dist/lsp-tools.js

@@ -1,32 +0,0 @@
-import { StringEnum } from "@netrodev/hxf-ai";
-import { defineTool } from "@netrodev/hxf-coding-agent";
-import { Type } from "typebox";
-import { askLsp } from "./lsp.js";
-export const lspTool = defineTool({
-    name: "lsp",
-    label: "lsp",
-    description: "Language-server query: definition, references, hover, symbols, or diagnostics for a file. Line is 1-based. Does not edit. If the server binary is missing the result says so; do not pretend grep is a substitute without telling the user.",
-    promptSnippet: "lsp: definition, references, hover, symbols, diagnostics",
-    parameters: Type.Object({
-        action: StringEnum(["diagnostics", "definition", "references", "hover", "symbols"], {
-            description: "Which language-server query to run",
-        }),
-        file: Type.String({ description: "File to query, relative to the project root" }),
-        line: Type.Optional(Type.Number({ description: "1-based line (definition, references, hover)" })),
-        symbol: Type.Optional(Type.String({ description: "Substring to locate on that line when column is omitted" })),
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-        const result = await askLsp({
-            action: params.action,
-            file: params.file,
-            line: params.line,
-            symbol: params.symbol,
-            // The session project root: the server's rootUri and the child's cwd.
-            root: ctx.cwd,
-        });
-        if (!result.ok) {
-            return { content: [{ type: "text", text: result.error }], details: { error: result.error }, isError: true };
-        }
-        return { content: [{ type: "text", text: result.text }], details: { action: params.action, count: result.count } };
-    },
-});