@indigoai-us/hq-cli 5.345.54 → 5.345.56

package/dist/lanes-drain-hook.js

@@ -17,7 +17,7 @@ function parseHookInput(text) {
         throw new Error("invalid_hook_input_shape: expected a JSON object");
     }
     const value = parsed;
-    for (const key of ["transcript_path", "session_id", "hook_event_name"]) {
+    for (const key of ["transcript_path", "session_id", "hook_event_name", "hookEventName"]) {
         if (value[key] !== undefined && value[key] !== null && typeof value[key] !== "string") {
             throw new Error(`invalid_hook_input_field: ${key} must be a string`);
         }
@@ -25,7 +25,11 @@ function parseHookInput(text) {
     return {
         ...(typeof value.transcript_path === "string" ? { transcript_path: value.transcript_path } : {}),
         ...(typeof value.session_id === "string" ? { session_id: value.session_id } : {}),
-        ...(typeof value.hook_event_name === "string" ? { hook_event_name: value.hook_event_name } : {}),
+        ...(typeof value.hook_event_name === "string"
+            ? { hook_event_name: value.hook_event_name }
+            : typeof value.hookEventName === "string"
+                ? { hookEventName: value.hookEventName }
+                : {}),
     };
 }
 function laneIdIsSafe(laneId) {

package/dist/lib/daemon/conflict-notices.d.ts

@@ -0,0 +1,4 @@
+export declare function conflictNoticeStateDir(env?: NodeJS.ProcessEnv, home?: string): string;
+/** Acknowledge by appending a tombstone; runner-owned notice data is read-only here. */
+export declare function acknowledgeConflictNotice(id: string, stateDir?: string, acknowledgedAt?: string): void;
+//# sourceMappingURL=conflict-notices.d.ts.map

package/dist/lib/daemon/conflict-notices.js

@@ -0,0 +1,80 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function writeAllSync(fd, text) {
+    const bytes = Buffer.from(text);
+    let offset = 0;
+    while (offset < bytes.length) {
+        const written = fs.writeSync(fd, bytes, offset, bytes.length - offset);
+        if (written <= 0)
+            throw new Error("Conflict acknowledgement append made no progress.");
+        offset += written;
+    }
+}
+export function conflictNoticeStateDir(env = process.env, home = os.homedir()) {
+    return env.HQ_STATE_DIR || path.join(home, ".hq");
+}
+/** Acknowledge by appending a tombstone; runner-owned notice data is read-only here. */
+export function acknowledgeConflictNotice(id, stateDir = conflictNoticeStateDir(), acknowledgedAt = new Date().toISOString()) {
+    if (!/^[a-f0-9]{64}$/.test(id))
+        throw new Error("Invalid conflict notice id.");
+    const noticesPath = path.join(stateDir, "conflict-notices.json");
+    let notices = [];
+    try {
+        const file = JSON.parse(fs.readFileSync(noticesPath, "utf8"));
+        if (file?.schema === 1 && Array.isArray(file.notices))
+            notices = file.notices;
+        else
+            process.stderr.write("Conflict notice schema is unsupported; treating notices as empty.\n");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            process.stderr.write(`Conflict notice file could not be read; treating notices as empty (${error instanceof Error ? error.name : "UnknownError"}).\n`);
+        }
+    }
+    if (!notices.some((notice) => notice.id === id)) {
+        throw new Error("Unknown conflict notice.");
+    }
+    const ackPath = path.join(stateDir, "conflict-notice-acks.jsonl");
+    let existing = "";
+    try {
+        existing = fs.readFileSync(ackPath, "utf8");
+        let malformedLineCount = 0;
+        let alreadyAcknowledged = false;
+        for (const line of existing.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const record = JSON.parse(line);
+                if (!/^[a-f0-9]{64}$/.test(record.id) || typeof record.acknowledgedAt !== "string") {
+                    throw new Error("Invalid acknowledgement record");
+                }
+                if (record.id === id)
+                    alreadyAcknowledged = true;
+            }
+            catch {
+                malformedLineCount += 1;
+            }
+        }
+        if (malformedLineCount > 0) {
+            process.stderr.write(`Skipped ${malformedLineCount} malformed conflict acknowledgement line(s).\n`);
+        }
+        if (alreadyAcknowledged)
+            return;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    fs.mkdirSync(stateDir, { recursive: true });
+    const fd = fs.openSync(ackPath, "a", 0o600);
+    try {
+        const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+        writeAllSync(fd, `${separator}${JSON.stringify({ id, acknowledgedAt })}\n`);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+//# sourceMappingURL=conflict-notices.js.map

package/dist/lib/doctor/checks/sync-health.d.ts

@@ -59,6 +59,8 @@ export interface SyncManifestUploadStatus {
     snapshotId: string | null;
     sequence: number;
     baseUsable: boolean;
+    /** Local company slug for company-scoped remediation; absent for personal. */
+    companySlug?: string;
 }
 /** Injectable dependencies — defaults are the real collectors. */
 export interface SyncHealthDeps {

package/dist/lib/doctor/checks/sync-health.js

@@ -32,6 +32,7 @@ import * as path from "node:path";
 // ../../hq-cloud-manifest.js.
 import * as hqCloud from "@indigoai-us/hq-cloud";
 import { loadManifestExports, MANIFEST_UNAVAILABLE_REASON, } from "../../hq-cloud-manifest.js";
+import { readCompaniesManifestMap } from "../../work-context/repo-remote.js";
 import { CLI_VERSION } from "../../../cli-version.js";
 import { readSyncVersion } from "../../../utils/feedback-versions.js";
 import { readHqVersion } from "../../../utils/pack-contributions.js";
@@ -52,9 +53,9 @@ function withDefaults(deps, hqRoot) {
     return {
         ...deps,
         runtime: deps.runtime ?? (() => []),
-        manifestStatuses: deps.manifestStatuses ?? defaultManifestStatuses,
+        manifestStatuses: deps.manifestStatuses ?? ((journals) => defaultManifestStatuses(hqRoot, journals)),
         manifestAvailable: deps.manifestAvailable ?? (() => loadManifestExports() !== null),
-        unresolvedScopes: deps.unresolvedScopes ?? defaultUnresolvedScopes,
+        unresolvedScopes: deps.unresolvedScopes ?? ((journals) => defaultUnresolvedScopes(hqRoot, journals)),
         localCompanyExists: deps.localCompanyExists ??
             ((slug) => defaultLocalCompanyExists(hqRoot, slug)),
     };
@@ -78,15 +79,35 @@ function defaultLocalCompanyExists(hqRoot, slug) {
         return false;
     }
 }
-/**
- * Company journal shards are unresolvable by the default collector: the
- * snapshot store keys company scopes by `companyUid`, which `listJournals()`
- * does not carry. Naming them here keeps them visible.
- */
-function defaultUnresolvedScopes(journals) {
-    return journals
-        .filter((entry) => !NON_COMPANY_JOURNAL_SLUGS.has(entry.slug))
-        .map((entry) => entry.slug);
+/** Resolve locally-known company journal slugs to the UID used by snapshots. */
+function resolvedCompanyScopes(hqRoot, journals) {
+    const companies = readCompaniesManifestMap(hqRoot);
+    const seen = new Set();
+    const scopes = [];
+    for (const { slug } of journals) {
+        if (NON_COMPANY_JOURNAL_SLUGS.has(slug) ||
+            !isSafeCompanySlug(slug) ||
+            !defaultLocalCompanyExists(hqRoot, slug) ||
+            seen.has(slug)) {
+            continue;
+        }
+        seen.add(slug);
+        const uid = companies?.[slug]?.cloud_uid;
+        if (typeof uid === "string" && /^cmp_[A-Za-z0-9]{3,128}$/.test(uid.trim())) {
+            scopes.push({ kind: "company", companyUid: uid.trim(), slug });
+        }
+    }
+    return scopes;
+}
+function defaultUnresolvedScopes(hqRoot, journals) {
+    const resolved = new Set(resolvedCompanyScopes(hqRoot, journals).map((scope) => scope.slug));
+    return [
+        ...new Set(journals
+            .filter((entry) => !NON_COMPANY_JOURNAL_SLUGS.has(entry.slug) &&
+            defaultLocalCompanyExists(hqRoot, entry.slug) &&
+            !resolved.has(entry.slug))
+            .map((entry) => entry.slug)),
+    ];
 }
 function defaultVersions(hqRoot) {
     return {
@@ -119,21 +140,15 @@ const DEFAULT_DEPS = {
     // than no check.
     journals: () => hqCloud.listJournals(),
     now: () => new Date(),
-    manifestStatuses: defaultManifestStatuses,
     runtime: defaultSyncRuntimeResults,
 };
 /**
  * Map the machine's journal shards onto the manifest scopes hq-cloud keys its
- * snapshot store by, then read each one's last upload.
- *
- * The journal slug `personal` is the personal tree; every other slug is a
- * company. Note the snapshot store keys company scopes by `companyUid`, which
- * the journal listing does not carry — so a company whose uid we cannot name
- * is simply not reported here rather than reported wrongly. That is the honest
- * outcome: this check exists to tell an operator when a manifest STOPPED being
- * uploaded, and inventing a scope key would make it lie in both directions.
+ * snapshot store by, then read each one's last upload. Company journal rows
+ * carry only slugs, so resolve their UIDs from the local companies manifest;
+ * a missing or malformed UID stays explicitly unresolved below.
  */
-function defaultManifestStatuses(journals) {
+function defaultManifestStatuses(hqRoot, journals) {
     // Both the legacy `personal` shard and the current personal-vault
     // pseudo-slug name the SAME personal tree; a machine mid-migration has both
     // on disk, so collapse them to a single personal scope rather than asking
@@ -141,6 +156,7 @@ function defaultManifestStatuses(journals) {
     const scopes = journals.some((entry) => NON_COMPANY_JOURNAL_SLUGS.has(entry.slug))
         ? [{ kind: "personal" }]
         : [];
+    scopes.push(...resolvedCompanyScopes(hqRoot, journals));
     if (scopes.length === 0)
         return [];
     // Absent on an older hq-cloud; the NA row is emitted by `manifestResults`
@@ -148,7 +164,15 @@ function defaultManifestStatuses(journals) {
     const exports = loadManifestExports();
     if (!exports)
         return [];
-    return exports.readManifestUploadStatus(exports.getStateDir(), scopes);
+    const companySlugsByUid = new Map(scopes
+        .filter((scope) => scope.kind === "company")
+        .map((scope) => [scope.companyUid, scope.slug]));
+    const statuses = exports.readManifestUploadStatus(exports.getStateDir(), scopes);
+    return statuses.map((status) => {
+        const companyUid = /^company:(cmp_[A-Za-z0-9]{3,128})$/.exec(status.scopeKey)?.[1];
+        const companySlug = companyUid ? companySlugsByUid.get(companyUid) : undefined;
+        return companySlug ? { ...status, companySlug } : status;
+    });
 }
 /** The legacy journal slug that named the personal (non-company) tree. */
 const PERSONAL_SCOPE_SLUG = "personal";
@@ -526,7 +550,7 @@ function manifestResults(deps, journals) {
                 checkId,
                 reasonCode: "stale-threshold",
                 message: `Scope '${entry.scopeKey}' last uploaded a sync manifest ${days} day${days === 1 ? "" : "s"} ago (${entry.lastUploadAt}) — the daily audit pass is not running.`,
-                remediation: "Run `hq sync manifest` and check HQ_SYNC_MANIFEST_DISABLED and the sync runner.",
+                remediation: `Run \`hq sync manifest${entry.companySlug ? ` --scope ${entry.companySlug}` : ""}\` and check HQ_SYNC_MANIFEST_DISABLED and the sync runner.`,
             };
         }
         return {

package/dist/lib/import-scan/events.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Streaming context-scan events (contract v1).
+ *
+ * `hq import scan --json --stream` relays these as JSON Lines, one object per
+ * line. They are produced by the HQ import-context scanner
+ * (`.claude/skills/import-context/scan.sh --progress-json` in an HQ tree) and
+ * validated here before they reach stdout. The HQ desktop first-run setup
+ * renders them as a knowledge tree that grows while the scan runs.
+ *
+ * The canonical contract lives next to the scanner
+ * (`.claude/skills/import-context/progress-json.md` in hq-core) and in
+ * `docs/import-scan-stream.md` in this repo. The JSON Schema is
+ * `scan-event.schema.json` in this directory (shipped next to the compiled
+ * module as `dist/lib/import-scan/scan-event.schema.json`).
+ *
+ * Desktop consumers can import these types from
+ * `@indigoai-us/hq-cli/dist/lib/import-scan/events.js` or mirror them.
+ *
+ * Versioning: within v1, fields, source ids, count keys and messages may be
+ * added. Consumers ignore unknown fields and must not parse message text.
+ * Removing or retyping a field, or adding a new `type`, `status` or `basis`
+ * value, bumps `v`.
+ */
+export declare const SCAN_EVENT_VERSION: 1;
+/** Event types, in the order a stream introduces them. */
+export declare const SCAN_EVENT_TYPES: readonly ["start", "source", "count", "company", "project", "error", "done"];
+export type ScanEventType = (typeof SCAN_EVENT_TYPES)[number];
+export declare const SCAN_SOURCE_STATUSES: readonly ["scanning", "done", "skipped", "error"];
+export type ScanSourceStatus = (typeof SCAN_SOURCE_STATUSES)[number];
+export declare const SCAN_COMPANY_BASES: readonly ["hq-company", "repo-org", "folder"];
+export type ScanCompanyBasis = (typeof SCAN_COMPANY_BASES)[number];
+export declare const SCAN_PROJECT_BASES: readonly ["repo", "claude-code-cwd", "codex-cwd"];
+export type ScanProjectBasis = (typeof SCAN_PROJECT_BASES)[number];
+/**
+ * Source ids the v1 scanner emits, in scan order. Other ids may appear in
+ * later v1 scanners; show them by their `label`.
+ */
+export declare const KNOWN_SCAN_SOURCE_IDS: readonly ["hq", "repos", "claude-code", "codex", "grok", "claude-ai", "artifacts"];
+export type KnownScanSourceId = (typeof KNOWN_SCAN_SOURCE_IDS)[number];
+/**
+ * Source id used on `error` events that hq-cli itself emits (HQ not found,
+ * scanner missing or too old, scanner crashed). Never listed in `start`.
+ */
+export declare const SCAN_CLI_ERROR_SOURCE: "scanner";
+/**
+ * Stable machine-readable codes on `error` events. hq-cli sets one on every
+ * error it emits itself (source "scanner"); scanner-emitted errors may omit it.
+ *
+ *   scanner_outdated  the HQ tree's scanner is missing or predates
+ *                     --progress-json; updating HQ fixes it
+ *   scan_failed       any other reason the scan could not run or finish
+ *                     (HQ not found, scanner crashed, cancelled, non-zero exit)
+ *
+ * Consumers branch on `code`, never on `message`. Treat an error without a
+ * code as non-fatal unless the stream ends with `report: null`.
+ */
+export declare const SCAN_ERROR_CODES: readonly ["scanner_outdated", "scan_failed"];
+export type ScanErrorCode = (typeof SCAN_ERROR_CODES)[number];
+/** Project ids: "p_" + 12 lowercase hex (pid() in scan-progress.sh). */
+export declare const SCAN_PROJECT_ID_PATTERN: RegExp;
+export interface ScanSourceInfo {
+    id: string;
+    label: string;
+}
+interface ScanEventBase {
+    v: typeof SCAN_EVENT_VERSION;
+}
+/** First line: the sources present on this machine, in scan order. */
+export interface ScanStartEvent extends ScanEventBase {
+    type: "start";
+    sources: ScanSourceInfo[];
+}
+/** Source lifecycle: `scanning` once, then one of done/skipped/error. */
+export interface ScanSourceEvent extends ScanEventBase {
+    type: "source";
+    id: string;
+    status: ScanSourceStatus;
+    /** Final counts, on `done`. Each value repeats the last `count` event for that key. */
+    counts?: Record<string, number>;
+    /** Plain-words reason, on `skipped` and `error`. */
+    message?: string;
+}
+/** Running count; fires at 1-2-5 milestones and once with the final value. */
+export interface ScanCountEvent extends ScanEventBase {
+    type: "count";
+    source: string;
+    key: string;
+    value: number;
+}
+/** A company from the deterministic rule pass. Emitted once per id. */
+export interface ScanCompanyEvent extends ScanEventBase {
+    type: "company";
+    id: string;
+    name: string;
+    basis: ScanCompanyBasis;
+}
+/**
+ * A project. Upsert by `id`: an id repeats only when a later rule pass
+ * attaches a company to a project that had `company: null`.
+ */
+export interface ScanProjectEvent extends ScanEventBase {
+    type: "project";
+    /** "p_" + 12 lowercase hex, the same for the same project on any machine. */
+    id: string;
+    /** Folder or repository basename; never contains "/". */
+    name: string;
+    company: string | null;
+    basis: ScanProjectBasis;
+}
+/** Non-fatal problem, in plain words. */
+export interface ScanErrorEvent extends ScanEventBase {
+    type: "error";
+    source: string;
+    message: string;
+    /** Stable code (SCAN_ERROR_CODES). Always set on hq-cli's own errors. */
+    code?: ScanErrorCode;
+}
+export interface ScanSummary {
+    companies: number;
+    projects: number;
+    sessions: number;
+}
+/**
+ * Last line. `report` is the absolute path of report.json, or `null` when
+ * hq-cli could not run the scan (then `summary` is all zeros and the command
+ * exits non-zero).
+ */
+export interface ScanDoneEvent extends ScanEventBase {
+    type: "done";
+    report: string | null;
+    summary: ScanSummary;
+}
+export type ScanEvent = ScanStartEvent | ScanSourceEvent | ScanCountEvent | ScanCompanyEvent | ScanProjectEvent | ScanErrorEvent | ScanDoneEvent;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/lib/import-scan/events.js

@@ -0,0 +1,71 @@
+/**
+ * Streaming context-scan events (contract v1).
+ *
+ * `hq import scan --json --stream` relays these as JSON Lines, one object per
+ * line. They are produced by the HQ import-context scanner
+ * (`.claude/skills/import-context/scan.sh --progress-json` in an HQ tree) and
+ * validated here before they reach stdout. The HQ desktop first-run setup
+ * renders them as a knowledge tree that grows while the scan runs.
+ *
+ * The canonical contract lives next to the scanner
+ * (`.claude/skills/import-context/progress-json.md` in hq-core) and in
+ * `docs/import-scan-stream.md` in this repo. The JSON Schema is
+ * `scan-event.schema.json` in this directory (shipped next to the compiled
+ * module as `dist/lib/import-scan/scan-event.schema.json`).
+ *
+ * Desktop consumers can import these types from
+ * `@indigoai-us/hq-cli/dist/lib/import-scan/events.js` or mirror them.
+ *
+ * Versioning: within v1, fields, source ids, count keys and messages may be
+ * added. Consumers ignore unknown fields and must not parse message text.
+ * Removing or retyping a field, or adding a new `type`, `status` or `basis`
+ * value, bumps `v`.
+ */
+export const SCAN_EVENT_VERSION = 1;
+/** Event types, in the order a stream introduces them. */
+export const SCAN_EVENT_TYPES = [
+    "start",
+    "source",
+    "count",
+    "company",
+    "project",
+    "error",
+    "done",
+];
+export const SCAN_SOURCE_STATUSES = ["scanning", "done", "skipped", "error"];
+export const SCAN_COMPANY_BASES = ["hq-company", "repo-org", "folder"];
+export const SCAN_PROJECT_BASES = ["repo", "claude-code-cwd", "codex-cwd"];
+/**
+ * Source ids the v1 scanner emits, in scan order. Other ids may appear in
+ * later v1 scanners; show them by their `label`.
+ */
+export const KNOWN_SCAN_SOURCE_IDS = [
+    "hq",
+    "repos",
+    "claude-code",
+    "codex",
+    "grok",
+    "claude-ai",
+    "artifacts",
+];
+/**
+ * Source id used on `error` events that hq-cli itself emits (HQ not found,
+ * scanner missing or too old, scanner crashed). Never listed in `start`.
+ */
+export const SCAN_CLI_ERROR_SOURCE = "scanner";
+/**
+ * Stable machine-readable codes on `error` events. hq-cli sets one on every
+ * error it emits itself (source "scanner"); scanner-emitted errors may omit it.
+ *
+ *   scanner_outdated  the HQ tree's scanner is missing or predates
+ *                     --progress-json; updating HQ fixes it
+ *   scan_failed       any other reason the scan could not run or finish
+ *                     (HQ not found, scanner crashed, cancelled, non-zero exit)
+ *
+ * Consumers branch on `code`, never on `message`. Treat an error without a
+ * code as non-fatal unless the stream ends with `report: null`.
+ */
+export const SCAN_ERROR_CODES = ["scanner_outdated", "scan_failed"];
+/** Project ids: "p_" + 12 lowercase hex (pid() in scan-progress.sh). */
+export const SCAN_PROJECT_ID_PATTERN = /^p_[0-9a-f]{12}$/;
+//# sourceMappingURL=events.js.map

package/dist/lib/import-scan/run.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Runs the HQ import-context scanner with `--progress-json` and relays its
+ * JSON Lines event stream (contract: ./events.ts).
+ *
+ * The scanner is the HQ tree's own copy at
+ * `<hq root>/.claude/skills/import-context/scan.sh`, the same place the
+ * /import-context skill runs it from. The scan is local only: the scanner
+ * reads the filesystem and writes one report.json; nothing here touches the
+ * network.
+ *
+ * HQ root: `--hq-root` when given, else the root the HQ installer recorded in
+ * `~/.hq/menubar.json` (`hqPath`). Nothing else is trusted: no walk up from
+ * the current folder and no `$HQ_ROOT`, because this command runs a script
+ * from that tree.
+ *
+ * Output modes:
+ *   stream  every valid event, rebuilt from its v1 fields (invalid lines are
+ *           dropped with a warning on stderr that never echoes the line)
+ *   final   only the final `done` object
+ *   human   short progress lines and a summary
+ *
+ * The `done` event is held until the scanner exits. When the scan cannot run
+ * or does not finish cleanly (HQ not found, scanner missing or too old,
+ * scanner exited non-zero or without `done`, cancelled), an `error` event
+ * (source "scanner") comes first, then `done` (zeroed with `report: null`
+ * unless the scanner produced one), and the command exits non-zero.
+ *
+ * Process handling: the scanner runs in its own process group. SIGINT/SIGTERM
+ * to hq-cli are forwarded to the whole group and escalated to SIGKILL after
+ * `killTimeoutMs`. When the scanner exits, anything still left in its group
+ * is terminated so an orphan holding stdout open cannot stall the command.
+ *
+ * Scanner stderr is not forwarded verbatim: each line is passed through with
+ * paths and token-like strings replaced, at most MAX_STDERR_LINES lines, then
+ * a count of the rest.
+ */
+export declare const SCANNER_RELATIVE_PATH: string;
+export type ImportScanMode = "stream" | "final" | "human";
+export interface ImportScanOptions {
+    mode: ImportScanMode;
+    /** Explicit HQ root (--hq-root). */
+    hqRoot?: string;
+    /** Home directory used to find ~/.hq/menubar.json (tests). */
+    home?: string;
+    /** Report path. Defaults to <hq>/workspace/imports/<scan id>/report.json. */
+    output?: string;
+    scopes?: string[];
+    claudeExport?: string;
+    noDefaultScopes?: boolean;
+    /** Shell used to run scan.sh (default "bash"). */
+    bash?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    /** Grace period between forwarding a signal and SIGKILL (default 5000). */
+    killTimeoutMs?: number;
+    /** Cancels the scan like SIGTERM (for embedding callers and tests). */
+    abortSignal?: AbortSignal;
+}
+export interface ImportScanIo {
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+}
+/** UTC scan id in the /import-context skill's format: YYYYMMDDTHHMMSSZ. */
+export declare function scanId(date: Date): string;
+export declare class HqRootError extends Error {
+}
+/**
+ * --hq-root, else the installer-recorded root in ~/.hq/menubar.json. Throws
+ * HqRootError with a plain-words message otherwise.
+ */
+export declare function resolveScanHqRoot(opts: {
+    hqRoot?: string;
+    home?: string;
+}): string;
+/**
+ * Replace paths and token-like strings in one scanner stderr line. A path
+ * runs from its first "/" (or a leading ~ / $HOME) to the next quote or the
+ * end of the line, because folder names may contain spaces: stopping at
+ * whitespace would leak the rest of "/Users/x/My Project/secret".
+ */
+export declare function redactScannerLine(line: string): string;
+/** Run the scan. Resolves to the process exit code. */
+export declare function runImportScan(opts: ImportScanOptions, io: ImportScanIo): Promise<number>;
+//# sourceMappingURL=run.d.ts.map