@indigoai-us/hq-cli 5.345.53 → 5.345.55

package/dist/lib/import-scan/scan-event.schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://hq.computer/schemas/import-scan/scan-event.v1.schema.json",
+  "title": "HQ import scan event (v1)",
+  "description": "One line of `hq import scan --json --stream` / `scan.sh --progress-json`. Each type is also addressable as #/$defs/<type>. Unknown extra fields are allowed within v1; hq-cli forwards only the fields listed here.",
+  "type": "object",
+  "required": ["v", "type"],
+  "properties": {
+    "v": { "const": 1 },
+    "type": { "enum": ["start", "source", "count", "company", "project", "error", "done"] }
+  },
+  "oneOf": [
+    { "$ref": "#/$defs/start" },
+    { "$ref": "#/$defs/source" },
+    { "$ref": "#/$defs/nonNegative" },
+    { "$ref": "#/$defs/company" },
+    { "$ref": "#/$defs/project" },
+    { "$ref": "#/$defs/error" },
+    { "$ref": "#/$defs/done" }
+  ],
+  "$defs": {
+    "name": { "type": "string", "minLength": 1, "maxLength": 512 },
+    "nonNegative": { "type": "integer", "minimum": 0 },
+    "baseName": {
+      "description": "A folder or repository basename: a name without \"/\".",
+      "allOf": [{ "$ref": "#/$defs/name" }, { "pattern": "^[^/]+$" }]
+    },
+    "start": {
+      "type": "object",
+      "required": ["v", "type", "sources"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "start" },
+        "sources": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["id", "label"],
+            "properties": {
+              "id": { "$ref": "#/$defs/name" },
+              "label": { "$ref": "#/$defs/name" }
+            }
+          }
+        }
+      }
+    },
+    "source": {
+      "type": "object",
+      "required": ["v", "type", "id", "status"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "source" },
+        "id": { "$ref": "#/$defs/name" },
+        "status": { "enum": ["scanning", "done", "skipped", "error"] },
+        "counts": {
+          "type": "object",
+          "propertyNames": { "pattern": "^[a-z0-9_-]{1,64}$" },
+          "additionalProperties": { "$ref": "#/$defs/nonNegative" }
+        },
+        "message": { "type": "string", "maxLength": 2000 }
+      }
+    },
+    "count": {
+      "type": "object",
+      "required": ["v", "type", "source", "key", "value"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "count" },
+        "source": { "$ref": "#/$defs/name" },
+        "key": { "type": "string", "pattern": "^[a-z0-9_-]{1,64}$" },
+        "value": { "$ref": "#/$defs/nonNegative" }
+      }
+    },
+    "company": {
+      "type": "object",
+      "required": ["v", "type", "id", "name", "basis"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "company" },
+        "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "maxLength": 128 },
+        "name": { "$ref": "#/$defs/name" },
+        "basis": { "enum": ["hq-company", "repo-org", "folder"] }
+      }
+    },
+    "project": {
+      "type": "object",
+      "required": ["v", "type", "id", "name", "company", "basis"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "project" },
+        "id": { "type": "string", "pattern": "^p_[0-9a-f]{12}$" },
+        "name": { "$ref": "#/$defs/baseName" },
+        "company": { "type": ["string", "null"] },
+        "basis": { "enum": ["repo", "claude-code-cwd", "codex-cwd"] }
+      }
+    },
+    "error": {
+      "type": "object",
+      "required": ["v", "type", "source", "message"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "error" },
+        "source": { "$ref": "#/$defs/name" },
+        "message": { "type": "string", "minLength": 1, "maxLength": 2000 },
+        "code": { "enum": ["scanner_outdated", "scan_failed"] }
+      }
+    },
+    "done": {
+      "type": "object",
+      "required": ["v", "type", "report", "summary"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "done" },
+        "report": { "type": ["string", "null"] },
+        "summary": {
+          "type": "object",
+          "required": ["companies", "projects", "sessions"],
+          "properties": {
+            "companies": { "$ref": "#/$defs/nonNegative" },
+            "projects": { "$ref": "#/$defs/nonNegative" },
+            "sessions": { "$ref": "#/$defs/nonNegative" }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/lib/import-scan/validate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Validates one line of the import-scan event stream against
+ * `scan-event.schema.json` (Ajv, draft 2020-12) and rebuilds the event from
+ * the v1 fields only.
+ *
+ * Validation dispatches on `type`: the common envelope is checked first, then
+ * the line is validated against `#/$defs/<type>` alone, so a drop reason names
+ * the real problem instead of the first failing `oneOf` branch.
+ *
+ * Failure reasons name the type, the schema path and Ajv's generic message
+ * only. They never echo values from the line, so a malformed event that
+ * happens to carry content cannot leak through the warning hq-cli prints.
+ */
+import { type ScanEvent } from "./events.js";
+export declare const SCAN_EVENT_SCHEMA_PATH: string;
+export type ParsedScanLine = {
+    ok: true;
+    event: ScanEvent;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Parse and validate one JSON Lines record. */
+export declare function parseScanEventLine(line: string): ParsedScanLine;
+export declare function validateScanEvent(value: unknown): ParsedScanLine;
+/**
+ * Rebuild an already-validated event from the v1 fields only, so fields a
+ * scanner adds (or smuggles) never reach stdout.
+ */
+export declare function pickScanEvent(event: ScanEvent): ScanEvent;
+//# sourceMappingURL=validate.d.ts.map

package/dist/lib/import-scan/validate.js

@@ -0,0 +1,111 @@
+/**
+ * Validates one line of the import-scan event stream against
+ * `scan-event.schema.json` (Ajv, draft 2020-12) and rebuilds the event from
+ * the v1 fields only.
+ *
+ * Validation dispatches on `type`: the common envelope is checked first, then
+ * the line is validated against `#/$defs/<type>` alone, so a drop reason names
+ * the real problem instead of the first failing `oneOf` branch.
+ *
+ * Failure reasons name the type, the schema path and Ajv's generic message
+ * only. They never echo values from the line, so a malformed event that
+ * happens to carry content cannot leak through the warning hq-cli prints.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
+import { SCAN_EVENT_TYPES, SCAN_EVENT_VERSION } from "./events.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const SCAN_EVENT_SCHEMA_PATH = join(HERE, "scan-event.schema.json");
+let validators;
+function getValidators() {
+    if (validators)
+        return validators;
+    const schema = JSON.parse(readFileSync(SCAN_EVENT_SCHEMA_PATH, "utf8"));
+    const ajv = new Ajv2020({ allErrors: false, strict: false, validateFormats: false });
+    ajv.addSchema(schema);
+    const map = new Map();
+    for (const type of SCAN_EVENT_TYPES) {
+        const fn = ajv.getSchema(`${schema.$id}#/$defs/${type}`);
+        if (!fn)
+            throw new Error(`scan-event schema has no $defs/${type}`);
+        map.set(type, fn);
+    }
+    validators = map;
+    return map;
+}
+/** Parse and validate one JSON Lines record. */
+export function parseScanEventLine(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return { ok: false, reason: "not valid JSON" };
+    }
+    return validateScanEvent(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateScanEvent(value) {
+    if (!isRecord(value))
+        return { ok: false, reason: "not a JSON object" };
+    if (value.v !== SCAN_EVENT_VERSION)
+        return { ok: false, reason: "missing or unsupported version (v)" };
+    const type = value.type;
+    if (typeof type !== "string" || !SCAN_EVENT_TYPES.includes(type)) {
+        return { ok: false, reason: "missing or unknown event type" };
+    }
+    const validate = getValidators().get(type);
+    if (!validate(value)) {
+        const first = validate.errors?.[0];
+        const where = first ? `${first.instancePath || "/"} ${first.message ?? first.keyword}` : "schema";
+        return { ok: false, reason: `event "${type}" does not match the v1 schema (${where})` };
+    }
+    return { ok: true, event: pickScanEvent(value) };
+}
+/**
+ * Rebuild an already-validated event from the v1 fields only, so fields a
+ * scanner adds (or smuggles) never reach stdout.
+ */
+export function pickScanEvent(event) {
+    const v = SCAN_EVENT_VERSION;
+    switch (event.type) {
+        case "start":
+            return { v, type: "start", sources: event.sources.map((s) => ({ id: s.id, label: s.label })) };
+        case "source": {
+            const out = { v, type: "source", id: event.id, status: event.status };
+            if (event.counts)
+                out.counts = Object.fromEntries(Object.entries(event.counts));
+            if (event.message !== undefined)
+                out.message = event.message;
+            return out;
+        }
+        case "count":
+            return { v, type: "count", source: event.source, key: event.key, value: event.value };
+        case "company":
+            return { v, type: "company", id: event.id, name: event.name, basis: event.basis };
+        case "project":
+            return { v, type: "project", id: event.id, name: event.name, company: event.company, basis: event.basis };
+        case "error": {
+            const out = { v, type: "error", source: event.source, message: event.message };
+            if (event.code !== undefined)
+                out.code = event.code;
+            return out;
+        }
+        case "done":
+            return {
+                v,
+                type: "done",
+                report: event.report,
+                summary: {
+                    companies: event.summary.companies,
+                    projects: event.summary.projects,
+                    sessions: event.summary.sessions,
+                },
+            };
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/lib/lanes/flag-keys.d.ts

@@ -30,4 +30,6 @@ export declare const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot
 export declare const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
 /** Allows a Claude lane to leave an exhausted profile account pin for an eligible account. */
 export declare const LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG = "lanes.profile-pin-exhausted-fallback";
+/** Enables conduct-mode SessionStart bootstrapping (defaults on; operator kill switch). */
+export declare const LANE_CONDUCT_SESSION_START_FLAG = "lanes.conduct-session-start";
 //# sourceMappingURL=flag-keys.d.ts.map

package/dist/lib/lanes/flag-keys.js

@@ -30,4 +30,6 @@ export const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot-outpost
 export const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
 /** Allows a Claude lane to leave an exhausted profile account pin for an eligible account. */
 export const LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG = "lanes.profile-pin-exhausted-fallback";
+/** Enables conduct-mode SessionStart bootstrapping (defaults on; operator kill switch). */
+export const LANE_CONDUCT_SESSION_START_FLAG = "lanes.conduct-session-start";
 //# sourceMappingURL=flag-keys.js.map

package/dist/lib/lanes/monitor.js

@@ -422,7 +422,7 @@ export function monitorReminderText() {
         "For active Claude senior lanes, arm one live Claude Code Monitor task per uncovered lane:",
         'Monitor(command="hq lanes watch <lane-id>...", timeout_ms=1800000, persistent=true)',
         "Use `hq lanes monitor-check --session <id>` to verify coverage. `persistent=true` is requested where the installed Monitor tool honors it; Claude Code caps Monitor tasks at 30 minutes, so re-arm after expiry.",
-        "The caller must pass `--engine codex` or `--engine grok` (or set HQ_CONDUCT_ENGINE) for sessions whose engine has no Claude Monitor tool; those engines are never required to provide one.",
+        "The caller must pass `--engine codex` or `--engine grok` (or set HQ_LANE_ENGINE; deprecated alias HQ_CONDUCT_ENGINE) for sessions whose engine has no Claude Monitor tool; those engines are never required to provide one.",
     ].join("\n");
 }
 //# sourceMappingURL=monitor.js.map

package/dist/lib/lanes/registry-flag.d.ts

@@ -11,6 +11,8 @@ export interface LanesFlagClient {
 }
 export type LanesFlagClientFactory = (options: FlagClientOptions) => LanesFlagClient;
 export interface ReadLanesFlagOptions {
+    /** Fallback for a missing registry row; kill switches should normally use true. */
+    defaultValue?: boolean;
     company?: LaneCompanyRef | null;
     companyUidSource?: string;
     env?: NodeJS.ProcessEnv;

package/dist/lib/lanes/registry-flag.js

@@ -155,7 +155,7 @@ async function readRegistryValue(flagKey, endpoint, options) {
             rememberFailure(error);
         }
         try {
-            resolution = client.explain(flagKey, { fallback: false });
+            resolution = client.explain(flagKey, { fallback: options.defaultValue ?? false });
         }
         catch (error) {
             rememberFailure(error);

package/dist/utils/manifest.d.ts

@@ -1,5 +1,11 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import type { ModulesManifest, ModuleDefinition, ModuleLock, SyncState } from '../types.js';
-export declare function findHqRoot(): string;
+export declare function findHqRoot(options?: {
+    cwd?: string;
+    pathApi?: Pick<typeof path, 'dirname' | 'join'>;
+    existsSync?: typeof fs.existsSync;
+}): string;
 /**
  * Resolve the manifest path for a given HQ root.
  *

package/dist/utils/manifest.js

@@ -5,15 +5,23 @@ import { parseUserYaml } from './user-yaml-error.js';
 const MANIFEST_FILE = 'modules.yaml';
 const LOCK_FILE = 'modules.lock';
 const STATE_FILE = '.hq-sync-state.json';
-export function findHqRoot() {
-    let dir = process.cwd();
-    while (dir !== '/') {
-        if (fs.existsSync(path.join(dir, '.claude')) || fs.existsSync(path.join(dir, 'workers'))) {
+export function findHqRoot(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const pathApi = options.pathApi ?? path;
+    const existsSync = options.existsSync ?? fs.existsSync;
+    let dir = cwd;
+    while (true) {
+        const parent = pathApi.dirname(dir);
+        // Check the fixed point before looking for markers so POSIX keeps its
+        // existing behavior of never checking `/` itself.
+        if (parent === dir)
+            break;
+        if (existsSync(pathApi.join(dir, '.claude')) || existsSync(pathApi.join(dir, 'workers'))) {
             return dir;
         }
-        dir = path.dirname(dir);
+        dir = parent;
     }
-    return process.cwd();
+    return cwd;
 }
 /**
  * Resolve the manifest path for a given HQ root.

package/package.json

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