@indigoai-us/hq-cli 5.345.169 → 5.345.171

package/dist/lib/lanes/stale-lock.js

@@ -0,0 +1,105 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import { randomBytes } from "node:crypto";
+export const DEFAULT_LIVE_OWNER_MAX_MS = 10 * 60_000;
+/** HQ_LANES_LOCK_LIVE_OWNER_MAX_MS overrides the live-owner ceiling. */
+export function liveOwnerMaxMs(env = process.env) {
+    const raw = env.HQ_LANES_LOCK_LIVE_OWNER_MAX_MS;
+    const parsed = raw === undefined ? NaN : Number(raw);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LIVE_OWNER_MAX_MS;
+}
+export function lockOwnerPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code !== "ESRCH";
+    }
+}
+/** Contents to write into a freshly created lock file. */
+export function lockFileContents(hostname = os.hostname()) {
+    return `${process.pid}\n${Date.now()}\n${hostname}\n`;
+}
+function sameFile(a, b) {
+    return a.ino === b.ino && a.dev === b.dev;
+}
+/** Decide whether the lock content/age describes an abandoned lock. */
+export function lockIsStale(raw, mtimeMs, now, hostname, isAlive, options) {
+    const reclaimByAge = options.reclaimByAge ?? true;
+    const [pidLine, tsLine, hostLine] = raw.split("\n");
+    const pid = pidLine ? Number(pidLine) : NaN;
+    const ts = tsLine ? Number(tsLine) : NaN;
+    const pidKnown = Number.isSafeInteger(pid) && pid > 0;
+    // A pid is only meaningful on the host that wrote it.
+    const sameHost = hostLine !== undefined && hostLine.trim() !== "" && hostLine.trim() === hostname;
+    const mtimeAge = now - mtimeMs;
+    const age = Number.isFinite(ts) ? Math.max(now - ts, mtimeAge) : mtimeAge;
+    if (pidKnown && sameHost) {
+        if (!isAlive(pid))
+            return true;
+        return reclaimByAge && age > Math.max(options.liveOwnerMaxMs, options.staleMs);
+    }
+    // A legacy lock (no host line, written by an older CLI) whose pid is alive
+    // here may be a live local holder: give it the live-owner ceiling too.
+    const legacyNoHost = hostLine === undefined || hostLine.trim() === "";
+    if (pidKnown && legacyNoHost && isAlive(pid)) {
+        return reclaimByAge && age > Math.max(options.liveOwnerMaxMs, options.staleMs);
+    }
+    return reclaimByAge && age > options.staleMs;
+}
+/** Remove an abandoned lock atomically. Returns true when this call reclaimed it. */
+export function reclaimStaleLock(lockPath, options, io = {}) {
+    const statSync = io.statSync ?? ((p) => fs.statSync(p));
+    const readFileSync = io.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    const renameSync = io.renameSync ?? fs.renameSync.bind(fs);
+    const unlinkSync = io.unlinkSync ?? fs.unlinkSync.bind(fs);
+    const linkSync = io.linkSync ?? fs.linkSync.bind(fs);
+    const hostname = io.hostname ?? os.hostname;
+    const isAlive = io.isAlive ?? lockOwnerPidAlive;
+    const before = statSync(lockPath);
+    const raw = readFileSync(lockPath, "utf8");
+    if (!lockIsStale(raw, before.mtimeMs, Date.now(), hostname(), isAlive, options))
+        return false;
+    const parked = `${lockPath}.stale.${process.pid}.${randomBytes(6).toString("hex")}`;
+    try {
+        renameSync(lockPath, parked);
+    }
+    catch (renameErr) {
+        // Another reclaimer won the rename, or the holder released it.
+        if (renameErr.code === "ENOENT")
+            return false;
+        throw renameErr;
+    }
+    const removeParked = () => {
+        try {
+            unlinkSync(parked);
+        }
+        catch (unlinkErr) {
+            if (unlinkErr.code !== "ENOENT")
+                throw unlinkErr;
+        }
+    };
+    let reclaimed;
+    try {
+        reclaimed = sameFile(statSync(parked), before) && readFileSync(parked, "utf8") === raw;
+        if (!reclaimed) {
+            // The parked file is a live holder's fresh lock. Put it back.
+            try {
+                linkSync(parked, lockPath);
+            }
+            catch (linkErr) {
+                if (linkErr.code !== "EEXIST")
+                    throw linkErr;
+                process.stderr.write(`${options.label ?? "lanes store"}: could not restore displaced lock ${lockPath}; a newer lock already exists\n`);
+            }
+        }
+    }
+    catch (err) {
+        removeParked();
+        throw err;
+    }
+    removeParked();
+    return reclaimed;
+}
+//# sourceMappingURL=stale-lock.js.map

package/dist/lib/lanes/store.js

@@ -20,6 +20,7 @@ import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, is
 import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_RUNNERS, LANE_WRITERS, } from "./types.js";
 import { laneStories } from "./stories.js";
 import { laneStoryLedgerEnabled, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
+import { liveOwnerMaxMs, reclaimStaleLock } from "./stale-lock.js";
 export const LANES_STORE_REL = path.join("workspace", "lanes");
 export const LANE_RECORDS_DIR = "lanes";
 export const QUESTION_RECORDS_DIR = "questions";
@@ -159,89 +160,23 @@ function wait(ms) {
 function lockPathFor(recordPath) {
     return `${recordPath}.lock`;
 }
-function lockOwnerAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code !== "ESRCH";
-    }
-}
 function sameFile(a, b) {
     return a.ino === b.ino && a.dev === b.dev;
 }
 /**
  * Remove a record lock that no live process holds, and report whether it was
- * removed. A lock is stale when it was written on this host and its owner pid
- * no longer exists, or when it is older than the stale window. Age is the
- * larger of the timestamp age and the file mtime age, so a future or
- * unparseable timestamp still ages out through mtime.
- *
- * Removal is atomic: the lock is renamed to a unique name, which only one
- * reclaimer can win. If the renamed file is not the lock that was inspected
- * (another process reclaimed it and took a fresh lock in between), the fresh
- * lock is linked back into place and nothing is reclaimed.
+ * removed. See stale-lock.ts for the rules; a live same-host holder is kept
+ * until the live-owner ceiling, never by the ordinary stale window.
  */
 function recordLockIsStale(lockPath, deps, reclaimByAge = true) {
-    const statSync = deps.statSync ?? ((p) => fs.statSync(p));
-    const linkSync = deps.linkSync ?? fs.linkSync.bind(fs);
-    const before = statSync(lockPath);
-    const raw = deps.readFileSync(lockPath, "utf8");
-    const [pidLine, tsLine, hostLine] = raw.split("\n");
-    const pid = pidLine ? Number(pidLine) : NaN;
-    const ts = tsLine ? Number(tsLine) : NaN;
-    const pidKnown = Number.isSafeInteger(pid) && pid > 0;
-    // A pid is only meaningful on the host that wrote it. A lock with a foreign
-    // or missing host falls back to the age rule.
-    const sameHost = hostLine !== undefined && hostLine.trim() !== "" && hostLine.trim() === deps.hostname();
-    const now = Date.now();
-    const mtimeAge = now - before.mtimeMs;
-    const age = Number.isFinite(ts) ? Math.max(now - ts, mtimeAge) : mtimeAge;
-    const stale = (pidKnown && sameHost && pid !== process.pid && !lockOwnerAlive(pid)) ||
-        (reclaimByAge && age > lockStaleMs());
-    if (!stale)
-        return false;
-    const parked = `${lockPath}.stale.${process.pid}.${randomBytes(6).toString("hex")}`;
-    try {
-        deps.renameSync(lockPath, parked);
-    }
-    catch (renameErr) {
-        // Another reclaimer won the rename, or the holder released it.
-        if (renameErr.code === "ENOENT")
-            return false;
-        throw renameErr;
-    }
-    const removeParked = () => {
-        try {
-            deps.unlinkSync(parked);
-        }
-        catch (unlinkErr) {
-            if (unlinkErr.code !== "ENOENT")
-                throw unlinkErr;
-        }
-    };
-    let reclaimed;
-    try {
-        reclaimed = sameFile(statSync(parked), before) && deps.readFileSync(parked, "utf8") === raw;
-        if (!reclaimed) {
-            // The parked file is a live holder's fresh lock. Put it back.
-            try {
-                linkSync(parked, lockPath);
-            }
-            catch (linkErr) {
-                if (linkErr.code !== "EEXIST")
-                    throw linkErr;
-                process.stderr.write(`lanes store: could not restore displaced lock ${lockPath}; a newer lock already exists\n`);
-            }
-        }
-    }
-    catch (err) {
-        removeParked();
-        throw err;
-    }
-    removeParked();
-    return reclaimed;
+    return reclaimStaleLock(lockPath, { staleMs: lockStaleMs(), liveOwnerMaxMs: liveOwnerMaxMs(), reclaimByAge }, {
+        statSync: deps.statSync ?? ((p) => fs.statSync(p)),
+        readFileSync: (p, enc) => String(deps.readFileSync(p, enc)),
+        renameSync: deps.renameSync,
+        unlinkSync: deps.unlinkSync,
+        linkSync: deps.linkSync ?? fs.linkSync.bind(fs),
+        hostname: deps.hostname,
+    });
 }
 function withRecordLock(recordPath, deps, fn, timeoutMs = LOCK_TIMEOUT_MS, reclaimByAge = true) {
     const lockPath = lockPathFor(recordPath);

package/dist/lib/mesh/live/daemon/work-subscribe.js

@@ -12,6 +12,33 @@ import { backoffDelayMs, RECONNECT_MIN_DELAY_MS } from "./presence.js";
 import { AGENT_INBOX_PUSH_STATE_BASENAME, SYNC_WAKE_STATE_BASENAME } from "../paths.js";
 export { AGENT_INBOX_PUSH_STATE_BASENAME, SYNC_WAKE_STATE_BASENAME } from "../paths.js";
 const INBOX_PUSH_HEARTBEAT_MS = 5_000;
+const SYNC_WAKE_KEYS = new Set(["v", "type", "vault", "head", "rootId"]);
+const SYNC_WAKE_VAULT = /^(?:prs|cmp|agt)_[0-9A-Za-z]+$/;
+const SYNC_WAKE_ROOT = /^[0-9a-f]{64}$/i;
+function isSyncWakeEnvelope(payload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.isBuffer(payload) ? payload.toString("utf8") : payload);
+    }
+    catch {
+        return false;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return false;
+    const message = parsed;
+    const keys = Object.keys(message);
+    if (keys.length !== SYNC_WAKE_KEYS.size || keys.some((key) => !SYNC_WAKE_KEYS.has(key))) {
+        return false;
+    }
+    return message.v === 1 &&
+        message.type === "vault.head" &&
+        typeof message.vault === "string" &&
+        SYNC_WAKE_VAULT.test(message.vault) &&
+        Number.isSafeInteger(message.head) &&
+        Number(message.head) > 0 &&
+        (message.rootId === null ||
+            (typeof message.rootId === "string" && SYNC_WAKE_ROOT.test(message.rootId)));
+}
 function readWakeSequence(meshRoot, basename, label, onInfo) {
     const target = path.join(meshRoot, basename);
     try {
@@ -260,6 +287,10 @@ export async function startWorkCacheSubscriber(opts) {
                 return;
             }
             if (syncTopic && _topic === syncTopic && syncSubscribed) {
+                if (!isSyncWakeEnvelope(payload)) {
+                    opts.onInfo?.("sync wake ignored (invalid envelope)");
+                    return;
+                }
                 syncWakeSequence += 1;
                 persistSyncState(true);
                 return;

package/dist/lib/notify-recipient.d.ts

@@ -14,9 +14,15 @@ export type DmRecipientKind = "person" | "agent" | "channel" | "group";
  */
 export declare function recipientKindOf(recipient: string): "person" | "agent";
 /**
- * Default audience by recipient: a 1:1 message to a person is for that
- * person (`human`); a message to an agent, a channel or a group is tagged
- * `agent` and folded away from people by default.
+ * Default audience by recipient and caller. A person login always defaults to
+ * `human`: people never send agent-tagged messages. A machine caller (a bot,
+ * an agent or an outpost) sends `human` to a person and `agent` to an agent,
+ * a channel or a group, so those are folded away from people by default.
  */
-export declare function defaultAudienceFor(kind: DmRecipientKind): DmAudience;
+export declare function defaultAudienceFor(kind: DmRecipientKind, machineCaller: boolean): DmAudience;
+/** Server error code for an agent-tagged send from a person login. */
+export declare const PERSON_CANNOT_SEND_AGENT_CODE = "person_cannot_send_agent_message";
+export declare const PERSON_AGENT_AUDIENCE_MESSAGE = "People can only send human messages. Agent messages are sent by agents and bots.";
+/** True when this caller may tag a message with `audience`. */
+export declare function callerMayUseAudience(audience: string | undefined, machineCaller: boolean): boolean;
 //# sourceMappingURL=notify-recipient.d.ts.map

package/dist/lib/notify-recipient.js

@@ -16,11 +16,23 @@ export function recipientKindOf(recipient) {
     return /^agt_/.test(recipient.trim()) ? "agent" : "person";
 }
 /**
- * Default audience by recipient: a 1:1 message to a person is for that
- * person (`human`); a message to an agent, a channel or a group is tagged
- * `agent` and folded away from people by default.
+ * Default audience by recipient and caller. A person login always defaults to
+ * `human`: people never send agent-tagged messages. A machine caller (a bot,
+ * an agent or an outpost) sends `human` to a person and `agent` to an agent,
+ * a channel or a group, so those are folded away from people by default.
  */
-export function defaultAudienceFor(kind) {
+export function defaultAudienceFor(kind, machineCaller) {
+    if (!machineCaller)
+        return "human";
     return kind === "person" ? "human" : "agent";
 }
+/** Server error code for an agent-tagged send from a person login. */
+export const PERSON_CANNOT_SEND_AGENT_CODE = "person_cannot_send_agent_message";
+export const PERSON_AGENT_AUDIENCE_MESSAGE = "People can only send human messages. Agent messages are sent by agents and bots.";
+/** True when this caller may tag a message with `audience`. */
+export function callerMayUseAudience(audience, machineCaller) {
+    if (machineCaller || audience === undefined || audience === "")
+        return true;
+    return audience === "human";
+}
 //# sourceMappingURL=notify-recipient.js.map

package/dist/lib/secret-input-link.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Rendering for `hq secrets generate-link` output.
+ *
+ * The URL is a single-use capability, so every mode prints it exactly once
+ * and never puts the token in a visible label.
+ *
+ * - `text` (default) on a TTY: the URL is wrapped in an OSC-8 hyperlink when
+ *   the terminal supports it, and printed plain otherwise.
+ * - `text` when stdout is not a TTY: unchanged plain output (no escapes), so
+ *   pipes and scripts that grep the URL keep working.
+ * - `markdown`: stdout gets one line, a Markdown inline link; the metadata
+ *   goes to stderr so `| pbcopy` or `$(...)` captures only the link.
+ * - `json`: stdout gets one JSON object with the API fields, nothing else.
+ */
+export type SecretLinkFormat = "text" | "markdown" | "json";
+export declare const SECRET_LINK_FORMATS: readonly SecretLinkFormat[];
+export interface SecretInputLinkData {
+    url: string;
+    expiresAt: string;
+    secretName: string;
+}
+export interface RenderedSecretLink {
+    stdout: string[];
+    stderr: string[];
+}
+export declare function osc8(url: string, label: string): string;
+/**
+ * Best-effort OSC-8 support detection, consulted only when stdout is a TTY.
+ * FORCE_HYPERLINK=1/0 overrides detection on a TTY; it never adds escapes to
+ * non-TTY output.
+ * Unknown terminals get the plain URL, which most terminals auto-link anyway.
+ */
+export declare function supportsHyperlinks(env: NodeJS.ProcessEnv): boolean;
+export declare function stripControlChars(value: string): string;
+export declare function sanitizeSecretInputLinkData(data: SecretInputLinkData): SecretInputLinkData;
+export declare function markdownSecretLink(raw: SecretInputLinkData): string;
+export declare function renderSecretInputLink(raw: SecretInputLinkData, opts: {
+    format: SecretLinkFormat;
+    isTTY: boolean;
+    env: NodeJS.ProcessEnv;
+}): RenderedSecretLink;
+//# sourceMappingURL=secret-input-link.d.ts.map

package/dist/lib/secret-input-link.js

@@ -0,0 +1,93 @@
+/**
+ * Rendering for `hq secrets generate-link` output.
+ *
+ * The URL is a single-use capability, so every mode prints it exactly once
+ * and never puts the token in a visible label.
+ *
+ * - `text` (default) on a TTY: the URL is wrapped in an OSC-8 hyperlink when
+ *   the terminal supports it, and printed plain otherwise.
+ * - `text` when stdout is not a TTY: unchanged plain output (no escapes), so
+ *   pipes and scripts that grep the URL keep working.
+ * - `markdown`: stdout gets one line, a Markdown inline link; the metadata
+ *   goes to stderr so `| pbcopy` or `$(...)` captures only the link.
+ * - `json`: stdout gets one JSON object with the API fields, nothing else.
+ */
+export const SECRET_LINK_FORMATS = ["text", "markdown", "json"];
+const OSC = "\u001b]";
+const ST = "\u001b\\";
+export function osc8(url, label) {
+    return `${OSC}8;;${url}${ST}${label}${OSC}8;;${ST}`;
+}
+/**
+ * Best-effort OSC-8 support detection, consulted only when stdout is a TTY.
+ * FORCE_HYPERLINK=1/0 overrides detection on a TTY; it never adds escapes to
+ * non-TTY output.
+ * Unknown terminals get the plain URL, which most terminals auto-link anyway.
+ */
+export function supportsHyperlinks(env) {
+    const force = env.FORCE_HYPERLINK;
+    if (force !== undefined && force !== "")
+        return force !== "0" && force !== "false";
+    if (env.TERM === "dumb" || env.CI)
+        return false;
+    const program = env.TERM_PROGRAM ?? "";
+    if (["iTerm.app", "WezTerm", "vscode", "ghostty", "Hyper", "Tabby", "rio"].includes(program)) {
+        return true;
+    }
+    if (env.WT_SESSION || env.KITTY_WINDOW_ID || env.KONSOLE_VERSION || env.DOMTERM)
+        return true;
+    const vte = Number.parseInt(env.VTE_VERSION ?? "", 10);
+    if (Number.isFinite(vte) && vte >= 5000)
+        return true;
+    const term = env.TERM ?? "";
+    return /kitty|alacritty|foot|wezterm|ghostty/.test(term);
+}
+/** Percent-encode the characters that would end a Markdown link target early. */
+function markdownTarget(url) {
+    return url.replace(/[()<>\s]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+}
+// C0 (U+0000-U+001F), DEL and C1 (U+0080-U+009F). Server-supplied fields must
+// not be able to inject terminal escapes (ESC, BEL, OSC) or extra lines.
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
+export function stripControlChars(value) {
+    return value.replace(CONTROL_CHARS, "");
+}
+export function sanitizeSecretInputLinkData(data) {
+    return {
+        url: stripControlChars(String(data.url ?? "")),
+        expiresAt: stripControlChars(String(data.expiresAt ?? "")),
+        secretName: stripControlChars(String(data.secretName ?? "")),
+    };
+}
+function markdownLabelText(value) {
+    return value.replace(/[[\]\\]/g, (c) => `\\${c}`);
+}
+export function markdownSecretLink(raw) {
+    const data = sanitizeSecretInputLinkData(raw);
+    const label = `Submit ${markdownLabelText(data.secretName)} (expires ${markdownLabelText(data.expiresAt)}) ›`;
+    return `[${label}](${markdownTarget(data.url)})`;
+}
+export function renderSecretInputLink(raw, opts) {
+    const data = sanitizeSecretInputLinkData(raw);
+    const meta = [
+        `  Secret:  ${data.secretName}`,
+        `  Expires: ${data.expiresAt}`,
+        "  One-time use — link is invalidated after first submission.",
+    ];
+    if (opts.format === "json") {
+        return {
+            stdout: [JSON.stringify({ url: data.url, expiresAt: data.expiresAt, secretName: data.secretName })],
+            stderr: [],
+        };
+    }
+    if (opts.format === "markdown") {
+        return { stdout: [markdownSecretLink(data)], stderr: meta };
+    }
+    const shown = opts.isTTY && supportsHyperlinks(opts.env) ? osc8(data.url, data.url) : data.url;
+    return {
+        stdout: ["Secret input link generated:", `\n  ${shown}\n`, ...meta],
+        stderr: [],
+    };
+}
+//# sourceMappingURL=secret-input-link.js.map

package/dist/lib/secret-scan/range.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Range scan: the lines a branch added between <base> and <head>, as
+ * `commit-secret-scan.sh pr-check` needs them.
+ *
+ * What is scanned:
+ *   - The added lines of every non-merge commit in base..head, each against
+ *     its own parent. A secret committed in one commit and deleted in a later
+ *     one is still reported: it stays in the branch history.
+ *   - For every merge commit in base..head, the lines that differ from all of
+ *     its parents (git's combined diff, "++" lines): content the merge itself
+ *     introduced, such as a conflict resolution. Lines a merge only carries
+ *     over from one parent are either base content or scanned in that
+ *     parent's own commits.
+ *   - The added lines of the net diff merge-base(base, head)..head.
+ *   - Binary files those diffs add or change: path rules, plus their bytes
+ *     scanned as text up to MAX_BINARY_BYTES (larger ones are warned about).
+ * Lines that already existed on the base, and earlier versions of lines the
+ * branch did not touch, are not scanned.
+ *
+ * Config comes from the repo's .gitleaks.toml:
+ *   - Allowlists: the exact-value exemptions committed on the base (the same
+ *     contract as `scan secrets --repo --allowlist-rev`). A branch cannot
+ *     exempt its own commits by adding an allowlist.
+ *   - Rules: [[rules]] committed on the base, added to the built-in rules.
+ *     Rules the branch adds or changes are not compiled or run: a branch-added
+ *     regex could be written to backtrack for minutes (ReDoS), and the base
+ *     copy has been reviewed.
+ * A rejected allowlist or rules section is warned about and dropped; the scan
+ * still runs with the built-in rules (stricter, never looser).
+ *
+ * Range errors: an unknown rev, a reversed range (head behind base) and a
+ * merge-base failure other than "no common history" exit 2. base == head is an
+ * empty range: a warning and no findings.
+ */
+import { type Fragment } from "./detect.js";
+import type { SecretFinding } from "./types.js";
+export declare const RULES_IGNORED_WARNING = "HQ secret scan: warning: the repo .gitleaks.toml [[rules]] were rejected; scanning with the built-in rules only";
+export declare const EMPTY_RANGE_WARNING = "HQ secret scan: warning: the range is empty (base and head are the same commit); nothing to scan";
+/** Binary blobs larger than this are not read; the scan warns instead. */
+export declare const MAX_BINARY_BYTES: number;
+/** `<base>..<head>` or `<base>` (head = HEAD). A three-dot range is rejected: the net diff is always taken from the merge base. */
+export declare function parseRange(range: string): {
+    base: string;
+    head: string;
+};
+/**
+ * Lines a merge introduced, from `git diff-tree --cc` output: a line counts
+ * only when every parent column is "+", i.e. it is in none of the parents.
+ */
+export declare function parseCombinedDiff(diff: string): Fragment[];
+/**
+ * Findings for the lines added on <head> since <base>. A finding from a
+ * commit that the net diff no longer shows is named `<file>@<commit12>`, so
+ * the reader can find the version that held it.
+ */
+export declare function scanRange(cwd: string, range: string): SecretFinding[];
+//# sourceMappingURL=range.d.ts.map