@indigoai-us/hq-cli 5.123.2 → 5.125.0

package/dist/lib/doctor/checks/work-context.js

@@ -6,7 +6,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { readDeviceConfig, getDefaultCompany, } from "../../work-context/config.js";
+import { readDeviceConfig, } from "../../work-context/config.js";
 import { outboxStats, listOutboxOperations } from "../../work-context/outbox.js";
 import { workContextRoot, workContextSessionsDir } from "../../work-context/paths.js";
 import { countJsonlLines, deadLetterNonEmpty, } from "../../mesh/live/spool.js";
@@ -96,7 +96,9 @@ function runChecks(deps) {
     // Default-company mode + migration capability (US-017B)
     try {
         const cfg = readDeviceConfig({ root });
-        const def = getDefaultCompany({ root });
+        const def = cfg.defaultCompany?.enabled && cfg.defaultCompany.slug
+            ? cfg.defaultCompany
+            : null;
         const mode = def?.enabled
             ? `enabled slug=${def.slug}`
             : "disabled (dark / unset)";

package/dist/lib/mesh/live/backfill-held.d.ts

@@ -111,6 +111,8 @@ export interface BackfillHeldDeps {
      * meta) in BOTH the dry-run predictor and the write path, so the two agree.
      */
     remoteOwnerHint?: string;
+    /** Historical device-default repair is opt-in; false keeps no-evidence sessions held. */
+    useDeviceDefault?: boolean;
     /** Env passed to the dry-run resolver (tests). Default process.env. */
     env?: NodeJS.ProcessEnv;
     /**

package/dist/lib/mesh/live/backfill-held.js

@@ -231,7 +231,7 @@ export function observationFromHeldRef(ref, contractVersion, clientOperationId)
  * the write run can still under-count; the gross all-or-nothing mismatch is
  * gone because both paths key off this same resolver + evidence.
  */
-function defaultPredictCompany(ref, workContextRoot, remoteOwnerHint, env) {
+function defaultPredictCompany(ref, workContextRoot, remoteOwnerHint, env, useDeviceDefault) {
     // This predictor is called only with a ref already rebuilt from trusted local
     // evidence. Do not let raw held-event cwd/hqRoot values re-enter resolution.
     const remoteOwnerSlug = remoteOwnerHint?.trim();
@@ -241,6 +241,7 @@ function defaultPredictCompany(ref, workContextRoot, remoteOwnerHint, env) {
         env,
         trusted: ref.companySlug ? { companySlug: ref.companySlug } : undefined,
         remoteOwnerSlug,
+        allowDeviceDefault: useDeviceDefault,
     });
     return resolution.status === "resolved";
 }
@@ -385,7 +386,7 @@ export async function backfillHeldSessions(deps) {
     const env = deps.env ?? process.env;
     const newOperationId = deps.newOperationId ?? (() => globalThis.crypto.randomUUID());
     const predictCompany = deps.predictCompany ??
-        ((ref) => defaultPredictCompany(ref, deps.workContextRoot, deps.remoteOwnerHint, env));
+        ((ref) => defaultPredictCompany(ref, deps.workContextRoot, deps.remoteOwnerHint, env, deps.useDeviceDefault === true));
     const sessions = readHeldSessions(deps.workMeshRoot);
     // An acked register is authoritative local evidence. Older clients could
     // lose its state projection on a later hook write; recover that projection
@@ -434,7 +435,10 @@ export async function backfillHeldSessions(deps) {
                 continue;
             }
         }
-        if (!evidence.candidate?.slug) {
+        // Historical repair may use the explicitly opted-in device default only
+        // when there is no durable local company evidence. Never manufacture a
+        // slug from the held event itself.
+        if (!evidence.candidate?.slug && deps.useDeviceDefault !== true) {
             result.unresolved += 1;
             deps.log?.(`would stay unresolved ${sessionId} (${hasOnlyStaleEventEvidence(ref, state) ? "STALE_EVIDENCE" : "no local company evidence"})`);
             continue;
@@ -442,7 +446,7 @@ export async function backfillHeldSessions(deps) {
         const evidenceRef = {
             sessionId,
             harness,
-            companySlug: evidence.candidate.slug,
+            companySlug: evidence.candidate?.slug,
             // Held-event fields are transport input, not trusted context. Preserve
             // project/task only when the durable session state already owns them.
             project: state?.projectId,

package/dist/lib/mesh/live/daemon/board-refresh.d.ts

@@ -6,6 +6,7 @@
  * authoritative in ProjectView because `hq mesh story` writes there.
  * Metadata-only snapshot — never prompts or tokens.
  */
+import type { SessionStateFile } from "../../../work-context/state.js";
 export declare const BOARD_REFRESH_INTERVAL_MS = 60000;
 export interface BoardStorySnapshot {
     id: string;
@@ -26,6 +27,8 @@ export interface BoardRefreshDeps {
     /** Per-session last refresh timestamps (ms). */
     lastRefresh?: Map<string, number>;
     intervalMs?: number;
+    /** Authorizes a device-default-derived session before its tenant read. */
+    authorizeDeviceDefaultTenant?: (sessionId: string, state: SessionStateFile) => Promise<boolean>;
 }
 export declare function formatBoardMarkdown(input: {
     sessionId: string;

package/dist/lib/mesh/live/daemon/board-refresh.js

@@ -92,6 +92,12 @@ export async function refreshBoundSessionBoards(deps) {
             skipped += 1;
             continue;
         }
+        if (state.companyConfidence === "device_default" &&
+            deps.authorizeDeviceDefaultTenant &&
+            !(await deps.authorizeDeviceDefaultTenant(sessionId, state))) {
+            skipped += 1;
+            continue;
+        }
         try {
             const board = await deps.readBoard(state.companyUid, state.projectId);
             if (!board) {

package/dist/lib/mesh/live/daemon/doctor.d.ts

@@ -19,6 +19,7 @@ export interface DaemonDoctorReport {
     heldCount: number;
     /** Distinct held sessions with neither bound state nor local company evidence. */
     heldWithNoLocalEvidence: number;
+    attributedByDeviceDefault: number;
     deadLetterCount: number;
     /** Events in any local queue still marked no-company / NEEDS_COMPANY / NONE. */
     unattributedEvents: UnattributedEventCounts;
@@ -47,6 +48,8 @@ export interface DaemonDoctorReport {
         rejected?: number;
         error?: string;
     };
+    /** Work held or quarantined after default-derived membership was denied. */
+    deviceDefaultAuthorizationDenials: number;
 }
 export interface DaemonDoctorDeps {
     home?: string;

package/dist/lib/mesh/live/daemon/doctor.js

@@ -4,6 +4,7 @@
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
+import * as path from "node:path";
 import { describeCognitoTokenSource, } from "../../../../utils/cognito-session.js";
 import { listOutboxOperations, outboxStats, } from "../../../work-context/outbox.js";
 import { readSessionState } from "../../../work-context/state.js";
@@ -52,6 +53,21 @@ function oldestJsonlAgeMs(filePath, nowMs) {
         return undefined;
     }
 }
+function countDeviceDefaultAttribution(root) {
+    try {
+        return fs.readdirSync(path.join(root, "sessions")).filter((entry) => {
+            if (!entry.endsWith(".json"))
+                return false;
+            const state = readSessionState(entry.slice(0, -5), root);
+            return state?.companyConfidence === "device_default" &&
+                Boolean(state.companyUid) &&
+                state.contextStatus !== "needs_company";
+        }).length;
+    }
+    catch {
+        return 0;
+    }
+}
 export function collectDaemonDoctor(deps = {}) {
     const home = deps.home ?? os.homedir();
     const env = deps.env ?? process.env;
@@ -88,6 +104,7 @@ export function collectDaemonDoctor(deps = {}) {
             !hasCurrentAcknowledgedRegistration(ref, state, outboxOperations, deps.hqRoot ?? env.HQ_ROOT?.trim(), trustedRoots) &&
             !refWithLocalCompanyEvidence(ref, deps.hqRoot ?? env.HQ_ROOT?.trim(), trustedRoots, state));
     }).length;
+    const attributedByDeviceDefault = countDeviceDefaultAttribution(ctxRoot);
     const deadLetterCount = countJsonlLines(deadPath);
     const unattributedEvents = countUnattributedEvents(meshRoot);
     const outbox = outboxStats(ctxRoot);
@@ -95,6 +112,7 @@ export function collectDaemonDoctor(deps = {}) {
     const companiesOnline = state?.companiesOnline ?? [];
     const emitMode = state?.emitMode ?? "legacy";
     const subscribed = mqttState === "connected";
+    const deviceDefaultAuthorizationDenials = state?.deviceDefaultAuthorizationDenials ?? 0;
     const oldestSpoolAgeMs = oldestJsonlAgeMs(spoolPath, now());
     const unhealthyReasons = [];
     const online = mqttState === "connected" && companiesOnline.length > 0;
@@ -140,6 +158,7 @@ export function collectDaemonDoctor(deps = {}) {
         spoolDepth,
         heldCount,
         heldWithNoLocalEvidence,
+        attributedByDeviceDefault,
         deadLetterCount,
         unattributedEvents,
         outboxDepth: outbox.depth,
@@ -164,6 +183,7 @@ export function collectDaemonDoctor(deps = {}) {
                 error: emitState.lastError,
             }
             : undefined,
+        deviceDefaultAuthorizationDenials,
     };
 }
 export function formatDaemonDoctor(report) {
@@ -179,7 +199,7 @@ export function formatDaemonDoctor(report) {
         // receive-only (direct) mode.
         lines.push(`spool depth: ${report.spoolDepth}`, `held: ${report.heldCount}`, `held with no local evidence: ${report.heldWithNoLocalEvidence}`, `outbox depth: ${report.outboxDepth}`);
     }
-    lines.push(`dead-letter: ${report.deadLetterCount}`, `unattributed events: ${report.unattributedEvents.total} ` +
+    lines.push(`attributed by device default: ${report.attributedByDeviceDefault}`, `device-default authorization denials: ${report.deviceDefaultAuthorizationDenials}`, `dead-letter: ${report.deadLetterCount}`, `unattributed events: ${report.unattributedEvents.total} ` +
         `(spool=${report.unattributedEvents.spool} held=${report.unattributedEvents.held} dead-letter=${report.unattributedEvents.deadLetter})`, `token source: ${report.tokenSource}`, `actor kind: ${report.actorKind}`);
     if (report.emitMode === "legacy") {
         lines.push(`last flush: ${report.lastFlushAt ?? "(never)"}${report.lastFlushResult

package/dist/lib/mesh/live/daemon/run.d.ts

@@ -8,8 +8,11 @@
  * - MQTT presence (contract-3)
  * - SIGTERM/SIGINT: flush once more, MQTT DISCONNECT (server derives offline), exit
  */
+import { type DeliverFn } from "../../../work-context/outbox.js";
+import { type SessionEventsPoster } from "../session-events-client.js";
 import { type FlushSummary } from "../flush.js";
 import { type BackfillHeldResult } from "../backfill-held.js";
+import { type BoardReader } from "./board-refresh.js";
 import { type CredentialsFetcher, type TimerHost } from "./credentials.js";
 import { type PidLockDeps } from "./pid-lock.js";
 import { PresenceClient, type MqttConnectFn } from "./presence.js";
@@ -19,6 +22,7 @@ export declare const SPOOL_DEBOUNCE_MS = 2000;
 export declare const FLUSH_INTERVAL_MS = 10000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
 export declare const HELD_BACKFILL_STARTUP_BATCH_SIZE = 100;
+export declare const DEVICE_DEFAULT_MEMBERSHIP_TIMEOUT_MS = 2000;
 /** Non-zero exit reserved for CLI version drift so legacy Restart=on-failure units restart. */
 export declare const DAEMON_VERSION_DRIFT_EXIT_CODE = 75;
 /**
@@ -79,6 +83,13 @@ export interface DaemonRunDeps {
     exit?: (code: number) => void;
     /** Token provider (tests). */
     getToken?: () => Promise<string>;
+    /** Low-level tenant I/O seams used by authorization regression tests. */
+    poster?: SessionEventsPoster;
+    deliver?: DeliverFn;
+    readBoard?: BoardReader;
+    resolveMembership?: (token: string, slug: string, signal?: AbortSignal) => Promise<{
+        companyUid: string;
+    } | null>;
     log?: (dir: string, line: string) => void;
     /** Stop after this many ms (tests). */
     runForMs?: number;

package/dist/lib/mesh/live/daemon/run.js

@@ -13,10 +13,13 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { CLI_VERSION } from "../../../../cli-version.js";
 import { createWorkSessionDeliverer } from "../../client.js";
-import { meshJson, resolveActiveMembershipCompany } from "../../api.js";
+import { listActiveMembershipCompanies, meshJson, resolveActiveMembershipCompany } from "../../api.js";
 import { ensureCognitoToken } from "../../../../utils/cognito-session.js";
 import { replayOutbox } from "../../../work-context/outbox.js";
 import { workContextRoot } from "../../../work-context/paths.js";
+import { ensureDefaultCompany } from "../../../work-context/default-company.js";
+import { invalidateDefaultCompanyMemberships, readDeviceConfig, } from "../../../work-context/config.js";
+import { readSessionState, writeSessionState, } from "../../../work-context/state.js";
 import { createSessionEventsPoster, resolveVaultApiBase, } from "../session-events-client.js";
 import { flushSessionEvents, HELD_RETRY_INTERVAL_MS, } from "../flush.js";
 import { backfillHeldSessions, } from "../backfill-held.js";
@@ -28,7 +31,7 @@ import { appendDaemonLog, daemonLogLine, ensureDaemonLog } from "./log.js";
 import { acquirePidLock, defaultPidLockDeps, releasePidLock, } from "./pid-lock.js";
 import { daemonDir } from "./paths.js";
 import { PresenceClient, } from "./presence.js";
-import { defaultDaemonState, patchDaemonState, writeDaemonState, } from "./state.js";
+import { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
 import { workMeshHeldPath } from "../paths.js";
 import { noteHookSessionsFromSpoolFile, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, } from "./transcript-watch.js";
 import { resolveMeshEmitMode, runsEmitPath, } from "./mode.js";
@@ -38,6 +41,7 @@ export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
 export const HELD_BACKFILL_STARTUP_BATCH_SIZE = 100;
+export const DEVICE_DEFAULT_MEMBERSHIP_TIMEOUT_MS = 2_000;
 /** Non-zero exit reserved for CLI version drift so legacy Restart=on-failure units restart. */
 export const DAEMON_VERSION_DRIFT_EXIT_CODE = 75;
 /**
@@ -111,12 +115,69 @@ export async function runMeshDaemon(deps = {}) {
     // daemon went dark once its IoT credentials expired.
     const defaultGetToken = async () => ensureCognitoToken({ interactive: false, tokenSource: "machine" });
     const getToken = deps.getToken ?? defaultGetToken;
+    const resolveMembership = deps.resolveMembership ?? resolveActiveMembershipCompany;
+    /** The sole authorization seam for daemon tenant I/O derived from a device default. */
+    const tenantGate = {
+        authorize: async (input) => {
+            const state = input.state ?? (input.sessionId
+                ? readSessionState(input.sessionId, ctxRoot)
+                : null);
+            const slug = input.companySlug ?? state?.companySlug;
+            const membership = await (async () => {
+                try {
+                    if (!slug)
+                        return null;
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), DEVICE_DEFAULT_MEMBERSHIP_TIMEOUT_MS);
+                    try {
+                        return await Promise.race([
+                            resolveMembership(await getToken(), slug, controller.signal),
+                            new Promise((resolve) => controller.signal.addEventListener("abort", () => resolve(null), { once: true })),
+                        ]);
+                    }
+                    finally {
+                        clearTimeout(timeout);
+                    }
+                }
+                catch {
+                    return null;
+                }
+            })();
+            const uid = membership?.companyUid;
+            if (!input.deviceDefault)
+                return uid ? { uid } : false;
+            if (uid &&
+                (!input.companyUid || input.companyUid === uid) &&
+                (!state?.companyUid || state.companyUid === uid)) {
+                return { uid };
+            }
+            try {
+                invalidateDefaultCompanyMemberships({ root: ctxRoot, now });
+            }
+            catch (err) {
+                log(dir, `default membership cache invalidation failed: ${String(err).slice(0, 160)}`);
+            }
+            if (state) {
+                writeSessionState({
+                    ...state,
+                    companyUid: undefined,
+                    companySlug: undefined,
+                    contextStatus: "needs_company",
+                    updatedAt: now().toISOString(),
+                }, ctxRoot);
+            }
+            const prior = readDaemonState(dir)?.deviceDefaultAuthorizationDenials ?? 0;
+            patchDaemonState(dir, { deviceDefaultAuthorizationDenials: prior + 1 }, now);
+            log(dir, `device-default membership denied${slug ? ` company=${slug}` : ""}; work held`);
+            return false;
+        },
+    };
     /** In-memory held re-attempt throttle (survives watch-triggered flushes). */
     let lastHeldRetryAtMs = 0;
     const flushFn = deps.flush ??
         (async () => {
             const t = await getToken();
-            const poster = createSessionEventsPoster({
+            const poster = deps.poster ?? createSessionEventsPoster({
                 token: t,
                 baseUrl: resolveVaultApiBase(env),
             });
@@ -130,32 +191,81 @@ export async function runMeshDaemon(deps = {}) {
                     lastHeldRetryAtMs = atMs;
                 },
                 log: (message) => log(dir, message),
+                authorizeDeviceDefaultTenant: async (state) => Boolean(await tenantGate.authorize({
+                    state,
+                    companySlug: state.companySlug,
+                    companyUid: state.companyUid,
+                    deviceDefault: true,
+                })),
             });
         });
     const replayFn = deps.replayOutbox ??
         (async () => {
             const t = await getToken();
-            const deliver = createWorkSessionDeliverer({ token: t });
-            return replayOutbox(ctxRoot, deliver);
+            const deliver = deps.deliver ?? createWorkSessionDeliverer({ token: t });
+            return replayOutbox(ctxRoot, async (op) => {
+                const state = readSessionState(op.sessionId, ctxRoot);
+                // Provenance must survive session-state loss. For pre-upgrade outbox
+                // entries without provenance, absent state is unknown and therefore
+                // requires the same membership check before delivery.
+                const requiresMembershipCheck = op.companyConfidence === "device_default" ||
+                    state?.companyConfidence === "device_default" ||
+                    // Pre-provenance entries are untrusted even if an equally legacy
+                    // session state happens to exist. A current membership read is the
+                    // only authority that may release them.
+                    !op.companyConfidence;
+                if (requiresMembershipCheck) {
+                    const allowed = await tenantGate.authorize({
+                        state: state ?? undefined,
+                        companySlug: op.companySlug ?? state?.companySlug,
+                        companyUid: op.companyUid ?? state?.companyUid,
+                        deviceDefault: true,
+                    });
+                    if (!allowed) {
+                        return { ok: false, retryable: false, code: "DEVICE_DEFAULT_MEMBERSHIP_DENIED" };
+                    }
+                }
+                return deliver(op);
+            });
         });
+    const activateDefaultCompany = async () => {
+        try {
+            const token = await getToken();
+            await ensureDefaultCompany({
+                root: ctxRoot,
+                env,
+                listMemberships: () => listActiveMembershipCompanies(token),
+                log: (message) => log(dir, message),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log(dir, `default company activation skipped: ${message.slice(0, 160)}`);
+        }
+    };
     const backfillFn = deps.backfillHeld ??
         (async () => {
+            await activateDefaultCompany();
             const token = await getToken();
             const deliver = createWorkSessionDeliverer({ token });
+            const useDeviceDefault = readDeviceConfig({ root: ctxRoot }).repairHeldWithDefault === true;
             return backfillHeldSessions({
                 workMeshRoot: meshRoot,
                 workContextRoot: ctxRoot,
                 hqRoots: trustedRoots,
                 limit: deps.heldBackfillBatchSize ?? HELD_BACKFILL_STARTUP_BATCH_SIZE,
                 env,
+                useDeviceDefault,
                 reconcile: (observation) => reconcileObservation(observation, {
                     root: ctxRoot,
                     env,
                     deliver,
-                    validateMembership: async (slug) => {
-                        const membership = await resolveActiveMembershipCompany(token, slug);
-                        return membership ? { uid: membership.companyUid } : false;
-                    },
+                    validateMembership: async (slug) => tenantGate.authorize({
+                        companySlug: slug,
+                        deviceDefault: useDeviceDefault,
+                    }),
+                    allowDeviceDefault: useDeviceDefault,
+                    deviceDefaultConfidence: useDeviceDefault,
                 }),
             });
         });
@@ -163,7 +273,7 @@ export async function runMeshDaemon(deps = {}) {
     const refreshFn = deps.refreshBoards ??
         (async () => {
             const t = await getToken();
-            const reader = createVaultBoardReader({
+            const reader = deps.readBoard ?? createVaultBoardReader({
                 getJson: (p) => meshJson(t, p),
             });
             return refreshBoundSessionBoards({
@@ -172,6 +282,12 @@ export async function runMeshDaemon(deps = {}) {
                 lastRefresh: boardLast,
                 intervalMs: BOARD_REFRESH_INTERVAL_MS,
                 now: () => timers.now(),
+                authorizeDeviceDefaultTenant: async (_sessionId, state) => Boolean(await tenantGate.authorize({
+                    state,
+                    companySlug: state.companySlug,
+                    companyUid: state.companyUid,
+                    deviceDefault: true,
+                })),
             });
         });
     let presence = null;
@@ -490,6 +606,9 @@ export async function runMeshDaemon(deps = {}) {
     if (!requestRestartForVersionDrift() && emitPath) {
         void doFlushCycle("start");
     }
+    else {
+        void activateDefaultCompany();
+    }
     void refreshFn().catch(() => undefined);
     if (emitPath) {
         void runTranscriptTick();

package/dist/lib/mesh/live/daemon/state.d.ts

@@ -27,6 +27,8 @@ export interface DaemonStateFile {
     presenceRefusal?: PresenceRefusalState | null;
     /** Daemon emit mode: "legacy" (spool/flush) or "direct" (receive-only). */
     emitMode?: "legacy" | "direct";
+    /** Authoritative membership denials for device-default-derived tenant I/O. */
+    deviceDefaultAuthorizationDenials?: number;
     updatedAt: string;
 }
 export declare function defaultDaemonState(pid: number, now?: () => Date): DaemonStateFile;

package/dist/lib/mesh/live/flush.d.ts

@@ -8,6 +8,7 @@
  * Orphan `*.claimed` files from a prior crash are recovered first.
  * 2xx responses are accounted per eventId (accepted / duplicates / rejected).
  */
+import { type SessionStateFile } from "../../work-context/state.js";
 import { type RandomFn, type SleepFn } from "./backoff.js";
 import { type SessionEventsPoster } from "./session-events-client.js";
 export declare const HELD_TTL_MS: number;
@@ -43,6 +44,8 @@ export interface FlushDeps {
     heldMaxLines?: number;
     /** Optional logger (daemon wires this); used once per overflow trim. */
     log?: (message: string) => void;
+    /** Authoritative gate for state derived from a device default. */
+    authorizeDeviceDefaultTenant?: (state: SessionStateFile) => Promise<boolean>;
 }
 export interface FlushSummary {
     claimed: number;

package/dist/lib/mesh/live/flush.js

@@ -218,6 +218,17 @@ export async function flushSessionEvents(deps) {
         };
         for (const [sessionId, items] of bySession) {
             const state = readSessionState(sessionId, deps.workContextRoot);
+            if (state?.companyConfidence === "device_default" &&
+                deps.authorizeDeviceDefaultTenant &&
+                !(await deps.authorizeDeviceDefaultTenant(state))) {
+                const heldAt = now().toISOString();
+                for (const item of items) {
+                    appendHeldLine(heldEnvelope(item.event, "NEEDS_COMPANY", item.heldAt ?? heldAt), deps.workMeshRoot);
+                    summary.held += 1;
+                    markDisposed(item.event);
+                }
+                continue;
+            }
             const decision = classifySession(state);
             if (decision.action === "drop") {
                 appendDroppedReceipt({

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

@@ -65,6 +65,8 @@ export interface CompanyResolveInput {
      * session-meta. Omitted (or unmapped) → the ladder falls through unchanged.
      */
     repoIdentityKey?: string | null;
+    /** Explicit historical repair may disable weak device-default evidence. */
+    allowDeviceDefault?: boolean;
 }
 /** Env naming the on-box identity.json (fleet agent boxes). */
 export declare const HQ_AGENT_IDENTITY_FILE_ENV = "HQ_AGENT_IDENTITY_FILE";
@@ -76,6 +78,12 @@ export declare const DEFAULT_AGENT_IDENTITY_FILE = "/var/lib/hq-agent/identity.j
  * (never throws; never logs file contents).
  */
 export declare function readAgentIdentityCompanyUid(env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Agent boxes must never infer a human device default. The file itself is the
+ * machine marker; legacy identity files do not necessarily contain a company
+ * UID, so parsing for that field is not an eligibility check.
+ */
+export declare function hasAgentIdentityFile(env?: NodeJS.ProcessEnv): boolean;
 /**
  * Compare companies: UIDs when both sides have them; otherwise normalized
  * slugs when both have slugs. Never treat uid+slug vs slug-only as a

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

@@ -63,6 +63,23 @@ export function readAgentIdentityCompanyUid(env = process.env) {
         return undefined;
     }
 }
+/**
+ * Agent boxes must never infer a human device default. The file itself is the
+ * machine marker; legacy identity files do not necessarily contain a company
+ * UID, so parsing for that field is not an eligibility check.
+ */
+export function hasAgentIdentityFile(env = process.env) {
+    const configured = env[HQ_AGENT_IDENTITY_FILE_ENV];
+    const identityPath = configured === undefined ? DEFAULT_AGENT_IDENTITY_FILE : configured.trim();
+    if (!identityPath)
+        return false;
+    try {
+        return fs.existsSync(identityPath);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Compare companies: UIDs when both sides have them; otherwise normalized
  * slugs when both have slugs. Never treat uid+slug vs slug-only as a
@@ -178,6 +195,16 @@ export function resolveDeterministicCompany(input) {
     }
     return null;
 }
+function conflictingDeterministicEvidence(input) {
+    const cwd = companySlugFromCwd(input.cwd, input.hqRoot);
+    const remote = normalizeSlug(input.remoteOwnerSlug ?? undefined);
+    if (!cwd || !remote || cwd.toLowerCase() === remote.toLowerCase())
+        return null;
+    return {
+        cwd: { slug: cwd, source: "deterministic_cwd" },
+        remote: { slug: remote, source: "deterministic_remote" },
+    };
+}
 export function resolveCompany(input) {
     const env = input.env ?? process.env;
     // 1. Trusted explicit: HQ_SPAWN_COMPANY or observation trusted/explicit.
@@ -205,28 +232,31 @@ export function resolveCompany(input) {
             uid: prior.uid,
             source: "existing_scope",
         };
-        // After a binding exists, a suspected other-company mismatch cannot
-        // auto-switch — return company_conflict with the US-017B correction path.
+        // Deterministic evidence from another company never silently replaces a
+        // scoped session, even before it has a project binding. Preserve the
+        // original scope and surface a conflict before tenant I/O.
         const hadBinding = Boolean(state &&
             (state.contextStatus === "bound" ||
                 state.contextStatus === "needs_task" ||
                 state.contextStatus === "needs_project") &&
             (state.projectId || state.bindingEpisodeId));
-        if (hadBinding) {
-            const deterministic = resolveDeterministicCompany({
-                cwd: input.cwd,
-                hqRoot: input.hqRoot,
-                remoteOwnerSlug: input.remoteOwnerSlug,
-            });
-            if (deterministic && !sameCompany(scoped, deterministic)) {
-                return {
-                    status: "company_conflict",
-                    defaultCompany: scoped,
-                    evidenceCompany: deterministic,
-                    afterBinding: true,
-                    correctionPath: companyCorrectionPath(input.sessionId),
-                };
-            }
+        const deterministic = resolveDeterministicCompany({
+            cwd: input.cwd,
+            hqRoot: input.hqRoot,
+            remoteOwnerSlug: input.remoteOwnerSlug,
+        });
+        if (deterministic && !sameCompany(scoped, deterministic)) {
+            return {
+                status: "company_conflict",
+                defaultCompany: scoped,
+                evidenceCompany: deterministic,
+                ...(hadBinding
+                    ? {
+                        afterBinding: true,
+                        correctionPath: companyCorrectionPath(input.sessionId),
+                    }
+                    : {}),
+            };
         }
         return { status: "resolved", company: scoped };
     }
@@ -264,12 +294,26 @@ export function resolveCompany(input) {
         }
     }
     // 5 + 6. Device default vs deterministic evidence.
-    const deviceDefault = getDefaultCompany({ root: input.root });
+    const deviceDefault = input.allowDeviceDefault === false ? null : getDefaultCompany({ root: input.root });
     const deterministic = resolveDeterministicCompany({
         cwd: input.cwd,
         hqRoot: input.hqRoot,
         remoteOwnerSlug: input.remoteOwnerSlug,
     });
+    const deterministicConflict = conflictingDeterministicEvidence({
+        cwd: input.cwd,
+        hqRoot: input.hqRoot,
+        remoteOwnerSlug: input.remoteOwnerSlug,
+    });
+    // Cwd and remote are both deterministic evidence. Their disagreement is
+    // never permission to fall through to a weaker device preference.
+    if (deterministicConflict) {
+        return {
+            status: "company_conflict",
+            defaultCompany: deterministicConflict.cwd,
+            evidenceCompany: deterministicConflict.remote,
+        };
+    }
     if (deviceDefault?.enabled && deviceDefault.slug) {
         const def = {
             slug: deviceDefault.slug,