@indigoai-us/hq-cli 5.108.1 → 5.108.2

package/dist/lib/mesh/live/validate-session-event.js

@@ -0,0 +1,128 @@
+/**
+ * Work Mesh Live — session-event validator (US-001).
+ *
+ * Uses Ajv draft 2020-12 against the verbatim schema copy. Prohibited content
+ * classes are rejected (additionalProperties: false). Error messages never
+ * echo prohibited marker values (redaction assertion surface).
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const SESSION_EVENT_SCHEMA_PATH = join(HERE, "session-event.schema.json");
+/** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
+export const SESSION_EVENT_SCHEMA_SHA256 = "be300120b4793a5c6f1e713bf9f72b2fd22f6ac082bef8eedfa507b684b09ccb";
+export const PROHIBITED_CONTENT_CLASSES = [
+    "prompts",
+    "model_output",
+    "transcripts",
+    "message_bodies",
+    "tokens",
+    "credentials",
+];
+/** Fixture field name → prohibited class. */
+export const PROHIBITED_FIELD_BY_CLASS = {
+    prompts: "prompt",
+    model_output: "modelOutput",
+    transcripts: "transcript",
+    message_bodies: "messageBody",
+    tokens: "token",
+    credentials: "credentials",
+};
+const REDACT_MARKERS = [
+    "REDACT_MARKER_PROMPT_",
+    "REDACT_MARKER_MODEL_OUTPUT_",
+    "REDACT_MARKER_TRANSCRIPT_",
+    "REDACT_MARKER_MESSAGE_BODY_",
+    "REDACT_MARKER_TOKEN_",
+    "REDACT_MARKER_CREDENTIALS_",
+];
+let cachedValidate;
+function loadSchema() {
+    return JSON.parse(readFileSync(SESSION_EVENT_SCHEMA_PATH, "utf8"));
+}
+export function getSessionEventValidator() {
+    if (cachedValidate)
+        return cachedValidate;
+    const ajv = new Ajv2020({
+        allErrors: true,
+        strict: false,
+        validateFormats: false,
+    });
+    cachedValidate = ajv.compile(loadSchema());
+    return cachedValidate;
+}
+/**
+ * Redact known prohibited markers from Ajv error text so diagnostics never
+ * leak prompt/token/credential material.
+ */
+export function redactValidationMessage(message) {
+    let out = message;
+    for (const marker of REDACT_MARKERS) {
+        if (out.includes(marker)) {
+            out = out.split(marker)[0] + "[REDACTED]";
+        }
+    }
+    // Also strip any bearer-shaped or op:// fragments that slipped through.
+    out = out.replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]");
+    out = out.replace(/op:\/\/[^\s"]+/g, "op://[REDACTED]");
+    return out;
+}
+function formatErrors(errors) {
+    if (!errors || errors.length === 0)
+        return ["validation_failed"];
+    return errors.map((e) => {
+        const path = e.instancePath || "/";
+        const msg = e.message ?? "invalid";
+        return redactValidationMessage(`${path}: ${msg}`);
+    });
+}
+export function validateSessionEvent(candidate) {
+    const validate = getSessionEventValidator();
+    const ok = validate(candidate);
+    if (ok)
+        return { ok: true, errors: [] };
+    return { ok: false, errors: formatErrors(validate.errors) };
+}
+export function sha256File(path) {
+    return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+export function sha256SessionEventSchema() {
+    return sha256File(SESSION_EVENT_SCHEMA_PATH);
+}
+const HQ_PRO_SCHEMA_RELATIVE = "src/vault-service/work-mesh/live/session-event.schema.json";
+/** Walk up from `start` until a directory containing package.json is found. */
+function findRepoRoot(start) {
+    let dir = start;
+    for (;;) {
+        if (existsSync(join(dir, "package.json")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Resolve the hq-pro canonical schema path when available.
+ *
+ * Order: `HQ_PRO_SCHEMA_PATH` env override (absolute path to the hq-pro
+ * schema file) → sibling checkout
+ * `../hq-pro/src/vault-service/work-mesh/live/session-event.schema.json`
+ * from the hq-cli repo root → null.
+ * Shipped code must not hardcode machine-specific worktree paths.
+ */
+export function resolveHqProSchemaPath() {
+    const envPath = process.env.HQ_PRO_SCHEMA_PATH?.trim();
+    if (envPath) {
+        return isAbsolute(envPath) ? envPath : resolve(envPath);
+    }
+    const repoRoot = findRepoRoot(HERE);
+    if (!repoRoot)
+        return null;
+    const sibling = resolve(repoRoot, "..", "hq-pro", HQ_PRO_SCHEMA_RELATIVE);
+    return existsSync(sibling) ? sibling : null;
+}
+//# sourceMappingURL=validate-session-event.js.map

package/dist/lib/search-index/index.d.ts

@@ -200,6 +200,51 @@ export declare class QmdStoreUnopenableError extends QmdExitError {
     name: string;
     constructor(message: string, args: string[], status: number | null, stdout: string, stderr: string, storeDir?: string | undefined, probeReason?: string | undefined);
 }
+/**
+ * qmd's `query` subcommand (hybrid search) rejected the positional as a
+ * MALFORMED QUERY DOCUMENT: qmd 2.5.3 parses a multi-line positional as a query
+ * document and requires EVERY non-empty line to carry a lex:/vec:/hyde:/intent:/
+ * expand: prefix (dist/cli/qmd.js:2157-2217), throwing otherwise. That is the
+ * caller's INPUT SHAPE — a multi-line free-text query, most often a fleet agent
+ * forwarding a whole Slack message — not a bug HQ can fix in code.
+ *
+ * HQ-CLI-1B (Sentry indigo-d0/hq-cli 7705711476, 28 of 29 events): `hq search
+ * --mode hybrid` mapped to `qmd query` and handed the caller's multi-line query
+ * through unchanged; qmd exited 1 with `Line 1 is missing a lex:/vec:/hyde:/
+ * intent: prefix. …`. With no classifier the generic template raised a plain
+ * QmdExitError that reached the boundary's final else and was captured.
+ * buildSearchArgs now normalises free text to a single line so the common case
+ * never reaches qmd multi-line; this typed subclass lets the boundary classify a
+ * genuinely malformed structured document as the caller's input and stop
+ * fingerprinting on the query text: it is raised only from qmd's OWN captured
+ * streams and its message names the SUBCOMMAND only.
+ */
+export declare class QmdQueryDocumentError extends QmdExitError {
+    name: string;
+}
+/**
+ * A qmd MODEL DOWNLOAD did not finish: qmd crashed with ENOENT while renaming its
+ * own partial `.ipull` download file into place. The partial file was gone by the
+ * time the rename ran — the signature of ANOTHER qmd process on the same box
+ * finishing (or clearing) the same download first. That is a transient, retryable
+ * LOCAL-CACHE race, not a bug HQ can fix in code: hq cannot coordinate qmd
+ * children other users start on the same host, and reaching into qmd's model
+ * cache would be hq owning upstream state.
+ *
+ * HQ-CLI-1B (Sentry indigo-d0/hq-cli 7705711476, the newest event, on release
+ * 5.107.1): `qmd query` reached its reranking stage and its reranker-model
+ * downloader died uncaught with `[Error: ENOENT: no such file or directory,
+ * rename '<cache>/…-reranker-….gguf.ipull' -> '<cache>/…-reranker-….gguf']`.
+ * With no classifier it took the identical fall-through to capture as the
+ * query-document crash — and because both share the (QmdExitError, qmd:query,
+ * exit:1) fingerprint, a query-document-only fix would leave this issue alive.
+ * This typed subclass lets the boundary classify it and stop the capture: it is
+ * raised only from qmd's OWN captured streams and its message names the
+ * SUBCOMMAND only.
+ */
+export declare class QmdModelDownloadError extends QmdExitError {
+    name: string;
+}
 export type ResolveQmdBinOptions = {
     env?: Record<string, string | undefined>;
     isExecutable?: (candidate: string) => boolean;

package/dist/lib/search-index/index.js

@@ -4,8 +4,10 @@ import { createRequire } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { isQmdModelDownloadError } from '../../utils/qmd-model-download-error.js';
 import { isQmdModuleMissingError } from '../../utils/qmd-module-missing-error.js';
 import { isQmdNativeBindingError } from '../../utils/qmd-native-binding-error.js';
+import { isQmdQueryDocumentError } from '../../utils/qmd-query-document-error.js';
 import { isQmdStoreMissingError } from '../../utils/qmd-store-missing-error.js';
 import { isQmdStoreUnopenableError } from '../../utils/qmd-store-unopenable-error.js';
 import { redactErrorText } from '../../utils/redact-error-text.js';
@@ -189,6 +191,51 @@ export class QmdStoreUnopenableError extends QmdExitError {
         this.probeReason = probeReason;
     }
 }
+/**
+ * qmd's `query` subcommand (hybrid search) rejected the positional as a
+ * MALFORMED QUERY DOCUMENT: qmd 2.5.3 parses a multi-line positional as a query
+ * document and requires EVERY non-empty line to carry a lex:/vec:/hyde:/intent:/
+ * expand: prefix (dist/cli/qmd.js:2157-2217), throwing otherwise. That is the
+ * caller's INPUT SHAPE — a multi-line free-text query, most often a fleet agent
+ * forwarding a whole Slack message — not a bug HQ can fix in code.
+ *
+ * HQ-CLI-1B (Sentry indigo-d0/hq-cli 7705711476, 28 of 29 events): `hq search
+ * --mode hybrid` mapped to `qmd query` and handed the caller's multi-line query
+ * through unchanged; qmd exited 1 with `Line 1 is missing a lex:/vec:/hyde:/
+ * intent: prefix. …`. With no classifier the generic template raised a plain
+ * QmdExitError that reached the boundary's final else and was captured.
+ * buildSearchArgs now normalises free text to a single line so the common case
+ * never reaches qmd multi-line; this typed subclass lets the boundary classify a
+ * genuinely malformed structured document as the caller's input and stop
+ * fingerprinting on the query text: it is raised only from qmd's OWN captured
+ * streams and its message names the SUBCOMMAND only.
+ */
+export class QmdQueryDocumentError extends QmdExitError {
+    name = 'QmdQueryDocumentError';
+}
+/**
+ * A qmd MODEL DOWNLOAD did not finish: qmd crashed with ENOENT while renaming its
+ * own partial `.ipull` download file into place. The partial file was gone by the
+ * time the rename ran — the signature of ANOTHER qmd process on the same box
+ * finishing (or clearing) the same download first. That is a transient, retryable
+ * LOCAL-CACHE race, not a bug HQ can fix in code: hq cannot coordinate qmd
+ * children other users start on the same host, and reaching into qmd's model
+ * cache would be hq owning upstream state.
+ *
+ * HQ-CLI-1B (Sentry indigo-d0/hq-cli 7705711476, the newest event, on release
+ * 5.107.1): `qmd query` reached its reranking stage and its reranker-model
+ * downloader died uncaught with `[Error: ENOENT: no such file or directory,
+ * rename '<cache>/…-reranker-….gguf.ipull' -> '<cache>/…-reranker-….gguf']`.
+ * With no classifier it took the identical fall-through to capture as the
+ * query-document crash — and because both share the (QmdExitError, qmd:query,
+ * exit:1) fingerprint, a query-document-only fix would leave this issue alive.
+ * This typed subclass lets the boundary classify it and stop the capture: it is
+ * raised only from qmd's OWN captured streams and its message names the
+ * SUBCOMMAND only.
+ */
+export class QmdModelDownloadError extends QmdExitError {
+    name = 'QmdModelDownloadError';
+}
 function isExecutable(candidate) {
     try {
         fs.accessSync(candidate, fs.constants.X_OK);
@@ -1036,6 +1083,35 @@ function finishRunQmd(result, bin, args) {
         const ensure = lastQmdStoreEnsure;
         throw new QmdStoreUnopenableError(`qmd ${subcommand} could not run: its local search store could not be opened`, args, normalized.status, normalized.stdout, normalized.stderr, ensure?.dir, ensure && !ensure.writable ? ensure.reason : undefined);
     }
+    // qmd's `query` subcommand rejected the positional as a MALFORMED QUERY
+    // DOCUMENT: qmd 2.5.3 parses a multi-line positional as a document and requires
+    // every non-empty line to carry a lex:/vec:/hyde:/intent:/expand: prefix, so a
+    // multi-line free-text query (a fleet agent forwarding a whole Slack message)
+    // exits 1 with a syntax diagnostic. That is the caller's INPUT SHAPE, not an
+    // hq-cli defect. Read qmd's OWN captured streams only, never the synthesized
+    // message, so a user query that merely contains the wording can never trip it.
+    // hq-cli side: buildSearchArgs now normalises free text to one line so this no
+    // longer fires for the common case; this branch types a genuinely malformed
+    // structured document so the boundary prints a query-free remedy and skips
+    // capture. Placed AFTER the store checks and BEFORE the collection-missing
+    // regex; the wordings are disjoint (that regex needs collection/qmd:// adjacent
+    // to a not-found token, absent here), so no existing branch changes behaviour
+    // (HQ-CLI-1B / Sentry 7705711476).
+    if (isQmdQueryDocumentError({ stderr: normalized.stderr, stdout: normalized.stdout })) {
+        throw new QmdQueryDocumentError(`qmd ${subcommand} could not run: the query was read as a malformed query document`, args, normalized.status, normalized.stdout, normalized.stderr);
+    }
+    // A qmd MODEL DOWNLOAD died with ENOENT renaming its own partial `.ipull` file
+    // — the signature of another qmd process on the same box finishing or clearing
+    // the same download first. That is a transient, retryable LOCAL-CACHE race, not
+    // an hq-cli defect (hq cannot coordinate qmd children other users start on the
+    // host). Require BOTH the ENOENT-rename signature AND the `.ipull` marker so a
+    // durable failure (ENOSPC/EACCES/network) keeps its reportable path. Read qmd's
+    // OWN captured streams only. Placed with the query-document check, before the
+    // collection-missing regex; the signatures are disjoint, so no existing branch
+    // changes behaviour (HQ-CLI-1B / Sentry 7705711476, the newest event).
+    if (isQmdModelDownloadError({ stderr: normalized.stderr, stdout: normalized.stdout })) {
+        throw new QmdModelDownloadError(`qmd ${subcommand} could not run: a model download did not finish (its partial file disappeared)`, args, normalized.status, normalized.stdout, normalized.stderr);
+    }
     if (/(?:collection|qmd:\/\/).*(?:not found|does not exist|unknown)|(?:not found|does not exist).*collection/i.test(classifyText)) {
         throw new QmdCollectionMissingError(message, args, normalized.status, normalized.stdout, normalized.stderr);
     }

package/dist/lib/work-context/atomic.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Atomic owner-only file writes with symlink and path guards for work-context.
+ */
+/**
+ * Resolve symlinks on an existing path; for a missing leaf, resolve the parent
+ * and re-append the basename so we never rename onto a symlink.
+ */
+export declare function resolveRealTarget(target: string): string;
+/**
+ * Ensure parent dir exists as a real directory (not a symlink), mode 0700.
+ */
+export declare function ensureOwnerDir(dir: string): string;
+/**
+ * Atomically replace target with data at mode 0600 (same-dir tmp + rename).
+ */
+export declare function atomicWriteFile(target: string, data: string | Buffer): void;
+export declare function atomicWriteJson(target: string, value: unknown): void;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/lib/work-context/atomic.js

@@ -0,0 +1,132 @@
+/**
+ * Atomic owner-only file writes with symlink and path guards for work-context.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { UnsafeConfigPathError } from "./errors.js";
+function fsyncDir(dir) {
+    try {
+        const fd = fs.openSync(dir, "r");
+        try {
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        // Best-effort: some platforms reject directory fsync.
+    }
+}
+/**
+ * Resolve symlinks on an existing path; for a missing leaf, resolve the parent
+ * and re-append the basename so we never rename onto a symlink.
+ */
+export function resolveRealTarget(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch {
+        // Leaf may not exist yet.
+    }
+    let cur = path.dirname(target);
+    const base = path.basename(target);
+    for (let i = 0; i < 40; i += 1) {
+        try {
+            const lst = fs.lstatSync(cur);
+            if (lst.isSymbolicLink()) {
+                throw new UnsafeConfigPathError(`Refusing write through symlink: ${cur}`);
+            }
+            const real = fs.realpathSync(cur);
+            return path.join(real, base);
+        }
+        catch (err) {
+            if (err instanceof UnsafeConfigPathError)
+                throw err;
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                break;
+            cur = parent;
+        }
+    }
+    return target;
+}
+/**
+ * Ensure parent dir exists as a real directory (not a symlink), mode 0700.
+ */
+export function ensureOwnerDir(dir) {
+    const resolved = (() => {
+        try {
+            if (fs.existsSync(dir)) {
+                const lst = fs.lstatSync(dir);
+                if (lst.isSymbolicLink()) {
+                    throw new UnsafeConfigPathError(`Refusing directory that is a symlink: ${dir}`);
+                }
+                return fs.realpathSync(dir);
+            }
+        }
+        catch (err) {
+            if (err instanceof UnsafeConfigPathError)
+                throw err;
+        }
+        return dir;
+    })();
+    fs.mkdirSync(resolved, { recursive: true, mode: 0o700 });
+    try {
+        fs.chmodSync(resolved, 0o700);
+    }
+    catch {
+        // ignore chmod failures on exotic FS
+    }
+    const lst = fs.lstatSync(resolved);
+    if (lst.isSymbolicLink()) {
+        throw new UnsafeConfigPathError(`Refusing directory that is a symlink: ${resolved}`);
+    }
+    return fs.realpathSync(resolved);
+}
+/**
+ * Atomically replace target with data at mode 0600 (same-dir tmp + rename).
+ */
+export function atomicWriteFile(target, data) {
+    const realTarget = resolveRealTarget(target);
+    const dir = ensureOwnerDir(path.dirname(realTarget));
+    const finalPath = path.join(dir, path.basename(realTarget));
+    const tmp = path.join(dir, `.${path.basename(finalPath)}.tmp.${process.pid}.${Date.now()}`);
+    let fd;
+    try {
+        fd = fs.openSync(tmp, "wx", 0o600);
+        fs.writeSync(fd, typeof data === "string" ? Buffer.from(data, "utf8") : data);
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        fs.renameSync(tmp, finalPath);
+        fsyncDir(dir);
+        try {
+            fs.chmodSync(finalPath, 0o600);
+        }
+        catch {
+            // ignore
+        }
+    }
+    catch (err) {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                /* already closed */
+            }
+        }
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            /* temp may not exist */
+        }
+        throw err;
+    }
+}
+export function atomicWriteJson(target, value) {
+    atomicWriteFile(target, `${JSON.stringify(value, null, 2)}\n`);
+}
+//# sourceMappingURL=atomic.js.map

package/dist/lib/work-context/company.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Company precedence for work-context reconcile (US-007A).
+ *
+ * Order:
+ *   1. trusted explicit (HQ_SPAWN_COMPANY env or observation.trustedContext/explicit)
+ *   2. existing authoritative session scope
+ *   3. session meta.yaml company_slug (/startwork)
+ *   4. agent-box identity file (HQ_AGENT_IDENTITY_FILE → companyUid; source
+ *      trusted_explicit — never "default company mode"; below HQ_SPAWN_COMPANY,
+ *      above device default)
+ *   5. enabled device default
+ *   6. exactly one deterministic mapping (cwd under companies/{slug}/ or repo remote)
+ *
+ * Prompt-text matching is never used.
+ * Device default + conflicting deterministic evidence → company_conflict.
+ */
+import type { TrustedExplicitContext } from "./contract.js";
+import { type SessionStateFile } from "./state.js";
+export type CompanyResolutionSource = "trusted_explicit" | "existing_scope" | "session_meta" | "device_default" | "deterministic_cwd" | "deterministic_remote";
+export interface ResolvedCompany {
+    slug?: string;
+    uid?: string;
+    source: CompanyResolutionSource;
+}
+/** Pointer to the US-017B correction client (never auto-switches). */
+export declare const COMPANY_CORRECTION_PATH_PREFIX = "hq mesh context correct --session";
+export declare function companyCorrectionPath(sessionId: string): string;
+export type CompanyResolution = {
+    status: "resolved";
+    company: ResolvedCompany;
+} | {
+    status: "needs_company";
+} | {
+    status: "company_conflict";
+    defaultCompany: ResolvedCompany;
+    evidenceCompany: ResolvedCompany;
+    /** Present when a prior binding exists and evidence names another company. */
+    correctionPath?: string;
+    /** True when conflict is after an existing binding (cannot auto-switch). */
+    afterBinding?: boolean;
+};
+export interface CompanyResolveInput {
+    root: string;
+    sessionId: string;
+    env?: NodeJS.ProcessEnv;
+    /** Trusted explicit from observation (trustedContext or explicit). */
+    trusted?: TrustedExplicitContext & {
+        companySlug?: string;
+    };
+    cwd?: string;
+    hqRoot?: string;
+    /** Optional preloaded state (tests). */
+    existingState?: SessionStateFile | null;
+    /** Optional injected meta company_slug. */
+    metaCompanySlug?: string | null;
+    /** Optional injected deterministic remote ownership slug. */
+    remoteOwnerSlug?: string | null;
+}
+/** Env naming the on-box identity.json (fleet agent boxes). */
+export declare const HQ_AGENT_IDENTITY_FILE_ENV = "HQ_AGENT_IDENTITY_FILE";
+/**
+ * Read `companyUid` from the agent identity file when
+ * `HQ_AGENT_IDENTITY_FILE` is set. Missing/unreadable/malformed → undefined
+ * (never throws; never logs file contents).
+ */
+export declare function readAgentIdentityCompanyUid(env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Compare companies: UIDs when both sides have them; otherwise normalized
+ * slugs when both have slugs. Never treat uid+slug vs slug-only as a
+ * conflict when the slugs match (verified scope under companies/{slug}/).
+ */
+export declare function sameCompany(a: {
+    slug?: string;
+    uid?: string;
+}, b: {
+    slug?: string;
+    uid?: string;
+}): boolean;
+/**
+ * Extract company slug from a cwd path containing `companies/{slug}/`.
+ */
+export declare function companySlugFromCwd(cwd: string | undefined, hqRoot?: string): string | undefined;
+/**
+ * Extract project id from cwd under `companies/{slug}/projects/{project}/`
+ * (US-007B deterministic mapping). Never invents a project.
+ */
+export declare function projectIdFromCwd(cwd: string | undefined, hqRoot?: string): string | undefined;
+/**
+ * Read company_slug from workspace/sessions/<sid>/meta.yaml (best-effort, no yaml dep).
+ */
+export declare function readMetaCompanySlug(sessionId: string, hqRoot: string | undefined): string | undefined;
+/**
+ * Deterministic mapping: exactly one of cwd companies/{slug} or remote owner.
+ * Multiple distinct signals that disagree → no deterministic mapping (needs_company
+ * unless a higher-precedence source exists). Matching signals collapse to one.
+ */
+export declare function resolveDeterministicCompany(input: {
+    cwd?: string;
+    hqRoot?: string;
+    remoteOwnerSlug?: string | null;
+}): ResolvedCompany | null;
+export declare function resolveCompany(input: CompanyResolveInput): CompanyResolution;
+//# sourceMappingURL=company.d.ts.map