@indigoai-us/hq-cli 5.328.0 → 5.330.0

package/dist/lib/lanes/types.d.ts

@@ -312,6 +312,10 @@ export interface LaneStopHistoryEntry {
 export interface LaneSettingsHistoryEntry {
     at: string;
     actor: string;
+    provider?: {
+        from: LaneProvider;
+        to: LaneProvider;
+    };
     model?: {
         from: string | null;
         to: string;
@@ -578,7 +582,13 @@ export interface LaneRecord {
     /** How policy files were delivered on the most recent profile spawn. */
     worker_policy_delivery?: "hook" | "prompt";
     provider: LaneProvider;
+    /** Whether provider came from an explicit create override or the worker profile/default. */
+    provider_source?: "cli" | "profile" | "default";
     account?: string;
+    /** Explicit create account choices remain pinned during profile refreshes. */
+    account_source?: "cli" | "profile" | "balanced";
+    /** Reuse snapshots the worker profile's resolved settings for the new story. */
+    profile_settings_pinned?: boolean;
     /** Recent Claude account-selection evidence for a create or automatic resume move. */
     account_selection?: LaneAccountSelection;
     /** Eligible accounts for a queue entry created without an explicit account. */

package/dist/lib/lanes/types.js

@@ -231,7 +231,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
-    provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
+    provider: ["creator", "command"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
     last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],

package/dist/lib/sync-invalid-entity-warning.d.ts

@@ -0,0 +1,32 @@
+import type { FlagClient, FlagClientOptions } from "@indigoai-us/hq-flags-client";
+export declare const SYNC_INVALID_ENTITY_WARNING_FLAG = "sync.warn-invalid-ontology-entities";
+export declare const SYNC_INVALID_ENTITY_WARNING_FALLBACK = false;
+export declare const SYNC_INVALID_ENTITY_WARNING_TIMEOUT_MS = 1500;
+type FlagClientLike = Pick<FlagClient, "ready" | "isEnabled" | "close">;
+export interface InvalidEntityFrontmatter {
+    path: string;
+    fields: string[];
+}
+export interface SyncInvalidEntityWarningDependencies {
+    env?: NodeJS.ProcessEnv;
+    createClient?: (options: FlagClientOptions) => FlagClientLike;
+    idToken?: string;
+    writeLine?: (line: string) => void;
+}
+/** Check only the entity directory that this sync push will upload. */
+export declare function findInvalidOntologyEntities(args: {
+    companyRoot: string;
+    hqRoot: string;
+}): InvalidEntityFrontmatter[];
+export declare function companySlugFromSyncPaths(hqRoot: string, syncPaths: string[]): string | undefined;
+/** Warns by path and field names only. Any diagnostic failure leaves sync running. */
+export declare function warnAboutInvalidOntologyEntities(args: {
+    hqRoot: string;
+    companyRoot: string;
+    companyUid: string;
+    companySlug: string;
+    idToken?: string;
+    dependencies?: Omit<SyncInvalidEntityWarningDependencies, "idToken">;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=sync-invalid-entity-warning.d.ts.map

package/dist/lib/sync-invalid-entity-warning.js

@@ -0,0 +1,205 @@
+import { createFlagClient, readLocalOverride } from "@indigoai-us/hq-flags-client";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+import { resolveFlagRegistryEndpoint } from "./flag-registry-endpoint.js";
+export const SYNC_INVALID_ENTITY_WARNING_FLAG = "sync.warn-invalid-ontology-entities";
+export const SYNC_INVALID_ENTITY_WARNING_FALLBACK = false;
+export const SYNC_INVALID_ENTITY_WARNING_TIMEOUT_MS = 1500;
+const ENTITY_TYPES = new Set([
+    "person", "project", "company", "concept", "product", "tool",
+    "tool/technology", "model", "platform", "contact", "deal", "contract",
+    "invoice", "account", "journal-entry", "ar-invoice", "ap-bill",
+]);
+const REQUIRED_FIELDS = [
+    "id", "type", "canonical_name", "confidence", "status",
+    "domain", "first_seen", "last_updated", "signal_count",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validRequiredFields(frontmatter) {
+    const invalid = new Set();
+    for (const field of REQUIRED_FIELDS) {
+        if (!(field in frontmatter))
+            invalid.add(field);
+    }
+    if (typeof frontmatter.id !== "string" || frontmatter.id.length === 0) {
+        invalid.add("id");
+    }
+    if (typeof frontmatter.type !== "string" || !ENTITY_TYPES.has(frontmatter.type)) {
+        invalid.add("type");
+    }
+    if (typeof frontmatter.canonical_name !== "string" ||
+        frontmatter.canonical_name.length === 0) {
+        invalid.add("canonical_name");
+    }
+    if ("aliases" in frontmatter &&
+        (!Array.isArray(frontmatter.aliases) ||
+            !frontmatter.aliases.every((value) => typeof value === "string"))) {
+        invalid.add("aliases");
+    }
+    if (typeof frontmatter.confidence !== "number" ||
+        !Number.isFinite(frontmatter.confidence) ||
+        frontmatter.confidence < 0 ||
+        frontmatter.confidence > 1) {
+        invalid.add("confidence");
+    }
+    if (frontmatter.status !== "draft" && frontmatter.status !== "confirmed") {
+        invalid.add("status");
+    }
+    if (!Array.isArray(frontmatter.domain) ||
+        !frontmatter.domain.every((value) => typeof value === "string")) {
+        invalid.add("domain");
+    }
+    if (typeof frontmatter.first_seen !== "string" || frontmatter.first_seen.length === 0) {
+        invalid.add("first_seen");
+    }
+    if (typeof frontmatter.last_updated !== "string" ||
+        frontmatter.last_updated.length === 0) {
+        invalid.add("last_updated");
+    }
+    if (typeof frontmatter.signal_count !== "number" ||
+        !Number.isInteger(frontmatter.signal_count) ||
+        frontmatter.signal_count < 0) {
+        invalid.add("signal_count");
+    }
+    if (invalid.size === 0 &&
+        frontmatter.identity_version !== 2 &&
+        frontmatter.id !== createHash("sha256")
+            .update(`${frontmatter.type}:${frontmatter.canonical_name}`)
+            .digest("hex")) {
+        invalid.add("id");
+    }
+    return [...invalid].sort();
+}
+function parseInvalidEntityFile(filePath, displayPath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf8");
+        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+        if (!match)
+            return { path: displayPath, fields: ["_frontmatter"] };
+        // Match the ontology reader's YAML parser semantics: ISO date scalars stay
+        // strings so Zod's `z.string()` fields are checked as the server checks them.
+        const parsed = yaml.load(match[1], { schema: yaml.CORE_SCHEMA });
+        if (!isRecord(parsed))
+            return { path: displayPath, fields: ["_root"] };
+        const fields = validRequiredFields(parsed);
+        return fields.length ? { path: displayPath, fields } : null;
+    }
+    catch {
+        // YAML parser errors can embed user content; report the location only.
+        return { path: displayPath, fields: ["_frontmatter"] };
+    }
+}
+/** Check only the entity directory that this sync push will upload. */
+export function findInvalidOntologyEntities(args) {
+    const entityRoot = path.join(args.companyRoot, "ontology", "entities");
+    if (!fs.existsSync(entityRoot))
+        return [];
+    const found = [];
+    const typeEntries = fs.readdirSync(entityRoot, { withFileTypes: true });
+    for (const typeEntry of typeEntries) {
+        if (!typeEntry.isDirectory())
+            continue;
+        const typeRoot = path.join(entityRoot, typeEntry.name);
+        for (const entityEntry of fs.readdirSync(typeRoot, { withFileTypes: true })) {
+            if (!entityEntry.isFile() || !entityEntry.name.endsWith(".md"))
+                continue;
+            const filePath = path.join(typeRoot, entityEntry.name);
+            const relativePath = path.relative(args.hqRoot, filePath).split(path.sep).join("/");
+            const invalid = parseInvalidEntityFile(filePath, relativePath);
+            if (invalid)
+                found.push(invalid);
+        }
+    }
+    return found.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function companySlugFromSyncPaths(hqRoot, syncPaths) {
+    const companiesRoot = path.resolve(hqRoot, "companies");
+    for (const syncPath of syncPaths) {
+        const relative = path.relative(companiesRoot, path.resolve(syncPath));
+        if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            continue;
+        const slug = relative.split(path.sep)[0];
+        if (slug && slug !== ".")
+            return slug;
+    }
+    return undefined;
+}
+function safeErrorClass(error) {
+    const name = error instanceof Error ? error.name : "UnknownError";
+    return /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(name) ? name : "UnknownError";
+}
+async function warningEnabled(args) {
+    const env = args.dependencies.env ?? process.env;
+    const override = readLocalOverride(SYNC_INVALID_ENTITY_WARNING_FLAG, env);
+    if (override !== null)
+        return override;
+    const companyUid = args.companyUid || env.HQ_COMPANY_UID?.trim() || "";
+    const companySlug = args.companySlug || env.HQ_COMPANY_SLUG?.trim() || "";
+    if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+        return SYNC_INVALID_ENTITY_WARNING_FALLBACK;
+    }
+    const token = args.dependencies.idToken ?? "";
+    if (!token)
+        return SYNC_INVALID_ENTITY_WARNING_FALLBACK;
+    let client;
+    let failed = false;
+    try {
+        client = (args.dependencies.createClient ?? createFlagClient)({
+            endpoint: resolveFlagRegistryEndpoint(undefined, env),
+            companyUid,
+            ...(/^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/.test(companySlug)
+                ? { companyIdentifiers: [companySlug] }
+                : {}),
+            env: {},
+            getToken: () => token,
+            refreshIntervalMs: 0,
+            requestTimeoutMs: SYNC_INVALID_ENTITY_WARNING_TIMEOUT_MS,
+            onError: (error) => {
+                failed = true;
+                (args.dependencies.writeLine ?? ((line) => process.stderr.write(line)))(`HQ Sync entity-warning flag lookup failed (${safeErrorClass(error)}); defaulting off.\n`);
+            },
+        });
+        await client.ready();
+        return !failed && client.isEnabled(SYNC_INVALID_ENTITY_WARNING_FLAG, {
+            fallback: SYNC_INVALID_ENTITY_WARNING_FALLBACK,
+        });
+    }
+    catch (error) {
+        (args.dependencies.writeLine ?? ((line) => process.stderr.write(line)))(`HQ Sync entity-warning flag lookup failed (${safeErrorClass(error)}); defaulting off.\n`);
+        return SYNC_INVALID_ENTITY_WARNING_FALLBACK;
+    }
+    finally {
+        client?.close();
+    }
+}
+/** Warns by path and field names only. Any diagnostic failure leaves sync running. */
+export async function warnAboutInvalidOntologyEntities(args) {
+    try {
+        const enabled = await warningEnabled({
+            companyUid: args.companyUid,
+            companySlug: args.companySlug,
+            dependencies: { ...args.dependencies, idToken: args.idToken },
+        });
+        if (!enabled)
+            return;
+        const invalid = findInvalidOntologyEntities(args);
+        const writeLine = args.dependencies?.writeLine ?? ((line) => process.stderr.write(line));
+        for (const item of invalid) {
+            writeLine(`HQ Sync warning: ${item.path} has frontmatter rejected by ontology matching: ${item.fields.join(", ")}. Sync will continue and leave the file unchanged. Fix the entity if you want it included in ontology results.\n`);
+        }
+    }
+    catch (error) {
+        const writeLine = args.dependencies?.writeLine ?? ((line) => process.stderr.write(line));
+        try {
+            writeLine(`HQ Sync entity diagnostic failed (${safeErrorClass(error)}); sync will continue.\n`);
+        }
+        catch {
+            // A closed stderr must not prevent the upload from preserving user data.
+        }
+    }
+}
+//# sourceMappingURL=sync-invalid-entity-warning.js.map

package/dist/main.d.ts

@@ -5,6 +5,8 @@
 import "./node-preflight.js";
 import "./node-network-compat.js";
 import { Sentry } from "./sentry.js";
+export { handleStreamError } from "./stream-error-boundary.js";
+export type { StreamErrorDependencies } from "./stream-error-boundary.js";
 import { upgradeToTeam } from "./utils/team-upgrade.js";
 /**
  * Total time one CLI invocation may await foreground network work. This spans
@@ -31,11 +33,6 @@ export declare function createForegroundNetworkBudget(options?: {
     budgetMs?: number;
     now?: () => number;
 }): ForegroundNetworkBudget;
-export type StreamErrorDependencies = {
-    stderr: Pick<typeof process.stderr, "write">;
-    exit: (code: number) => void;
-};
-export declare function handleStreamError(err: NodeJS.ErrnoException, deps?: StreamErrorDependencies): void;
 export declare function runCli(): Promise<void>;
 export type TopLevelErrorDependencies = {
     sentry: Pick<typeof Sentry, "captureException">;
@@ -49,5 +46,4 @@ export type TopLevelErrorDependencies = {
 };
 /** Classify a top-level failure without making the CLI process boundary opaque to tests. */
 export declare function handleTopLevelError(err: unknown, deps?: TopLevelErrorDependencies): Promise<void>;
-export {};
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -31,6 +31,8 @@ import { incompleteInstallMessage, incompleteInstallCaptureContext, } from "./ut
 import { isExpectedUserError } from "./utils/expected-cli-error.js";
 import { isVarlockEnvError } from "./run/env-graph-guard.js";
 import { isEpipe } from "./utils/epipe.js";
+import { installStreamErrorBoundary } from "./stream-error-boundary.js";
+export { handleStreamError } from "./stream-error-boundary.js";
 import { isInterceptedProcessExit } from "./utils/intercepted-process-exit.js";
 import { isAuthError } from "./utils/auth-error.js";
 import { browserLoginAbandonedMessage } from "./utils/browser-login-abandoned.js";
@@ -123,47 +125,7 @@ let activeForegroundNetworkBudget;
  * the rewrite window, while this path now holds the settled tree.
  */
 const RUNNING_ENTRY_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
-const defaultStreamErrorDependencies = {
-    stderr: process.stderr,
-    exit: (code) => process.exit(code),
-};
-// Handle an 'error' event on process.stdout/stderr without turning a benign
-// machine-state condition into a Sentry fatal.
-//   - EPIPE: a downstream reader closed the pipe early (`hq … | head`,
-//     `source <(hq …)`, a parent that exited) — a clean exit 0, no capture. The
-//     SYNCHRONOUS path (a `write EPIPE` thrown straight out of console.log) is
-//     handled in the top-level catch below; both share `isEpipe` (HQ-6B).
-//   - ENOSPC / EDQUOT / EROFS: a full disk, exhausted quota, or read-only mount
-//     (e.g. stdout redirected to a file that fills up) — the user's machine,
-//     not an hq-cli defect. Print one actionable line (best-effort; the same
-//     disk may reject it) and exit 1 WITHOUT rethrowing, so it never becomes an
-//     uncaughtException that ships a fatal (HQ-CLI-R). sentry.ts's
-//     path-independent beforeSend also drops it, covering the buffered-write
-//     route that never surfaces here.
-//   - Anything else: rethrow — an unknown stream failure must stay loud.
-// Exported in dependency-injectable form (mirroring handleTopLevelError) so the
-// process boundary stays unit-testable through the ./main.js import seam.
-export function handleStreamError(err, deps = defaultStreamErrorDependencies) {
-    if (isEpipe(err)) {
-        deps.exit(0);
-        return;
-    }
-    const envMessage = environmentalFsErrorMessage(err);
-    if (envMessage) {
-        try {
-            deps.stderr.write(`hq: ${envMessage}\n`);
-        }
-        catch {
-            // The same full disk / read-only mount can reject this write too; there
-            // is nothing more to surface, but we still exit non-zero below.
-        }
-        deps.exit(1);
-        return;
-    }
-    throw err;
-}
-process.stdout.on("error", (err) => handleStreamError(err));
-process.stderr.on("error", (err) => handleStreamError(err));
+installStreamErrorBoundary();
 runGlobalNetworkLifecycle(process.argv, () => initSentry());
 const program = new Command();
 program

package/dist/stream-error-boundary.d.ts

@@ -0,0 +1,7 @@
+export type StreamErrorDependencies = {
+    stderr: Pick<typeof process.stderr, "write">;
+    exit: (code: number) => void;
+};
+export declare function handleStreamError(err: NodeJS.ErrnoException, deps?: StreamErrorDependencies): void;
+export declare function installStreamErrorBoundary(): void;
+//# sourceMappingURL=stream-error-boundary.d.ts.map

package/dist/stream-error-boundary.js

@@ -0,0 +1,33 @@
+import { environmentalFsErrorMessage } from "./utils/environmental-error.js";
+import { isEpipe } from "./utils/epipe.js";
+const defaults = {
+    stderr: process.stderr,
+    exit: (code) => process.exit(code),
+};
+export function handleStreamError(err, deps = defaults) {
+    if (isEpipe(err)) {
+        deps.exit(0);
+        return;
+    }
+    const message = environmentalFsErrorMessage(err);
+    if (message) {
+        try {
+            deps.stderr.write(`hq: ${message}\n`);
+        }
+        catch {
+            // The same full disk or read-only mount can reject the diagnostic write.
+        }
+        deps.exit(1);
+        return;
+    }
+    throw err;
+}
+let installed = false;
+export function installStreamErrorBoundary() {
+    if (installed)
+        return;
+    installed = true;
+    process.stdout.on("error", (err) => handleStreamError(err));
+    process.stderr.on("error", (err) => handleStreamError(err));
+}
+//# sourceMappingURL=stream-error-boundary.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.328.0",
+  "version": "5.330.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {