@indigoai-us/hq-cli 5.108.1 → 5.108.2

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

@@ -0,0 +1,651 @@
+/**
+ * hq mesh context reconcile — sole runtime-to-control-plane entrypoint
+ * (US-007A company gate + US-007B project/task organization).
+ */
+import * as fs from "node:fs";
+import { InvalidSessionIdentityError, normalizeSessionIdentity, } from "../mesh/live/session-identity.js";
+import { companyCorrectionPath, resolveCompany, } from "./company.js";
+import { WORK_CONTEXT_CONTRACT_VERSION, normalizeTaskId, } from "./contract.js";
+import { EXIT_INVALID_IDENTITY, EXIT_NOT_TRACKING, EXIT_OK, InvalidDecisionOriginError, NotTrackingError, } from "./errors.js";
+import { decisionFromCandidates, } from "./organize.js";
+import { resolveProjectTask, shouldAskAfter } from "./project.js";
+import { deriveRemoteOwnerSlug } from "./repo-remote.js";
+import { enqueueOutbox, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, } from "./outbox.js";
+import { mergeLocalSessionFields, readSessionState, writeSessionState, } from "./state.js";
+function resultOf(parts) {
+    const out = {
+        contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+        kind: parts.kind,
+        classification: parts.classification,
+        delivery: parts.delivery,
+        lifecycle: parts.lifecycle ?? "open",
+        sessionId: parts.sessionId,
+        clientOperationId: parts.clientOperationId,
+    };
+    if (parts.companyUid)
+        out.companyUid = parts.companyUid;
+    if (parts.projectId)
+        out.projectId = parts.projectId;
+    if (parts.taskId)
+        out.taskId = parts.taskId;
+    if (parts.bindingEpisodeId)
+        out.bindingEpisodeId = parts.bindingEpisodeId;
+    if (parts.errorCode)
+        out.errorCode = parts.errorCode;
+    return out;
+}
+function parseUntrackedOrigin(obs) {
+    if (obs.untrackedOrigin === "user")
+        return "user";
+    if (obs.untracked) {
+        const origin = String(obs.untracked.origin || "").toLowerCase();
+        if (origin === "user")
+            return "user";
+        if (origin === "model" || origin === "agent")
+            return "rejected";
+        return "rejected";
+    }
+    return undefined;
+}
+export function parseObservationJson(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error("Observation must be a JSON object");
+    }
+    if (parsed.contractVersion !== WORK_CONTEXT_CONTRACT_VERSION) {
+        throw new Error(`Unsupported observation contractVersion: ${String(parsed.contractVersion)}`);
+    }
+    if (!parsed.clientOperationId || typeof parsed.clientOperationId !== "string") {
+        throw new Error("Observation requires clientOperationId");
+    }
+    if (!parsed.identity || typeof parsed.identity !== "object") {
+        throw new Error("Observation requires identity");
+    }
+    return parsed;
+}
+export function loadObservationFromFile(filePath) {
+    return parseObservationJson(fs.readFileSync(filePath, "utf8"));
+}
+/**
+ * Mark a session untracked (user origin only). Local receipt; no server write.
+ */
+export function markUntracked(sessionId, deps, clientOperationId = `untracked_${sessionId}`) {
+    const now = (deps.now ?? (() => new Date()))().toISOString();
+    const state = {
+        contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+        sessionId,
+        contextStatus: "untracked",
+        untrackedReceipt: { origin: "user", at: now, noBackfill: true },
+        updatedAt: now,
+    };
+    const statePath = writeSessionState(state, deps.root);
+    return {
+        result: resultOf({
+            kind: "untracked",
+            classification: "untracked",
+            delivery: "clean",
+            sessionId,
+            clientOperationId,
+        }),
+        exitCode: EXIT_OK,
+        diagnostics: ["untracked: local consent receipt only; no server write"],
+        statePath,
+    };
+}
+export async function reconcileObservation(obs, deps) {
+    const diagnostics = [];
+    const env = deps.env ?? process.env;
+    const nowFn = deps.now ?? (() => new Date());
+    let sessionId;
+    try {
+        const normalized = normalizeSessionIdentity({
+            sessionId: obs.identity.sessionId,
+            providerSessionId: obs.identity.providerSessionId,
+            env,
+        });
+        sessionId = normalized.sessionId;
+    }
+    catch (err) {
+        if (err instanceof InvalidSessionIdentityError) {
+            const sid = obs.identity.sessionId || "unknown";
+            return {
+                result: resultOf({
+                    kind: "error",
+                    classification: "unresolved",
+                    delivery: "clean",
+                    sessionId: sid,
+                    clientOperationId: obs.clientOperationId,
+                    errorCode: "InvalidSessionIdentityError",
+                }),
+                exitCode: EXIT_INVALID_IDENTITY,
+                diagnostics: [err.message],
+            };
+        }
+        throw err;
+    }
+    // Explicit untracked before company resolution.
+    const untracked = parseUntrackedOrigin(obs);
+    if (untracked === "rejected") {
+        return {
+            result: resultOf({
+                kind: "error",
+                classification: "unresolved",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                errorCode: "InvalidDecisionOriginError",
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [
+                new InvalidDecisionOriginError().message,
+            ],
+        };
+    }
+    if (untracked === "user") {
+        try {
+            return markUntracked(sessionId, deps, obs.clientOperationId);
+        }
+        catch (err) {
+            if (err instanceof NotTrackingError) {
+                return {
+                    result: resultOf({
+                        kind: "error",
+                        classification: "untracked",
+                        delivery: "clean",
+                        sessionId,
+                        clientOperationId: obs.clientOperationId,
+                        errorCode: "NOT_TRACKING",
+                    }),
+                    exitCode: EXIT_NOT_TRACKING,
+                    diagnostics: [err.message],
+                };
+            }
+            throw err;
+        }
+    }
+    // Already untracked locally — stay untracked until explicit opt-in (no backfill).
+    const prior = readSessionState(sessionId, deps.root);
+    if (prior?.contextStatus === "untracked" && prior.untrackedReceipt?.origin === "user") {
+        return {
+            result: resultOf({
+                kind: "untracked",
+                classification: "untracked",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: ["session already untracked (local receipt); no server write"],
+            statePath: undefined,
+        };
+    }
+    const trusted = obs.trustedContext ?? obs.explicit;
+    if (trusted?.taskId || trusted?.storyId) {
+        const norm = normalizeTaskId({
+            taskId: trusted.taskId,
+            storyId: trusted.storyId,
+        });
+        if (!norm.ok) {
+            return {
+                result: resultOf({
+                    kind: "error",
+                    classification: "unresolved",
+                    delivery: "clean",
+                    sessionId,
+                    clientOperationId: obs.clientOperationId,
+                    errorCode: norm.code,
+                }),
+                exitCode: EXIT_OK,
+                diagnostics: [`task alias error: ${norm.code}`],
+            };
+        }
+    }
+    const cwd = typeof obs.cwd === "string" ? obs.cwd : undefined;
+    const hqRoot = typeof obs.hqRoot === "string" ? obs.hqRoot : undefined;
+    // Prefer an explicit observation remoteOwnerSlug (tests / adapters); otherwise
+    // derive from the enclosing git origin + companies/manifest.yaml.
+    const remoteOwnerSlug = typeof obs.remoteOwnerSlug === "string"
+        ? obs.remoteOwnerSlug
+        : deriveRemoteOwnerSlug({
+            cwd: cwd ?? process.cwd(),
+            hqRoot,
+        }) ?? undefined;
+    const company = resolveCompany({
+        root: deps.root,
+        sessionId,
+        env,
+        trusted,
+        cwd,
+        hqRoot,
+        remoteOwnerSlug,
+        existingState: prior,
+    });
+    const nowIso = nowFn().toISOString();
+    const startedAt = prior?.startedAt ?? nowIso;
+    const toolWrites = typeof obs.toolWrites === "number" && obs.toolWrites >= 0
+        ? Math.floor(obs.toolWrites)
+        : prior?.toolWrites;
+    const hasTurn = Boolean(obs.hasTurn || deps.markTurn || prior?.hasTurn);
+    const transcriptFields = obs.source === "transcript"
+        ? {
+            source: "transcript",
+            transcriptMarker: "from transcript",
+        }
+        : {};
+    if (company.status === "needs_company") {
+        let statePath;
+        try {
+            statePath = writeSessionState(mergeLocalSessionFields({
+                contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+                sessionId,
+                contextStatus: "needs_company",
+                updatedAt: nowIso,
+                startedAt,
+                ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+                ...(hasTurn ? { hasTurn: true } : {}),
+                ...transcriptFields,
+            }, prior), deps.root);
+        }
+        catch (err) {
+            if (err instanceof NotTrackingError) {
+                return {
+                    result: resultOf({
+                        kind: "error",
+                        classification: "needs_company",
+                        delivery: "clean",
+                        sessionId,
+                        clientOperationId: obs.clientOperationId,
+                        errorCode: "NOT_TRACKING",
+                    }),
+                    exitCode: EXIT_NOT_TRACKING,
+                    diagnostics: [err.message],
+                };
+            }
+            throw err;
+        }
+        return {
+            result: resultOf({
+                kind: "needs_company",
+                classification: "needs_company",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: ["needs_company: no tenant read or write"],
+            statePath,
+        };
+    }
+    if (company.status === "company_conflict") {
+        const correctionPath = company.correctionPath ??
+            (company.afterBinding ? companyCorrectionPath(sessionId) : undefined);
+        const statePath = writeSessionState(mergeLocalSessionFields({
+            contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+            sessionId,
+            contextStatus: "company_conflict",
+            companySlug: company.defaultCompany.slug,
+            companyUid: company.defaultCompany.uid,
+            updatedAt: nowIso,
+            startedAt,
+            ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+            ...(hasTurn ? { hasTurn: true } : {}),
+            // Preserve prior binding ids for visibility; do not auto-switch.
+            ...(prior?.projectId ? { projectId: prior.projectId } : {}),
+            ...(prior?.taskId ? { taskId: prior.taskId } : {}),
+            ...(prior?.bindingEpisodeId
+                ? { bindingEpisodeId: prior.bindingEpisodeId }
+                : {}),
+            ...transcriptFields,
+            decision: {
+                decisionId: `conflict_${sessionId}`,
+                options: company.afterBinding
+                    ? [
+                        {
+                            optionId: "correct_company",
+                            label: "Correct company (US-017B)",
+                            kind: "override_evidence",
+                        },
+                    ]
+                    : [
+                        {
+                            optionId: "keep_default",
+                            label: "Keep device default",
+                            kind: "keep_default",
+                        },
+                        {
+                            optionId: "override_evidence",
+                            label: "Use deterministic evidence",
+                            kind: "override_evidence",
+                        },
+                    ],
+                askAfter: false,
+                ...(correctionPath ? { correctionPath } : {}),
+            },
+        }, prior), deps.root);
+        return {
+            result: resultOf({
+                kind: "company_conflict",
+                classification: "company_conflict",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [
+                `company_conflict: default=${company.defaultCompany.slug ?? "?"} evidence=${company.evidenceCompany.slug ?? "?"} — no tenant I/O` +
+                    (correctionPath ? `; correctionPath=${correctionPath}` : ""),
+            ],
+            statePath,
+        };
+    }
+    // Membership-validated slug→uid when local resolution only yielded a slug.
+    let resolvedCompany = company.company;
+    if (!resolvedCompany.uid && resolvedCompany.slug && deps.validateMembership) {
+        try {
+            const membership = await deps.validateMembership(resolvedCompany.slug);
+            if (membership && typeof membership === "object" && membership.uid) {
+                resolvedCompany = {
+                    ...resolvedCompany,
+                    uid: membership.uid,
+                };
+                diagnostics.push(`membership resolved companyUid for slug=${resolvedCompany.slug}`);
+            }
+            else if (membership === false) {
+                diagnostics.push(`membership denied for slug=${resolvedCompany.slug}; treating as needs_company`);
+                const statePath = writeSessionState(mergeLocalSessionFields({
+                    contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+                    sessionId,
+                    contextStatus: "needs_company",
+                    companySlug: resolvedCompany.slug,
+                    updatedAt: nowIso,
+                    startedAt,
+                    ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+                    ...(hasTurn ? { hasTurn: true } : {}),
+                    ...transcriptFields,
+                }, prior), deps.root);
+                return {
+                    result: resultOf({
+                        kind: "needs_company",
+                        classification: "needs_company",
+                        delivery: "clean",
+                        sessionId,
+                        clientOperationId: obs.clientOperationId,
+                    }),
+                    exitCode: EXIT_OK,
+                    diagnostics: [
+                        ...diagnostics,
+                        "needs_company: slug not in active memberships",
+                    ],
+                    statePath,
+                };
+            }
+        }
+        catch (err) {
+            diagnostics.push(`membership lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Company resolved — resolve project/task (US-007B order).
+    const projectResolved = resolveProjectTask({
+        sessionId,
+        env,
+        trusted,
+        cwd,
+        hqRoot,
+        existingState: prior,
+    });
+    const projectId = projectResolved?.projectId;
+    const taskId = projectResolved?.taskId;
+    // Trusted / deterministic auto-bind never asks.
+    // Transcript-sourced sessions never ask (US-018).
+    const fromTranscript = obs.source === "transcript";
+    const autoBound = Boolean(projectResolved &&
+        projectId &&
+        taskId &&
+        (projectResolved.source === "trusted_explicit" ||
+            projectResolved.source === "existing_binding"));
+    const deterministicProjectOnly = Boolean(projectResolved &&
+        projectId &&
+        !taskId &&
+        (projectResolved.source === "deterministic_cwd" ||
+            projectResolved.source === "deterministic_registry"));
+    let classification;
+    if (autoBound) {
+        classification = "bound";
+    }
+    else if (projectId && taskId) {
+        classification = "bound";
+    }
+    else if (projectId || deterministicProjectOnly) {
+        classification = "needs_task";
+    }
+    else {
+        // Unresolved until work signals unlock candidates — never invent a project.
+        classification = "unresolved";
+    }
+    const effectiveClassification = classification;
+    // Prepare one-time decision from server candidates when threshold crossed
+    // and no trusted/deterministic bind applies. Soft evidence never auto-binds.
+    // Transcript fallback never asks / never invents a project.
+    let decision = prior?.decision;
+    const alreadyDecided = Boolean(prior?.decision?.decisionId);
+    const askReady = !fromTranscript &&
+        !autoBound &&
+        !alreadyDecided &&
+        (effectiveClassification === "unresolved" ||
+            effectiveClassification === "needs_task") &&
+        shouldAskAfter({
+            toolWrites,
+            startedAt,
+            hasTurn,
+            now: nowFn(),
+        });
+    if (askReady &&
+        resolvedCompany.uid &&
+        !deps.offline &&
+        deps.fetchCandidates) {
+        try {
+            const candidates = await deps.fetchCandidates({
+                sessionId,
+                companyUid: resolvedCompany.uid,
+            });
+            decision = decisionFromCandidates(sessionId, candidates);
+            diagnostics.push(`askAfter prepared decisionId=${decision.decisionId} options=${decision.options.length}`);
+        }
+        catch (err) {
+            diagnostics.push(`candidates fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (askReady &&
+        (deps.offline || !deps.fetchCandidates || !resolvedCompany.uid)) {
+        diagnostics.push("work-signal threshold crossed; candidates unavailable — staying unresolved (no invented project)");
+    }
+    else if (!autoBound &&
+        !alreadyDecided &&
+        effectiveClassification === "unresolved") {
+        diagnostics.push("below work-signal threshold; unresolved silently");
+    }
+    // When we have a pending ask, surface as needs_project for visibility.
+    let registerClassification = effectiveClassification;
+    if (decision?.askAfter &&
+        registerClassification === "unresolved") {
+        registerClassification = "needs_project";
+    }
+    let outboxOp;
+    try {
+        outboxOp = enqueueOutbox({
+            clientOperationId: obs.clientOperationId,
+            sessionId,
+            companyUid: resolvedCompany.uid,
+            companySlug: resolvedCompany.slug,
+            projectId,
+            taskId,
+            kind: "register",
+            now: nowFn,
+        }, deps.root);
+    }
+    catch (err) {
+        if (err instanceof NotTrackingError) {
+            return {
+                result: resultOf({
+                    kind: "error",
+                    classification: "unresolved",
+                    delivery: "clean",
+                    sessionId,
+                    clientOperationId: obs.clientOperationId,
+                    errorCode: "NOT_TRACKING",
+                }),
+                exitCode: EXIT_NOT_TRACKING,
+                diagnostics: [err.message],
+            };
+        }
+        throw err;
+    }
+    diagnostics.push(`outbox queued ${outboxOp.operationId}`);
+    if (projectResolved) {
+        diagnostics.push(`project source=${projectResolved.source} projectId=${projectId ?? "-"} taskId=${taskId ?? "-"}`);
+    }
+    let statePath;
+    try {
+        const stateWrite = mergeLocalSessionFields({
+            contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+            sessionId,
+            companyUid: resolvedCompany.uid,
+            companySlug: resolvedCompany.slug,
+            contextStatus: registerClassification,
+            projectId,
+            taskId,
+            updatedAt: nowIso,
+            startedAt,
+            ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+            ...(hasTurn ? { hasTurn: true } : {}),
+            ...(decision ? { decision } : {}),
+            ...transcriptFields,
+        }, prior);
+        statePath = writeSessionState(stateWrite, deps.root);
+    }
+    catch (err) {
+        if (err instanceof NotTrackingError) {
+            return {
+                result: resultOf({
+                    kind: "error",
+                    classification: registerClassification,
+                    delivery: "queued",
+                    sessionId,
+                    clientOperationId: obs.clientOperationId,
+                    companyUid: resolvedCompany.uid,
+                    projectId,
+                    taskId,
+                    errorCode: "NOT_TRACKING",
+                }),
+                exitCode: EXIT_NOT_TRACKING,
+                diagnostics: [err.message],
+                outboxOperationId: outboxOp.operationId,
+            };
+        }
+        throw err;
+    }
+    if (deps.offline || !deps.deliver) {
+        return {
+            result: resultOf({
+                kind: "queued",
+                classification: registerClassification,
+                delivery: "queued",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                companyUid: resolvedCompany.uid,
+                projectId,
+                taskId,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [...diagnostics, "offline/local: operation remains queued"],
+            statePath,
+            outboxOperationId: outboxOp.operationId,
+        };
+    }
+    const delivered = await deps.deliver(outboxOp);
+    if (delivered.ok) {
+        markOutboxAcked(outboxOp.operationId, deps.root, delivered.receiptId, nowFn);
+        // Persist binding episode on success for bound registrations.
+        if (registerClassification === "bound") {
+            writeSessionState(mergeLocalSessionFields({
+                contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+                sessionId,
+                companyUid: resolvedCompany.uid,
+                companySlug: resolvedCompany.slug,
+                contextStatus: "bound",
+                projectId,
+                taskId,
+                bindingEpisodeId: delivered.receiptId,
+                updatedAt: nowFn().toISOString(),
+                startedAt,
+                ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+                ...(hasTurn ? { hasTurn: true } : {}),
+                ...transcriptFields,
+            }, prior), deps.root);
+        }
+        const kind = registerClassification === "bound"
+            ? "bound"
+            : registerClassification === "needs_task"
+                ? "needs_task"
+                : registerClassification === "needs_project"
+                    ? "needs_project"
+                    : "queued";
+        return {
+            result: resultOf({
+                kind: kind === "queued" ? "queued" : kind,
+                classification: registerClassification,
+                delivery: "acked",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                companyUid: resolvedCompany.uid,
+                projectId,
+                taskId,
+                bindingEpisodeId: delivered.receiptId,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [...diagnostics, `acked receipt=${delivered.receiptId}`],
+            statePath,
+            outboxOperationId: outboxOp.operationId,
+        };
+    }
+    if (delivered.retryable) {
+        markOutboxQueued(outboxOp.operationId, deps.root, delivered.code, nowFn);
+        return {
+            result: resultOf({
+                kind: "queued",
+                classification: registerClassification,
+                delivery: "queued",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                companyUid: resolvedCompany.uid,
+                projectId,
+                taskId,
+                errorCode: delivered.code,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [...diagnostics, `transient ${delivered.code}; remains queued`],
+            statePath,
+            outboxOperationId: outboxOp.operationId,
+        };
+    }
+    markOutboxQuarantined(outboxOp.operationId, deps.root, delivered.code, nowFn);
+    return {
+        result: resultOf({
+            kind: "error",
+            classification: registerClassification,
+            delivery: "quarantined",
+            sessionId,
+            clientOperationId: obs.clientOperationId,
+            companyUid: resolvedCompany.uid,
+            projectId,
+            taskId,
+            errorCode: delivered.code,
+        }),
+        exitCode: EXIT_OK,
+        diagnostics: [...diagnostics, `quarantined: ${delivered.code}`],
+        statePath,
+        outboxOperationId: outboxOp.operationId,
+    };
+}
+export { replayOutbox };
+//# sourceMappingURL=reconcile.js.map

package/dist/lib/work-context/repo-remote.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Deterministic company ownership from the enclosing git remote (US-007A).
+ *
+ * Walks up from cwd to find a .git dir/file, reads origin's URL from .git/config
+ * (no git subprocess), normalises to owner/name, and matches against
+ * companies/manifest.yaml repos. Zero or multiple matches → no signal.
+ */
+export interface CompaniesManifestEntry {
+    repos?: unknown;
+    [k: string]: unknown;
+}
+export type CompaniesManifestMap = Record<string, CompaniesManifestEntry | null | undefined>;
+/**
+ * Normalise a git remote URL to `owner/name`.
+ * Handles https://github.com/owner/name(.git), git@github.com:owner/name(.git),
+ * and ssh://git@github.com/owner/name(.git). Returns null when unrecognised.
+ */
+export declare function normalizeRemoteOwnerName(remoteUrl: string): string | null;
+/** Walk up from startDir looking for a `.git` directory or file. */
+export declare function findEnclosingGitDir(startDir: string): string | null;
+/**
+ * Read `remote.origin.url` from a `.git/config` (ini-style). No subprocess.
+ */
+export declare function readOriginRemoteUrl(gitDir: string): string | null;
+/**
+ * Match normalised `owner/name` against companies/manifest repos.
+ * A repo entry matches if it equals owner/name (case-insensitive) or is a URL
+ * that normalises to the same owner/name. Exactly one company → its slug;
+ * zero or more than one → null.
+ */
+export declare function matchCompanySlugForRepo(ownerName: string, companies: CompaniesManifestMap): string | null;
+export declare function readCompaniesManifestMap(hqRoot: string): CompaniesManifestMap | null;
+/**
+ * Derive the deterministic remote-owner company slug from cwd + HQ manifest.
+ * Returns null when there is no unique match.
+ */
+export declare function deriveRemoteOwnerSlug(opts: {
+    cwd?: string;
+    hqRoot?: string;
+    /** Injectable manifest reader (tests). */
+    readManifest?: (hqRoot: string) => CompaniesManifestMap | null;
+}): string | null;
+//# sourceMappingURL=repo-remote.d.ts.map