@indigoai-us/hq-cli 5.124.0 → 5.126.0

package/dist/lib/lanes/types.js

@@ -0,0 +1,217 @@
+/**
+ * Lane record, question routing record, envelope, and config types (spec §3,
+ * §4, §5.5, §6.2). Finite sets are string-literal unions plus `const` arrays
+ * so the command layer can validate flags explicitly.
+ */
+import { LanesError, LaneSchemaError } from "./errors.js";
+export const LANE_SCHEMA_VERSION = "hq-lane.v1";
+export const QUESTION_SCHEMA_VERSION = "hq-lane-question.v1";
+export const ENVELOPE_SCHEMA_VERSION = "hq-lane-envelope.v1";
+export const CONFIG_SCHEMA_VERSION = "hq-lanes-config.v1";
+export const LANE_STATES = [
+    "queued",
+    "running",
+    "awaiting_input",
+    "blocked",
+    "done",
+    "failed",
+    "interrupted",
+    "cancelled",
+    "killed",
+];
+/** Exact terminal set from spec §6.7. `awaiting_input` and `blocked` are not terminal. */
+export const TERMINAL_LANE_STATES = [
+    "done",
+    "failed",
+    "interrupted",
+    "cancelled",
+    "killed",
+];
+export const LANE_PROVIDERS = ["claude", "codex", "grok"];
+export const QUEUED_REASONS = ["cap", "queue_position", "throttle"];
+export const HOST_KINDS = ["local", "outpost"];
+export const SENIOR_KINDS = ["session", "lane", "user"];
+export const ENVELOPE_DECISIONS = ["done", "ask", "blocked"];
+export const STORY_STATUSES = [
+    "queued",
+    "in_progress",
+    "review",
+    "done",
+];
+export const QUESTION_STATUSES = [
+    "pending",
+    "answered",
+    "cancelled",
+    "expired",
+];
+export const RAISED_VIA = ["cli", "envelope"];
+export const ROUTING_REASONS = [
+    "asked",
+    "escalated",
+    "audience_ended",
+    "reparented",
+    "unanswered_timeout",
+    "cancelled",
+];
+export const QUESTION_BODY_STORES = ["company", "personal"];
+export const LIVENESS_STATES = ["live", "idle", "ended", "lost"];
+export const HISTORY_CAP = 50;
+const TERMINAL_SET = new Set(TERMINAL_LANE_STATES);
+export function isLaneState(value) {
+    return typeof value === "string" && LANE_STATES.includes(value);
+}
+export function isTerminalLaneState(value) {
+    return typeof value === "string" && TERMINAL_SET.has(value);
+}
+export function isLaneProvider(value) {
+    return (typeof value === "string" &&
+        LANE_PROVIDERS.includes(value));
+}
+export function isSeniorKind(value) {
+    return (typeof value === "string" &&
+        SENIOR_KINDS.includes(value));
+}
+export function isHostKind(value) {
+    return (typeof value === "string" &&
+        HOST_KINDS.includes(value));
+}
+export function isEnvelopeDecision(value) {
+    return (typeof value === "string" &&
+        ENVELOPE_DECISIONS.includes(value));
+}
+export function isQuestionStatus(value) {
+    return (typeof value === "string" &&
+        QUESTION_STATUSES.includes(value));
+}
+export function isLivenessState(value) {
+    return (typeof value === "string" &&
+        LIVENESS_STATES.includes(value));
+}
+export function parseLaneProvider(value) {
+    if (isLaneProvider(value))
+        return value;
+    throw new LanesError("unknown_provider", `Unknown provider ${JSON.stringify(value)}. Accepted: ${LANE_PROVIDERS.join(", ")}`, { accepted: [...LANE_PROVIDERS], value });
+}
+export function parseLaneState(value) {
+    if (isLaneState(value))
+        return value;
+    throw new LanesError("unknown_state", `Unknown lane state ${JSON.stringify(value)}. Accepted: ${LANE_STATES.join(", ")}`, { accepted: [...LANE_STATES], value });
+}
+export function parseQuestionStatus(value) {
+    if (isQuestionStatus(value))
+        return value;
+    throw new LanesError("unknown_status", `Unknown question status ${JSON.stringify(value)}. Accepted: ${QUESTION_STATUSES.join(", ")}`, { accepted: [...QUESTION_STATUSES], value });
+}
+export function parseLivenessState(value) {
+    if (isLivenessState(value))
+        return value;
+    throw new LanesError("unknown_state", `Unknown session liveness state ${JSON.stringify(value)}. Accepted: ${LIVENESS_STATES.join(", ")}`, { accepted: [...LIVENESS_STATES], value });
+}
+export function parseSeniorKind(value) {
+    if (isSeniorKind(value))
+        return value;
+    throw new LanesError("unknown_senior_kind", `Unknown senior kind ${JSON.stringify(value)}. Accepted: ${SENIOR_KINDS.join(", ")}`, { accepted: [...SENIOR_KINDS], value });
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireString(value, field) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new LaneSchemaError(`Expected non-empty string for ${field}`, {
+            field,
+        });
+    }
+    return value;
+}
+export function parseMajorSchema(schemaVersion, expectedPrefix, expectedMajor) {
+    const match = new RegExp(`^${expectedPrefix}\\.v(\\d+)$`).exec(schemaVersion);
+    if (!match) {
+        throw new LaneSchemaError(`Unknown schema_version ${JSON.stringify(schemaVersion)} (expected ${expectedPrefix}.v${expectedMajor})`, { schema_version: schemaVersion, expected: `${expectedPrefix}.v${expectedMajor}` });
+    }
+    const major = Number(match[1]);
+    if (major !== expectedMajor) {
+        throw new LaneSchemaError(`Unsupported ${expectedPrefix} major version ${major} (found ${schemaVersion})`, { schema_version: schemaVersion, major });
+    }
+}
+export function parseLaneEnvelope(raw) {
+    if (!isPlainObject(raw)) {
+        throw new LaneSchemaError("Lane envelope must be a JSON object");
+    }
+    const extra = Object.keys(raw).filter((key) => ![
+        "schema_version",
+        "decision",
+        "summary",
+        "questions",
+        "story_status",
+        "artifacts",
+        "blocked_reason",
+    ].includes(key));
+    if (extra.length > 0) {
+        throw new LaneSchemaError(`Lane envelope rejects unknown properties: ${extra.join(", ")}`, { extra });
+    }
+    const schema_version = requireString(raw.schema_version, "schema_version");
+    parseMajorSchema(schema_version, "hq-lane-envelope", 1);
+    if (!isEnvelopeDecision(raw.decision)) {
+        throw new LaneSchemaError(`Unknown envelope decision ${JSON.stringify(raw.decision)}. Accepted: ${ENVELOPE_DECISIONS.join(", ")}`, { accepted: [...ENVELOPE_DECISIONS], value: raw.decision });
+    }
+    const summary = requireString(raw.summary, "summary");
+    if (typeof raw.story_status !== "string" ||
+        !STORY_STATUSES.includes(raw.story_status)) {
+        throw new LaneSchemaError(`Unknown story_status ${JSON.stringify(raw.story_status)}. Accepted: ${STORY_STATUSES.join(", ")}`, { accepted: [...STORY_STATUSES], value: raw.story_status });
+    }
+    if (!Array.isArray(raw.artifacts)) {
+        throw new LaneSchemaError("Envelope artifacts must be an array");
+    }
+    const questions = raw.questions;
+    if (raw.decision === "ask") {
+        if (!Array.isArray(questions) || questions.length === 0) {
+            throw new LaneSchemaError('questions must be non-empty when decision is "ask"');
+        }
+    }
+    else if (questions !== undefined) {
+        if (!Array.isArray(questions) || questions.length !== 0) {
+            throw new LaneSchemaError('questions must be omitted or empty unless decision is "ask"');
+        }
+    }
+    if (raw.decision === "blocked") {
+        if (typeof raw.blocked_reason !== "string" || raw.blocked_reason.length === 0) {
+            throw new LaneSchemaError('blocked_reason is required when decision is "blocked"');
+        }
+    }
+    else if (raw.blocked_reason !== undefined) {
+        throw new LaneSchemaError('blocked_reason is present exactly when decision is "blocked"');
+    }
+    const envelope = {
+        schema_version: ENVELOPE_SCHEMA_VERSION,
+        decision: raw.decision,
+        summary,
+        story_status: raw.story_status,
+        artifacts: raw.artifacts,
+    };
+    if (Array.isArray(questions) && questions.length > 0) {
+        envelope.questions = questions.map((item, index) => {
+            if (!isPlainObject(item)) {
+                throw new LaneSchemaError(`questions[${index}] must be an object`);
+            }
+            const options = item.options;
+            if (!Array.isArray(options) ||
+                options.some((opt) => typeof opt !== "string")) {
+                throw new LaneSchemaError(`questions[${index}].options must be string[]`);
+            }
+            const parsed = {
+                question: requireString(item.question, `questions[${index}].question`),
+                context: requireString(item.context, `questions[${index}].context`),
+                options,
+            };
+            if (item.recommended !== undefined) {
+                parsed.recommended = requireString(item.recommended, `questions[${index}].recommended`);
+            }
+            return parsed;
+        });
+    }
+    if (typeof raw.blocked_reason === "string") {
+        envelope.blocked_reason = raw.blocked_reason;
+    }
+    return envelope;
+}
+//# sourceMappingURL=types.js.map

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/config.d.ts

@@ -3,6 +3,33 @@ export interface DaemonConfig {
 }
 export declare function daemonConfigPath(daemonDirectory: string): string;
 export declare function verifyHqRoot(candidate: string | undefined): string | null;
+/**
+ * A directory the daemon may be installed for: it must carry
+ * companies/manifest.yaml (what verifyHqRoot demands at runtime) and one of
+ * the tree markers utils/hq-roots.ts accepts (core/, .claude/, personal/).
+ * A bare .claude/ directory — every repo with Claude settings has one — is
+ * not an HQ root and must never be persisted or passed as --hq-root.
+ */
+export declare function isInstallableHqRoot(dir: string): boolean;
+/** Nearest ancestor of startDir (inclusive) that is an installable HQ root, realpath'd; null if none. */
+export declare function findAncestorHqRoot(startDir: string): string | null;
+export interface InstallHqRootResolution {
+    root: string;
+    source: "flag" | "env" | "ancestor";
+}
+/**
+ * Resolve the HQ root `hq mesh daemon install` records and passes to the
+ * service. Precedence: --hq-root, then HQ_ROOT, then the nearest ancestor of
+ * cwd that is an installable HQ root. An explicit value that is not an HQ
+ * root is an error rather than a silent fallback, and with nothing
+ * qualifying the install is refused: an unverified root would be persisted
+ * and trusted by the daemon for company attribution.
+ */
+export declare function resolveInstallHqRoot(opts?: {
+    explicit?: string;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): InstallHqRootResolution;
 export declare function readDaemonConfig(daemonDirectory: string): DaemonConfig;
 /** Record a verified local HQ checkout without trusting a caller-supplied path at runtime. */
 export declare function registerTrustedHqRoot(daemonDirectory: string, candidate: string | undefined): DaemonConfig;

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

@@ -16,6 +16,81 @@ export function verifyHqRoot(candidate) {
         return null;
     }
 }
+/**
+ * A directory the daemon may be installed for: it must carry
+ * companies/manifest.yaml (what verifyHqRoot demands at runtime) and one of
+ * the tree markers utils/hq-roots.ts accepts (core/, .claude/, personal/).
+ * A bare .claude/ directory — every repo with Claude settings has one — is
+ * not an HQ root and must never be persisted or passed as --hq-root.
+ */
+export function isInstallableHqRoot(dir) {
+    if (verifyHqRoot(dir) === null)
+        return false;
+    return ["core", ".claude", "personal"].some((marker) => {
+        try {
+            return fs.statSync(path.join(dir, marker)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Nearest ancestor of startDir (inclusive) that is an installable HQ root, realpath'd; null if none. */
+export function findAncestorHqRoot(startDir) {
+    let dir;
+    try {
+        dir = fs.realpathSync(startDir);
+    }
+    catch {
+        dir = path.resolve(startDir);
+    }
+    for (;;) {
+        if (isInstallableHqRoot(dir))
+            return fs.realpathSync(dir);
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Resolve the HQ root `hq mesh daemon install` records and passes to the
+ * service. Precedence: --hq-root, then HQ_ROOT, then the nearest ancestor of
+ * cwd that is an installable HQ root. An explicit value that is not an HQ
+ * root is an error rather than a silent fallback, and with nothing
+ * qualifying the install is refused: an unverified root would be persisted
+ * and trusted by the daemon for company attribution.
+ */
+export function resolveInstallHqRoot(opts = {}) {
+    const env = opts.env ?? process.env;
+    const cwd = opts.cwd ?? process.cwd();
+    const explicit = opts.explicit?.trim();
+    if (explicit) {
+        if (!isInstallableHqRoot(explicit)) {
+            throw expectedError(`--hq-root ${explicit} is not an HQ root (needs companies/manifest.yaml plus core/, .claude/, or personal/).`);
+        }
+        return { root: fs.realpathSync(explicit), source: "flag" };
+    }
+    const fromEnv = env.HQ_ROOT?.trim();
+    if (fromEnv) {
+        if (!isInstallableHqRoot(fromEnv)) {
+            throw expectedError(`HQ_ROOT=${fromEnv} is not an HQ root (needs companies/manifest.yaml plus core/, .claude/, or personal/). ` +
+                `Fix HQ_ROOT or pass --hq-root <path>.`);
+        }
+        return { root: fs.realpathSync(fromEnv), source: "env" };
+    }
+    const ancestor = findAncestorHqRoot(cwd);
+    if (!ancestor) {
+        throw expectedError(`No HQ root found above ${cwd} (a directory with companies/manifest.yaml plus core/, .claude/, or personal/). ` +
+            `Run from inside your HQ tree or pass --hq-root <path>.`);
+    }
+    return { root: ancestor, source: "ancestor" };
+}
+function expectedError(message) {
+    const err = new Error(message);
+    err.expected = true;
+    return err;
+}
 export function readDaemonConfig(daemonDirectory) {
     try {
         const raw = JSON.parse(fs.readFileSync(daemonConfigPath(daemonDirectory), "utf8"));

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/index.d.ts

@@ -1,4 +1,4 @@
-export { DAEMON_DIRNAME, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_NAME, DAEMON_PID_NAME, DAEMON_STATE_NAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, daemonDir, daemonLogPath, daemonPidPath, daemonStatePath, sessionBoardPath, } from "./paths.js";
+export { DAEMON_DIRNAME, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_NAME, DAEMON_PID_NAME, DAEMON_STATE_NAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, WINDOWS_TASK_NAME, daemonDir, daemonLogPath, daemonPidPath, daemonStatePath, sessionBoardPath, } from "./paths.js";
 export { acquirePidLock, defaultPidLockDeps, parsePidLock, pidLockStatus, readPidLock, releasePidLock, resolveDaemonDir, } from "./pid-lock.js";
 export type { PidLockDeps, PidLockRecord, PidLockResult } from "./pid-lock.js";
 export { CREDENTIAL_RENEWAL_FRACTION, DEFAULT_REFUSED_RETRY_MS, MAX_RETRY_DELAY_MS, MAX_TIMER_DELAY_MS, MQTT_KEEPALIVE_SECONDS, REALTIME_CREDENTIALS_PATH, REFUSED_RETRY_ENV, CredentialRenewalManager, CredentialVendError, classifyCredentialVendFailure, clampRetryDelayMs, createContract3Fetcher, defaultRefusedRetryMs, extractVendErrorCode, isCredentialVendRefused, normalizeContract3Bundle, parseRetryAfterMs, realTimerHost, refusedRetryDelayMs, renewalDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
@@ -12,9 +12,10 @@ export type { DaemonStateFile, PresenceRefusalState } from "./state.js";
 export { appendDaemonLog, daemonLogLine, ensureDaemonLog, resolveDaemonAssetDir, rotateDaemonLogIfNeeded, } from "./log.js";
 export { BOARD_REFRESH_INTERVAL_MS, createVaultBoardReader, formatBoardMarkdown, refreshBoundSessionBoards, writeBoardMarkdown, } from "./board-refresh.js";
 export type { BoardReader, BoardRefreshDeps, BoardStorySnapshot } from "./board-refresh.js";
-export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonService, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveHqBinary, resolveNodeBinary, uninstallDaemonService, } from "./install.js";
+export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonService, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveHqBinary, resolveNodeBinary, parseSchtasksLastResult, parseWindowsTaskHqRoot, readRecordedWindowsHqRoot, schtasksLastResultFailed, uninstallDaemonService, windowsLaunchMode, windowsLogonNotice, } from "./install.js";
 export type { DaemonInstallPlatform, InstallPaths, InstallResult, } from "./install.js";
-export { daemonConfigPath, readDaemonConfig, registerTrustedHqRoot, verifyHqRoot } from "./config.js";
+export { daemonConfigPath, findAncestorHqRoot, isInstallableHqRoot, readDaemonConfig, registerTrustedHqRoot, resolveInstallHqRoot, verifyHqRoot, } from "./config.js";
+export type { InstallHqRootResolution } from "./config.js";
 export type { DaemonConfig } from "./config.js";
 export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatDaemonDoctor, } from "./doctor.js";
 export type { DaemonDoctorDeps, DaemonDoctorReport } from "./doctor.js";

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

@@ -1,4 +1,4 @@
-export { DAEMON_DIRNAME, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_NAME, DAEMON_PID_NAME, DAEMON_STATE_NAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, daemonDir, daemonLogPath, daemonPidPath, daemonStatePath, sessionBoardPath, } from "./paths.js";
+export { DAEMON_DIRNAME, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_NAME, DAEMON_PID_NAME, DAEMON_STATE_NAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, WINDOWS_TASK_NAME, daemonDir, daemonLogPath, daemonPidPath, daemonStatePath, sessionBoardPath, } from "./paths.js";
 export { acquirePidLock, defaultPidLockDeps, parsePidLock, pidLockStatus, readPidLock, releasePidLock, resolveDaemonDir, } from "./pid-lock.js";
 export { CREDENTIAL_RENEWAL_FRACTION, DEFAULT_REFUSED_RETRY_MS, MAX_RETRY_DELAY_MS, MAX_TIMER_DELAY_MS, MQTT_KEEPALIVE_SECONDS, REALTIME_CREDENTIALS_PATH, REFUSED_RETRY_ENV, CredentialRenewalManager, CredentialVendError, classifyCredentialVendFailure, clampRetryDelayMs, createContract3Fetcher, defaultRefusedRetryMs, extractVendErrorCode, isCredentialVendRefused, normalizeContract3Bundle, parseRetryAfterMs, realTimerHost, refusedRetryDelayMs, renewalDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
 export { amzDateOf, hex, presignIotWssUrl, rfc3986Encode } from "./presign.js";
@@ -6,8 +6,8 @@ export { CLOSE_LOG_ALWAYS_COUNT, CLOSE_LOG_INTERVAL_MS, CONNECT_STABLE_GRACE_MS,
 export { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
 export { appendDaemonLog, daemonLogLine, ensureDaemonLog, resolveDaemonAssetDir, rotateDaemonLogIfNeeded, } from "./log.js";
 export { BOARD_REFRESH_INTERVAL_MS, createVaultBoardReader, formatBoardMarkdown, refreshBoundSessionBoards, writeBoardMarkdown, } from "./board-refresh.js";
-export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonService, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveHqBinary, resolveNodeBinary, uninstallDaemonService, } from "./install.js";
-export { daemonConfigPath, readDaemonConfig, registerTrustedHqRoot, verifyHqRoot } from "./config.js";
+export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonService, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveHqBinary, resolveNodeBinary, parseSchtasksLastResult, parseWindowsTaskHqRoot, readRecordedWindowsHqRoot, schtasksLastResultFailed, uninstallDaemonService, windowsLaunchMode, windowsLogonNotice, } from "./install.js";
+export { daemonConfigPath, findAncestorHqRoot, isInstallableHqRoot, readDaemonConfig, registerTrustedHqRoot, resolveInstallHqRoot, verifyHqRoot, } from "./config.js";
 export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatDaemonDoctor, } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, DAEMON_VERSION_DRIFT_EXIT_CODE, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";