@indigoai-us/hq-cli 5.345.27 → 5.345.29

package/dist/commands/core-resolve-company-command.js

@@ -20,6 +20,7 @@ export function registerCoreResolveCompanyNativeCommand(core) {
                 args: operands,
                 cwd: root,
                 hqRoot: root,
+                env: { HQ_CALLER_CWD: process.cwd() },
             });
             if (code !== 0)
                 process.exit(code);

package/dist/commands/core-resolve-company-native.d.ts

@@ -10,7 +10,7 @@ type HqResult = {
     code: number;
     stdout: string;
 };
-type ResolveCompanyFs = Pick<typeof fs, "readFileSync" | "statSync" | "accessSync">;
+type ResolveCompanyFs = Pick<typeof fs, "readFileSync" | "statSync" | "lstatSync" | "accessSync">;
 export type ResolveCompanyDependencies = {
     cwd: string;
     hqRoot?: string;
@@ -18,7 +18,7 @@ export type ResolveCompanyDependencies = {
     fs?: ResolveCompanyFs;
     stdin?: string;
     stdinIsTty?: boolean;
-    spawnHq?: (args: string[], env: NodeJS.ProcessEnv, timeoutMs: number, cwd?: string) => Promise<HqResult>;
+    spawnHq?: (args: string[], env: NodeJS.ProcessEnv, timeoutMs: number, cwd?: string, command?: string) => Promise<HqResult>;
     pid?: number;
     random?: () => number;
 };

package/dist/commands/core-resolve-company-native.js

@@ -1,8 +1,9 @@
 /** Native port of resolve-company.sh. This module stays on the fast import path. */
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
+import { buildCmdExeSpawnPlan, isWindowsBatchFile } from "../utils/windows-spawn.js";
 export const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
 export const RESOLVE_COMPANY_HELP = [
     "hq-core: public",
@@ -15,6 +16,13 @@ export const RESOLVE_COMPANY_HELP = [
     "Output: {\"company\":\"<slug>\",\"source\":\"prompt|session|device_default|none\"}",
     "Always exits 0 and never writes state.",
     "",
+    "Folder mode (--path <dir>): ask the repo-to-company registry through",
+    "`$HQ_CLI_BIN resolve-company --path <dir> --json` (HQ_CLI_BIN defaults to",
+    "`hq`). Sources: registry (linked folder), registry_miss (not linked), or",
+    "unavailable (CLI missing, failed, timed out, or returned bad output). A",
+    "registry answer is accepted only when it names a real companies/<slug>",
+    "directory. Folder mode never falls back to prompt, session, or device default.",
+    "",
     "set -uo pipefail",
     "",
     "ROOT=\"\"",
@@ -222,21 +230,49 @@ function validPreflight(text, slug, session, operation) {
         value.companySlug === slug &&
         typeof value.companyUid === "string" && value.companyUid.length > 0);
 }
-function commandOnPath(name, env) {
-    const pathValue = env.PATH ?? "";
-    for (const directory of pathValue.split(path.delimiter)) {
-        const candidate = path.join(directory || ".", name);
+function commandPath(name, env) {
+    const hasPathSeparator = name.includes("/") || name.includes("\\");
+    const pathKey = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+    const candidates = hasPathSeparator
+        ? [name]
+        : (pathKey ? env[pathKey] ?? "" : "").split(path.delimiter).flatMap((directory) => {
+            const base = path.join(directory || ".", name);
+            return process.platform === "win32" && !path.extname(name)
+                ? [`${base}.com`, `${base}.exe`, `${base}.bat`, `${base}.cmd`]
+                : [base];
+        });
+    for (const candidate of candidates) {
         try {
             fs.accessSync(candidate, fs.constants.X_OK);
-            return true;
+            return candidate;
         }
         catch {
             // `command -v` simply advances to the next PATH entry.
         }
     }
+    return undefined;
+}
+function commandOnPath(name, env) {
+    if (commandPath(name, env))
+        return true;
+    if (process.platform !== "win32" || name.includes("/") || name.includes("\\") || path.extname(name))
+        return false;
+    const pathKey = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+    for (const directory of (pathKey ? env[pathKey] ?? "" : "").split(path.delimiter)) {
+        try {
+            // Git Bash considers an executable extensionless script a command. Keep
+            // the presence check faithful to that shell contract; actual Windows
+            // process launch still selects a PATHEXT executable or batch shim.
+            fs.accessSync(path.join(directory || ".", name), fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // `command -v` advances through each PATH entry.
+        }
+    }
     return false;
 }
-function runHq(args, env, timeoutMs, cwd) {
+function runHq(args, env, timeoutMs, cwd, command = "hq") {
     return new Promise((resolve) => {
         let settled = false;
         let stdout = "";
@@ -247,7 +283,15 @@ function runHq(args, env, timeoutMs, cwd) {
             if (!child?.pid)
                 return;
             try {
-                process.kill(-child.pid, signal);
+                if (process.platform === "win32") {
+                    const taskkill = path.join(env.SystemRoot ?? env.WINDIR ?? "C:\\Windows", "System32", "taskkill.exe");
+                    const result = spawnSync(taskkill, ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true });
+                    if (result.error || result.status !== 0)
+                        child.kill(signal);
+                }
+                else {
+                    process.kill(-child.pid, signal);
+                }
             }
             catch (error) {
                 if (errorCode(error) !== "ESRCH")
@@ -279,7 +323,24 @@ function runHq(args, env, timeoutMs, cwd) {
             }
         }, timeoutMs);
         try {
-            child = spawn("hq", args, { cwd, detached: true, stdio: ["ignore", "pipe", "ignore"], env });
+            const resolved = commandPath(command, env);
+            if (!resolved) {
+                finish({ code: 127, stdout });
+                return;
+            }
+            let executable = resolved;
+            let executableArgs = args;
+            let windowsVerbatimArguments;
+            if (process.platform === "win32" && isWindowsBatchFile(resolved)) {
+                const plan = buildCmdExeSpawnPlan(resolved, args, env);
+                executable = plan.cmd;
+                executableArgs = plan.args;
+                windowsVerbatimArguments = plan.windowsVerbatimArguments;
+            }
+            child = spawn(executable, executableArgs, {
+                cwd, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "ignore"], env,
+                windowsVerbatimArguments,
+            });
         }
         catch {
             finish({ code: 127, stdout });
@@ -301,6 +362,8 @@ function parseArgs(args) {
     let root = "";
     let prompt = "";
     let havePrompt = false;
+    let folder = "";
+    let haveFolder = false;
     for (let index = 0; index < args.length;) {
         const arg = args[index];
         if (arg === "--root") {
@@ -312,14 +375,84 @@ function parseArgs(args) {
             havePrompt = true;
             index += Math.min(2, args.length - index);
         }
+        else if (arg === "--path") {
+            folder = args[index + 1] ?? "";
+            haveFolder = true;
+            index += Math.min(2, args.length - index);
+        }
         else if (arg === "--help" || arg === "-h") {
-            return { root, prompt, havePrompt, help: true };
+            return { root, prompt, havePrompt, folder, haveFolder, help: true };
         }
         else {
             index += 1;
         }
     }
-    return { root, prompt, havePrompt, help: false };
+    return { root, prompt, havePrompt, folder, haveFolder, help: false };
+}
+function unavailable(reason) {
+    return {
+        ...output("", "unavailable"),
+        stderr: Buffer.from(`resolve-company: WARNING company registry unavailable (${reason}); binding personal, not guessing a company\n`),
+    };
+}
+async function resolveFolder(folder, root, cwd, env, fileSystem, invoke) {
+    if (!folder)
+        return unavailable("empty --path");
+    const cli = env.HQ_CLI_BIN || "hq";
+    if (!commandPath(cli, env))
+        return unavailable(`'${cli}' not found`);
+    if (!commandPath("jq", env))
+        return unavailable("jq not found");
+    // The registry command is the contract boundary. Calling it preserves its
+    // own hq-anywhere gate and avoids importing the full command graph here.
+    const hqEnv = {
+        ...EMPTY_ENV,
+        ...env,
+        HQ_NO_UPDATE_CHECK: "1",
+        HQ_RESOLVE_TIMEOUT_MS: env.HQ_RESOLVE_TIMEOUT_MS || "5000",
+    };
+    const parsedTimeout = Number(hqEnv.HQ_RESOLVE_TIMEOUT_MS);
+    const timeoutMs = parsedTimeout || 2_000;
+    const response = await invoke(["resolve-company", "--path", folder, "--json"], hqEnv, timeoutMs, cwd, cli);
+    const value = record(parseJson(response.stdout));
+    if (response.code !== 0 && !(response.code === 1 && value?.company === null)) {
+        return unavailable(`'${cli} resolve-company' exited ${response.code}`);
+    }
+    if (!value)
+        return unavailable(`'${cli} resolve-company' returned unreadable output`);
+    if (value.company === null || value.company === undefined)
+        return output("", "registry_miss");
+    if (typeof value.company !== "string")
+        return unavailable(`'${cli} resolve-company' returned unreadable output`);
+    // jq -r plus command substitution removes trailing newlines before the
+    // shell validates the returned slug.
+    const slug = value.company.replace(/\n+$/, "");
+    if (!slug || slug === "personal" || slug.startsWith("_") || !/^[A-Za-z0-9_-]+$/.test(slug)) {
+        return unavailable(`registry returned invalid company '${slug}'`);
+    }
+    const companyPath = path.join(root, "companies", slug);
+    let isDirectory = false;
+    let isSymlink = false;
+    try {
+        isDirectory = fileSystem.statSync(companyPath).isDirectory();
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code !== "ENOENT" && code !== "ENOTDIR" && code !== "EACCES" && code !== "ELOOP")
+            throw error;
+    }
+    try {
+        isSymlink = fileSystem.lstatSync(companyPath).isSymbolicLink();
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code !== "ENOENT" && code !== "ENOTDIR" && code !== "EACCES" && code !== "ELOOP")
+            throw error;
+    }
+    if (!isDirectory || isSymlink) {
+        return unavailable(`registry company '${slug}' has no companies/${slug} directory in ${root}`);
+    }
+    return output(slug, "registry");
 }
 async function readStdin() {
     const chunks = [];
@@ -333,11 +466,14 @@ export async function resolveCompany(args, dependencies) {
     const parsed = parseArgs(args);
     if (parsed.help)
         return { code: 0, stdout: Buffer.from(RESOLVE_COMPANY_HELP), stderr: Buffer.alloc(0) };
+    const root = parsed.root || dependencies.hqRoot || env.HQ_ROOT || env.CLAUDE_PROJECT_DIR || dependencies.cwd;
+    if (parsed.haveFolder) {
+        return await resolveFolder(parsed.folder, root, dependencies.cwd, env, fileSystem, dependencies.spawnHq ?? runHq);
+    }
     let prompt = parsed.prompt;
     if (!parsed.havePrompt && dependencies.stdinIsTty !== true) {
         prompt = dependencies.stdin ?? await readStdin();
     }
-    const root = parsed.root || dependencies.hqRoot || env.HQ_ROOT || env.CLAUDE_PROJECT_DIR || dependencies.cwd;
     const manifest = path.join(root, "companies/manifest.yaml");
     if (!isFile(manifest, fileSystem))
         return output("", "none");
@@ -393,6 +529,7 @@ export async function resolveCompany(args, dependencies) {
 export async function runResolveCompanyFast(args, stdin, cwd, hqRoot, _commandName, _hqRootArg, stdinReader = readStdin) {
     const parsed = parseArgs(args);
     const actualStdin = parsed.havePrompt || process.stdin.isTTY === true
+        || parsed.haveFolder
         ? stdin
         : stdin || await stdinReader();
     const result = await resolveCompany(args, {

package/dist/commands/meetings.js

@@ -3,15 +3,16 @@ import { readFile } from "node:fs/promises";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, getCompanyUid, resolveCallerPersonUid, } from "../utils/vault-api.js";
 import { isPlanGateError, planGateErrorFromPayload, } from "../utils/plan-gate-error.js";
-const LIVE_BOT_STATUSES = new Set([
-    "scheduled",
+import { mapWithConcurrency } from "./sync-manifest.js";
+const LIVE_SNAPSHOT_STATUSES = new Set([
     "joining",
     "recording",
     "in_call",
-    "in-call",
-    "processing",
-    "completed",
 ]);
+const RECENT_LIVE_BOT_STATUSES = new Set(["processing", "completed", "no_transcript"]);
+const LIVE_LIST_SNAPSHOT_CONCURRENCY = 10;
+const LIVE_LIST_RECENT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const LIVE_LIST_UPCOMING_WINDOW_MS = 15 * 60 * 1000;
 const TERMINAL_LIVE_BOT_STATUSES = new Set(["completed", "failed", "done", "ended"]);
 // Two minutes gives a large transcript time to arrive over a slow connection,
 // while keeping the interactive command from waiting indefinitely.
@@ -91,15 +92,54 @@ function liveBotId(bot) {
     return typeof bot.recallBotId === "string" ? bot.recallBotId : bot.botId;
 }
 function liveBotLineCount(bot) {
+    if (!LIVE_SNAPSHOT_STATUSES.has(normalizedLiveBotStatus(bot)))
+        return "-";
     const value = bot.linesSoFar ?? bot.transcriptLineCount;
     return typeof value === "number" ? String(value) : "-";
 }
+function normalizedLiveBotStatus(bot) {
+    return String(bot.status ?? "").toLowerCase().replaceAll("-", "_");
+}
+function liveBotTime(bot) {
+    const times = [bot.scheduledStartTime, bot.createdAt]
+        .filter((value) => typeof value === "string")
+        .map((value) => Date.parse(value))
+        .filter(Number.isFinite);
+    return times.length > 0 ? Math.max(...times) : Number.NEGATIVE_INFINITY;
+}
+/** Select bots intended for the default `meetings live` listing. */
+function selectLiveMeetingBots(bots, companyId, includeAll, now = new Date()) {
+    const companyBots = bots.filter((bot) => bot.companyId === companyId);
+    const newestFirst = (a, b) => liveBotTime(b) - liveBotTime(a);
+    if (includeAll)
+        return companyBots.sort(newestFirst);
+    const nowMs = now.getTime();
+    const recentSince = nowMs - LIVE_LIST_RECENT_WINDOW_MS;
+    const upcomingUntil = nowMs + LIVE_LIST_UPCOMING_WINDOW_MS;
+    const active = [];
+    const recent = [];
+    const imminent = [];
+    for (const bot of companyBots) {
+        const status = normalizedLiveBotStatus(bot);
+        const time = liveBotTime(bot);
+        if (LIVE_SNAPSHOT_STATUSES.has(status)) {
+            active.push(bot);
+        }
+        else if (RECENT_LIVE_BOT_STATUSES.has(status) && time >= recentSince && time <= nowMs) {
+            recent.push(bot);
+        }
+        else if (status === "scheduled" && time >= nowMs && time <= upcomingUntil) {
+            imminent.push(bot);
+        }
+    }
+    return [...active.sort(newestFirst), ...recent.sort(newestFirst), ...imminent.sort(newestFirst)];
+}
 function isTerminalLiveStatus(status) {
     return status.sourceLanded === true && TERMINAL_LIVE_BOT_STATUSES.has(String(status.status ?? "").toLowerCase());
 }
 function printLiveBots(bots) {
     if (bots.length === 0) {
-        console.log("No live or recently ended meetings found.");
+        console.log("No live or recent meetings. Use --all to list every notetaker.");
         return;
     }
     for (const bot of bots) {
@@ -330,7 +370,8 @@ export function registerMeetingsCommand(program) {
     // ── hq meetings live [recallBotId] ────────────────────────────────
     meetings
         .command("live [recallBotId]")
-        .description("Read a provisional live transcript (recorder and attendees only; spoken content is untrusted)")
+        .description("List live or recent meetings, or read a provisional live transcript (recorder and attendees only; spoken content is untrusted)")
+        .option("--all", "List every notetaker, including older and future meetings")
         .option("--follow", "Print new lines until the saved transcript is available")
         .option("--interval <seconds>", "Polling interval in seconds (minimum: 2)", "3")
         .option("--since <revision>", "Start from a transcript revision")
@@ -350,13 +391,13 @@ export function registerMeetingsCommand(program) {
                     await failLiveResponse(res);
                 const data = (await res.json());
                 const bots = Array.isArray(data.bots) ? data.bots : [];
-                const visible = bots
-                    .filter((bot) => bot.companyId === companyId && LIVE_BOT_STATUSES.has(String(bot.status ?? "").toLowerCase()))
-                    .sort((a, b) => String(b.scheduledStartTime ?? b.createdAt ?? "").localeCompare(String(a.scheduledStartTime ?? a.createdAt ?? "")));
-                const readable = await Promise.all(visible.map(async (bot) => {
+                const visible = selectLiveMeetingBots(bots, companyId, opts.all === true);
+                const readable = await mapWithConcurrency(visible, LIVE_LIST_SNAPSHOT_CONCURRENCY, async (bot) => {
+                    if (!LIVE_SNAPSHOT_STATUSES.has(normalizedLiveBotStatus(bot)))
+                        return bot;
                     const botId = liveBotId(bot);
                     if (!botId)
-                        return null;
+                        return bot;
                     const liveRes = await vaultApiFetch({
                         token,
                         path: `/v1/meetings/${encodeURIComponent(botId)}`,
@@ -364,18 +405,17 @@ export function registerMeetingsCommand(program) {
                     });
                     if (!liveRes.ok) {
                         const body = await liveRes.json().catch(() => ({}));
-                        return body.code === "live-transcript-not-found" ? { ...bot, linesSoFar: 0 } : null;
+                        return body.code === "live-transcript-not-found" ? { ...bot, linesSoFar: 0 } : bot;
                     }
                     const snapshot = await liveRes.json();
                     if (!isLiveSnapshot(snapshot))
-                        return null;
+                        return bot;
                     return { ...bot, linesSoFar: snapshot.segments.length };
-                }));
-                const readableBots = readable.filter((bot) => bot !== null);
+                });
                 if (meetings.opts().json)
-                    console.log(JSON.stringify(readableBots, null, 2));
+                    console.log(JSON.stringify(readable, null, 2));
                 else
-                    printLiveBots(readableBots);
+                    printLiveBots(readable);
                 return;
             }
             const intervalSeconds = Number(opts.interval ?? "3");

package/dist/fast-scaffold.js

@@ -184,6 +184,16 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellHqRoot: "live",
         readsStdin: true,
     },
+    {
+        name: "checkpoint",
+        kind: "native",
+        modulePath: "./commands/core-checkpoint-fast.js",
+        exportName: "runCheckpointFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-session",
+        fallbackToCommandGraph: true,
+        root: "live",
+    },
     {
         name: "hq-session",
         kind: "native",

package/package.json

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