@indigoai-us/hq-cli 5.345.106 → 5.345.108

package/dist/commands/capacity.js

@@ -3,12 +3,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as readline from "node:readline";
-import { LedgerCorrupt, LedgerMissing, READING_SOURCES, capacityRoot, nowViewJsonSchema, readCollectorMark, readLedgerEvents, readNow, rebuildNow, setCollectorEnabled, } from "../lib/capacity/ledger.js";
+import { LedgerCorrupt, LedgerMissing, READING_SOURCES, capacityOptionsFromEnv, capacityRoot, nowViewJsonSchema, readCollectorMark, readLedgerEvents, readNow, rebuildNow, setCollectorEnabled, } from "../lib/capacity/ledger.js";
 import { listCapacityAccounts, registryAccountIds } from "../lib/capacity/accounts.js";
 import { claudeIdentityKeys } from "../lib/capacity/collectors/claude-oauth.js";
 import { projectCapacityView } from "../lib/capacity/project.js";
 import { capacityWidgetTimeZone, renderCapacityWidget } from "../lib/capacity/widget.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { loadLanesConfig } from "../lib/lanes/config.js";
+import { readAllLanes } from "../lib/lanes/store.js";
+import { RouteUsageError, formatRouteText, pickAccount, resolveFloor, } from "../lib/capacity/route.js";
 import { SignInUsageError, executeCapacityLogin, formatCredits, formatLoginText, formatRefreshLine, formatRoster, generateAccountId, loginJson, presentAccount, promptsAllowed, removeCapacityAccount, renameCapacityAccount, rosterFrom, } from "../lib/capacity/sign-in.js";
 import { ingestClaudeStatuslinePayload, installStatuslineSpoolScript } from "../lib/capacity/collectors/claude-statusline.js";
 import { CapacityUsageError, REFUSAL_HELP, ingestRefusal, } from "../lib/capacity/refusal.js";
@@ -45,16 +48,7 @@ const HISTORY_HEADERS = [
     "SOURCE",
     "CLI VERSION",
 ];
-export function capacityOptionsFromEnv(env = process.env) {
-    const raw = env.HQ_CAPACITY_NOW?.trim();
-    if (!raw)
-        return { env };
-    const parsed = Date.parse(raw);
-    if (Number.isNaN(parsed)) {
-        throw new Error(`HQ_CAPACITY_NOW must be a UTC timestamp, got '${raw}'`);
-    }
-    return { env, now: () => new Date(raw) };
-}
+export { capacityOptionsFromEnv } from "../lib/capacity/ledger.js";
 export function withSchemaVersion(view) {
     return { ...view, schemaVersion: CAPACITY_SCHEMA_VERSION };
 }
@@ -297,6 +291,69 @@ export function registerCapacityCommand(program) {
                 process.exitCode = 1;
         });
     });
+    capacity
+        .command("route")
+        .description("Pick the account with the most capacity for a new lane (read-only; port of boss-route)")
+        .option("--provider <list>", "Comma-separated list: any, claude, codex, grok", "any")
+        .option("--model <id>", "Model id. Narrows --provider any to the mapped provider")
+        .option("--prefer <list>", "Comma-separated preferred provider order", "claude,codex,grok")
+        .option("--floor <percent>", "Minimum headroom percent the pick must clear (0-100)", "15")
+        .option("--json", "Print the route result as JSON (default)")
+        .option("--text", "Print a single-line text summary instead of JSON")
+        .action((_opts, command) => {
+        runCli(() => {
+            const opts = command.optsWithGlobals();
+            if (opts.json && opts.text) {
+                throw new RouteUsageError("--text cannot be combined with --json");
+            }
+            const clock = capacityClock();
+            const view = loadNow(clock.options);
+            const freshness = capacityFreshness(view.generatedAt, clock.nowMs);
+            const mark = readCollectorMark(clock.options);
+            const hqRoot = resolveLanesHqRoot({ env: process.env });
+            const lanesConfig = loadLanesConfig(hqRoot);
+            let lanes = [];
+            let lanesError = null;
+            try {
+                lanes = readAllLanes(hqRoot);
+            }
+            catch (err) {
+                lanesError = err instanceof Error ? err.message : String(err);
+            }
+            let result;
+            try {
+                result = pickAccount({
+                    view,
+                    lanes,
+                    lanesConfig,
+                    providers: splitList(opts.provider),
+                    model: opts.model ?? null,
+                    prefer: splitList(opts.prefer),
+                    floor: resolveFloor(opts.floor),
+                    now: new Date(clock.nowMs),
+                    collectorEnabled: mark ? mark.enabled : null,
+                    capacityStale: freshness.stale,
+                    lanesError,
+                });
+            }
+            catch (err) {
+                if (err instanceof RouteUsageError) {
+                    console.error(err.message);
+                    process.exitCode = 1;
+                    return;
+                }
+                throw err;
+            }
+            if (opts.text) {
+                console.log(formatRouteText(result));
+            }
+            else {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            if (!result.ok)
+                process.exitCode = 2;
+        });
+    });
     capacity
         .command("enable")
         .description("Create the ledger directory and mark the collector on")
@@ -594,6 +651,12 @@ function wantsJson(opts, command) {
     }
     return false;
 }
+function splitList(raw) {
+    if (raw === undefined)
+        return undefined;
+    const parts = raw.split(",").map((v) => v.trim()).filter(Boolean);
+    return parts.length === 0 ? undefined : parts;
+}
 function runCli(action) {
     try {
         process.exitCode = 0;

package/dist/commands/core-checkpoint-stop-gate-native.js

@@ -73,15 +73,27 @@ const defaults = () => ({
     },
     makeTempPath: () => path.join(os.tmpdir(), `tmp.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`),
     commandExists: (name, env) => {
+        const windowsExtensions = process.platform === "win32"
+            ? (env?.PATHEXT ?? process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
+            : [];
         for (const entry of (env?.PATH ?? process.env.PATH ?? "").split(path.delimiter)) {
             if (!entry)
                 continue;
-            const candidate = path.join(entry, name);
-            try {
-                fs.accessSync(candidate, fs.constants.X_OK);
-                return true;
+            const candidates = [name, ...windowsExtensions.map((extension) => `${name}${extension}`)];
+            for (const command of candidates) {
+                const candidate = path.join(entry, command);
+                try {
+                    if (process.platform === "win32") {
+                        if (fs.statSync(candidate).isFile())
+                            return true;
+                    }
+                    else {
+                        fs.accessSync(candidate, fs.constants.X_OK);
+                        return true;
+                    }
+                }
+                catch { /* try the next candidate in PATH */ }
             }
-            catch { /* try the next PATH entry */ }
         }
         return false;
     },

package/dist/commands/core-hq-task-fast.d.ts

@@ -0,0 +1,4 @@
+import { HQ_TASK_ASSET, runHqTask } from "./core-hq-task-native.js";
+export { HQ_TASK_ASSET, runHqTask };
+export declare function runHqTaskFast(args: string[], _stdin: string, _cwd: string, root: string): number;
+//# sourceMappingURL=core-hq-task-fast.d.ts.map

package/dist/commands/core-hq-task-fast.js

@@ -0,0 +1,11 @@
+import { HQ_TASK_ASSET, runHqTask } from "./core-hq-task-native.js";
+export { HQ_TASK_ASSET, runHqTask };
+export function runHqTaskFast(args, _stdin, _cwd, root) {
+    const result = runHqTask(args, root);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-hq-task-fast.js.map

package/dist/commands/core-hq-task-native.d.ts

@@ -0,0 +1,20 @@
+import * as fs from "node:fs";
+export declare const HQ_TASK_ASSET = "core/scripts/hq-task.sh";
+type Board = {
+    tasks: Array<Record<string, any>>;
+    objectives?: Array<Record<string, any>>;
+    [key: string]: any;
+};
+export type HqTaskResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+type AtomicFileIO = Pick<typeof fs, "writeFileSync" | "renameSync" | "chmodSync" | "statSync" | "existsSync" | "unlinkSync">;
+declare function save(file: string, board: Board, io?: AtomicFileIO): HqTaskResult | undefined;
+export declare const __hqTaskTest: {
+    save: typeof save;
+};
+export declare function runHqTask(args: readonly string[], root: string, env?: NodeJS.ProcessEnv): HqTaskResult;
+export {};
+//# sourceMappingURL=core-hq-task-native.d.ts.map

package/dist/commands/core-hq-task-native.js

@@ -0,0 +1,275 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+export const HQ_TASK_ASSET = "core/scripts/hq-task.sh";
+const USAGE = `hq-task — the global task list on an HQ board
+
+Usage:
+  hq-task.sh list   [--company <slug>] [--all] [--goal <objective-id>]
+  hq-task.sh add    [--company <slug>] --title "<short title>"
+                    [--description "<context>"]
+                    [--criteria "<one done-criterion>"]...
+                    [--contact "Name <email>|role"]...
+                    [--goal <objective-id>] [--priority <1-3>]
+  hq-task.sh done   [--company <slug>] --id T-002
+  hq-task.sh block  [--company <slug>] --id T-002 --reason "<what is in the way>"
+  hq-task.sh reopen [--company <slug>] --id T-002
+  hq-task.sh goals  [--company <slug>]
+
+Default board: personal/board.json. With --company: companies/<slug>/board.json.`;
+function isUnsafeCompanySlug(root, company) {
+    if (company.length === 0 || path.isAbsolute(company) || path.win32.isAbsolute(company) ||
+        company.includes("..") || /[\\/]/.test(company))
+        return true;
+    const companiesRoot = path.resolve(root, "companies");
+    const target = path.resolve(companiesRoot, company, "board.json");
+    const relative = path.relative(companiesRoot, target);
+    return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+}
+function nodeOnPath(env, platform = process.platform) {
+    const searchPath = env.PATH || "";
+    const names = platform === "win32" ? ["node.exe", "node.cmd", "node.bat"] : ["node"];
+    for (const directory of searchPath.split(path.delimiter)) {
+        if (!directory)
+            continue;
+        for (const name of names) {
+            try {
+                const candidate = path.join(directory, name);
+                fs.accessSync(candidate, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+                if (fs.statSync(candidate).isFile())
+                    return true;
+            }
+            catch {
+                // command -v ignores PATH entries that do not contain an executable.
+            }
+        }
+    }
+    return false;
+}
+function fail(message, code = 1) {
+    return { code, stdout: "", stderr: `${message}\n` };
+}
+function parseArgs(argv) {
+    const repeatable = new Set(["criteria", "contact"]);
+    const bare = new Set(["all"]);
+    const flags = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!token.startsWith("--"))
+            return { error: fail(`Unexpected argument: ${token}\n\n${USAGE}`) };
+        const key = token.slice(2);
+        if (bare.has(key)) {
+            flags[key] = true;
+            continue;
+        }
+        const value = argv[i + 1];
+        if (value === undefined || value.startsWith("--"))
+            return { error: fail(`Flag --${key} needs a value.\n\n${USAGE}`) };
+        i += 1;
+        if (repeatable.has(key)) {
+            const previous = flags[key];
+            flags[key] = [...(Array.isArray(previous) ? previous : []), value];
+        }
+        else
+            flags[key] = value;
+    }
+    return { flags };
+}
+function text(flags, key) {
+    const value = flags[key];
+    return typeof value === "string" ? value : undefined;
+}
+function boardPath(root, flags) {
+    const company = text(flags, "company");
+    return company ? path.join(root, "companies", company, "board.json") : path.join(root, "personal", "board.json");
+}
+function load(root, flags) {
+    const file = boardPath(root, flags);
+    if (!fs.existsSync(file))
+        return { error: fail(`No board at ${file}`) };
+    try {
+        const board = JSON.parse(fs.readFileSync(file, "utf8"));
+        board.tasks ||= [];
+        return { file, board };
+    }
+    catch (error) {
+        return { error: fail(error.message) };
+    }
+}
+function save(file, board, io = fs) {
+    board.updated_at = new Date().toISOString().replace(/\.\d+Z$/, "Z");
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        const mode = io.statSync(file).mode & 0o7777;
+        io.writeFileSync(temporary, `${JSON.stringify(board, null, 2)}\n`, { flag: "wx", mode });
+        io.chmodSync(temporary, mode);
+        io.renameSync(temporary, file);
+    }
+    catch (error) {
+        try {
+            if (io.existsSync(temporary))
+                io.unlinkSync(temporary);
+        }
+        catch { /* preserve the write or rename error */ }
+        return fail(error.message);
+    }
+    return undefined;
+}
+export const __hqTaskTest = { save };
+function parseContact(raw) {
+    let rest = raw;
+    let role;
+    const bar = rest.indexOf("|");
+    if (bar !== -1) {
+        role = rest.slice(bar + 1).trim();
+        rest = rest.slice(0, bar).trim();
+    }
+    let email;
+    const angle = /<([^>]+)>/.exec(rest);
+    if (angle) {
+        email = angle[1].trim();
+        rest = rest.slice(0, angle.index).trim();
+    }
+    const contact = { name: rest };
+    if (email)
+        contact.email = email;
+    if (role)
+        contact.role = role;
+    return contact;
+}
+function goalTitle(board, id) {
+    const objective = (board.objectives || []).find((row) => row.id === id);
+    return objective ? String(objective.title) : null;
+}
+function runList(root, flags) {
+    const loaded = load(root, flags);
+    if (loaded.error)
+        return loaded.error;
+    const board = loaded.board;
+    let tasks = board.tasks.filter((task) => flags.all === true || task.status !== "done");
+    const goal = text(flags, "goal");
+    if (goal)
+        tasks = tasks.filter((task) => task.objective_id === goal);
+    if (tasks.length === 0)
+        return { code: 0, stdout: "No open tasks.\n", stderr: "" };
+    const output = [`${text(flags, "company") || "personal"} — ${flags.all ? "all tasks" : "open tasks"} (${tasks.length})\n\n`];
+    tasks.sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99) || String(a.id).localeCompare(String(b.id)));
+    for (const task of tasks) {
+        const mark = task.status === "blocked" ? "!" : task.status === "done" ? "x" : " ";
+        output.push(`  [${mark}] ${task.id}  ${task.title || ""}\n`);
+        const goalName = task.objective_id && goalTitle(board, task.objective_id);
+        if (goalName)
+            output.push(`         goal: ${goalName}\n`);
+        if (task.status === "blocked" && task.blockedReason)
+            output.push(`         blocked: ${task.blockedReason}\n`);
+        for (const contact of task.contacts || []) {
+            const trail = [contact.email, contact.phone].filter(Boolean).join(" · ");
+            output.push(`         ${contact.name}${trail ? ` — ${trail}` : ""}\n`);
+        }
+    }
+    return { code: 0, stdout: output.join(""), stderr: "" };
+}
+function runGoals(root, flags) {
+    const loaded = load(root, flags);
+    if (loaded.error)
+        return loaded.error;
+    const board = loaded.board;
+    const objectives = board.objectives || [];
+    if (objectives.length === 0)
+        return { code: 0, stdout: "No goals on that board.\n", stderr: "" };
+    const output = [];
+    for (const objective of objectives) {
+        const count = board.tasks.filter((task) => task.objective_id === objective.id && task.status !== "done").length;
+        output.push(`${objective.id}  ${objective.title}  (${count} open task${count === 1 ? "" : "s"})\n`);
+        for (const kr of objective.key_results || [])
+            output.push(`    ${kr.title} — ${kr.current ?? 0}/${kr.target} ${kr.unit || ""}\n`);
+    }
+    return { code: 0, stdout: output.join(""), stderr: "" };
+}
+export function runHqTask(args, root, env = process.env) {
+    if (!nodeOnPath(env))
+        return fail("hq-task: node is required but was not found on PATH.");
+    const [command, ...rest] = args;
+    if (!command || command === "--help" || command === "-h") {
+        return { code: command ? 0 : 1, stdout: `${USAGE}\n`, stderr: "" };
+    }
+    if (!(command in { list: 1, goals: 1, add: 1, done: 1, reopen: 1, block: 1 }))
+        return fail(`Unknown command: ${command}\n\n${USAGE}`);
+    const parsed = parseArgs(rest);
+    if (parsed.error)
+        return parsed.error;
+    const flags = parsed.flags;
+    const company = text(flags, "company");
+    if (company !== undefined && isUnsafeCompanySlug(root, company))
+        return fail(`Invalid company slug: ${company}`);
+    if (command === "list")
+        return runList(root, flags);
+    if (command === "goals")
+        return runGoals(root, flags);
+    if (command === "add") {
+        const title = text(flags, "title");
+        if (!title)
+            return fail(`add needs --title.\n\n${USAGE}`);
+        const priority = text(flags, "priority");
+        if (flags.priority !== undefined && !/^[1-3]$/.test(priority ?? "")) {
+            return fail("--priority must be an integer from 1 to 3");
+        }
+        const loaded = load(root, flags);
+        if (loaded.error)
+            return loaded.error;
+        const board = loaded.board, file = loaded.file;
+        const goal = text(flags, "goal");
+        if (goal && !goalTitle(board, goal))
+            return fail(`No goal ${goal} on that board. Run 'hq-task.sh goals' to list them.`);
+        let highest = 0;
+        for (const task of board.tasks) {
+            const match = /^T-(\d+)$/.exec(task.id || "");
+            if (match)
+                highest = Math.max(highest, Number(match[1]));
+        }
+        const criteria = flags.criteria;
+        const contacts = flags.contact;
+        const task = {
+            id: `T-${String(highest + 1).padStart(3, "0")}`,
+            title,
+            description: text(flags, "description") || title,
+            status: "open",
+            priority: priority ? Number(priority) : 2,
+            objective_id: goal || null,
+            criteria: criteria || [`${title} — completed.`],
+            contacts: (contacts || []).map(parseContact),
+            createdAt: new Date().toISOString().slice(0, 10),
+        };
+        board.tasks.push(task);
+        const error = save(file, board);
+        if (error)
+            return error;
+        return { code: 0, stdout: `Added ${task.id}: ${task.title}\n`, stderr: "" };
+    }
+    if (command === "block" && !text(flags, "reason"))
+        return fail(`block needs --reason.\n\n${USAGE}`);
+    const loaded = load(root, flags);
+    if (loaded.error)
+        return loaded.error;
+    const id = text(flags, "id");
+    const nextStatus = command === "done" ? "done" : command === "block" ? "blocked" : "open";
+    if (!id)
+        return fail(`${command} needs --id.\n\n${USAGE}`);
+    const task = loaded.board.tasks.find((row) => row.id === id);
+    if (!task)
+        return fail(`No task ${id} on that board.`);
+    task.status = nextStatus;
+    if (nextStatus === "done")
+        task.closedAt = new Date().toISOString().slice(0, 10);
+    else
+        delete task.closedAt;
+    if (nextStatus === "blocked")
+        task.blockedReason = text(flags, "reason") || "";
+    else
+        delete task.blockedReason;
+    const error = save(loaded.file, loaded.board);
+    if (error)
+        return error;
+    return { code: 0, stdout: `${task.id} → ${nextStatus}: ${task.title}\n`, stderr: "" };
+}
+//# sourceMappingURL=core-hq-task-native.js.map

package/dist/commands/core-native-bucket-c-flag.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE_NATIVE_BUCKET_C_FLAG = "core-native-bucket-c";
+export declare function coreNativeBucketCEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-bucket-c-flag.d.ts.map

package/dist/commands/core-native-bucket-c-flag.js

@@ -0,0 +1,6 @@
+import { coreNativeFamilyEnabled } from "./core-native-family-flag.js";
+export const CORE_NATIVE_BUCKET_C_FLAG = "core-native-bucket-c";
+export function coreNativeBucketCEnabled() {
+    return coreNativeFamilyEnabled(CORE_NATIVE_BUCKET_C_FLAG);
+}
+//# sourceMappingURL=core-native-bucket-c-flag.js.map

package/dist/commands/core-native-family-flag.d.ts

@@ -1,7 +1,5 @@
 /** Shared fail-safe readers for shipped native core families. */
 export declare function coreNativeFamilyEnabled(flagKey: string): Promise<boolean>;
 export declare const CORE_NATIVE_DELEGATE_FLAG = "core-native-delegate";
-export declare const CORE_NATIVE_ONTOLOGY_FLAG = "core-native-ontology";
 export declare function coreNativeDelegateEnabled(): Promise<boolean>;
-export declare function coreNativeOntologyEnabled(): Promise<boolean>;
 //# sourceMappingURL=core-native-family-flag.d.ts.map

package/dist/commands/core-native-family-flag.js

@@ -11,11 +11,7 @@ export async function coreNativeFamilyEnabled(flagKey) {
     });
 }
 export const CORE_NATIVE_DELEGATE_FLAG = "core-native-delegate";
-export const CORE_NATIVE_ONTOLOGY_FLAG = "core-native-ontology";
 export function coreNativeDelegateEnabled() {
     return coreNativeFamilyEnabled(CORE_NATIVE_DELEGATE_FLAG);
 }
-export function coreNativeOntologyEnabled() {
-    return coreNativeFamilyEnabled(CORE_NATIVE_ONTOLOGY_FLAG);
-}
 //# sourceMappingURL=core-native-family-flag.js.map

package/dist/commands/core-native-pipeline-flag.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE_NATIVE_PIPELINE_FLAG = "core-native-pipeline";
+export declare function coreNativePipelineEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-pipeline-flag.d.ts.map

package/dist/commands/core-native-pipeline-flag.js

@@ -0,0 +1,6 @@
+import { coreNativeFamilyEnabled } from "./core-native-family-flag.js";
+export const CORE_NATIVE_PIPELINE_FLAG = "core-native-pipeline";
+export function coreNativePipelineEnabled() {
+    return coreNativeFamilyEnabled(CORE_NATIVE_PIPELINE_FLAG);
+}
+//# sourceMappingURL=core-native-pipeline-flag.js.map

package/dist/commands/core-ontology-native.js

@@ -4,15 +4,16 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveWindowsExecutable } from "../lib/bot/runtime/windows.js";
-import { runBundledScript } from "../utils/run-bundled-script.js";
-import { resolveBundledAsset } from "../utils/hq-roots.js";
+import { BUNDLED_ASSET_DIR, packageRoot } from "../utils/hq-roots.js";
 import { planResolvedCommandSpawn } from "../utils/windows-spawn.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
 import { runKnowledgePrefs } from "./core-knowledge-prefs.js";
-const FLAG = "core-native-ontology";
 const ASSET = "core/scripts/";
 const SIGNAL_TYPES = ["decision", "commitment", "risk", "question", "action_item", "key_point", "participant_contribution", "summary"];
 const CANDIDATE_SIGNAL_TYPES = ["action_item", "commitment", "decision", "risk", "question", "key_point", "participant_contribution", "summary"];
+function legacyAssetPath(name) {
+    return path.join(packageRoot(), BUNDLED_ASSET_DIR, ASSET, name);
+}
 const ENTITY_TYPES = ["person", "project", "company", "concept"];
 const ok = (stdout = "") => ({ code: 0, stdout, stderr: "" });
 const err = (code, stderr, stdout = "") => ({ code, stdout, stderr });
@@ -179,7 +180,7 @@ export function candidateCommand(args, root) {
                 "--company": 50, "--kind": 51, "--type": 52, "--audience": 53,
                 "--source-ref": 54, "--body": 55, "--body-file": 56, "--created-by": 57,
             };
-            return err(1, `${resolveBundledAsset(`${ASSET}ontology-candidate.sh`)}: line ${lines[name]}: $2: unbound variable\n`);
+            return err(1, `${legacyAssetPath("ontology-candidate.sh")}: line ${lines[name]}: $2: unbound variable\n`);
         }
         values[aliases[name]] = args[++index];
     }
@@ -677,7 +678,7 @@ export function audienceGrant(args, root) {
         const key = args[index];
         if (key === "--company") {
             if (index + 1 >= args.length)
-                return err(1, `${resolveBundledAsset(`${ASSET}ontology-audience-grant.sh`)}: line 26: $2: unbound variable\n`);
+                return err(1, `${legacyAssetPath("ontology-audience-grant.sh")}: line 26: $2: unbound variable\n`);
             company = args[++index];
         }
         else if (key === "--dry-run")
@@ -707,9 +708,14 @@ export function audienceGrant(args, root) {
     if (!cloud)
         return ok("local-only, no grants\n");
     const membersRun = runHq(["members", "--company", company, "list"]);
-    const memberLines = membersRun.stdout.split("\n").slice(1).map((line) => line.trim().split(/[\t ]+/)[0]?.toLowerCase() ?? "");
-    const members = shellSubstitution(memberLines.join("\n"));
-    if (!members)
+    const memberLines = membersRun.stdout.split("\n");
+    const members = new Set();
+    for (let index = 1; index < memberLines.length; index += 1) {
+        const member = memberLines[index].trim().split(/[\t ]+/)[0]?.toLowerCase() ?? "";
+        if (member)
+            members.add(member);
+    }
+    if (members.size === 0)
         return err(3, `could not list members of ${company}\n`);
     let granted = 0;
     let skipped = 0;
@@ -774,7 +780,7 @@ export function audienceGrant(args, root) {
             }
         }
         for (const who of principals) {
-            if (!/^prs_|^agt_/.test(who) && !members.split("\n").includes(who)) {
+            if (!/^prs_|^agt_/.test(who) && !members.has(who)) {
                 stderr += `skip ${who} (not a member of ${company})\n`;
                 skipped += 1;
                 continue;
@@ -913,7 +919,7 @@ export function worklistCommand(args, root) {
         if (key === "--company" || key === "--channel" || key === "--limit" || key === "--mark-done") {
             if (index + 1 >= args.length) {
                 const line = key === "--mark-done" ? 30 : 29;
-                return err(1, `${resolveBundledAsset(`${ASSET}ontology-source-worklist.sh`)}: line ${line}: $2: unbound variable\n`);
+                return err(1, `${legacyAssetPath("ontology-source-worklist.sh")}: line ${line}: $2: unbound variable\n`);
             }
             const value = args[++index];
             if (key === "--company")
@@ -1069,7 +1075,7 @@ export function worklistCommand(args, root) {
         if (/^[+-]?\d+$/.test(limit) && count >= Number(limit))
             break;
         if (!/^[+-]?\d+$/.test(limit)) {
-            process.stderr.write(`${resolveBundledAsset(`${ASSET}ontology-source-worklist.sh`)}: line 186: [: ${limit}: integer expression expected\n`);
+            process.stderr.write(`${legacyAssetPath("ontology-source-worklist.sh")}: line 186: [: ${limit}: integer expression expected\n`);
         }
         count += 1;
         const file = path.join(directory, name);
@@ -1128,12 +1134,12 @@ export function worklistCommand(args, root) {
 }
 export function registerCoreOntologyNativeCommands(ontology, rootFor) {
     const entries = [
-        { name: "audience-grant", summary: "Grant scoped ontology audiences and verify each grant", asset: "ontology-audience-grant.sh", root: "live", run: audienceGrant },
-        { name: "brief", summary: "Render the local ontology company brief", asset: "ontology-brief.mjs", root: "live", run: (args, root) => briefCommand(args, root) },
-        { name: "candidate", summary: "Write a deterministic ontology candidate", asset: "ontology-candidate.sh", root: "live", run: candidateCommand },
-        { name: "garden", summary: "Promote local ontology candidates", asset: "ontology-garden.mjs", root: "live", run: (args, root) => gardenCommand(args, root) },
-        { name: "source-worklist", summary: "List unprocessed source items and their audience", asset: "ontology-source-worklist.sh", root: "live", run: worklistCommand },
-        { name: "source-yaml-validate", summary: "Validate a source.yaml file", asset: "source-yaml-validate.sh", root: "cwd", run: (args) => sourceYamlValidate(args[0]) },
+        { name: "audience-grant", summary: "Grant scoped ontology audiences and verify each grant", root: "live", run: audienceGrant },
+        { name: "brief", summary: "Render the local ontology company brief", root: "live", run: (args, root) => briefCommand(args, root) },
+        { name: "candidate", summary: "Write a deterministic ontology candidate", root: "live", run: candidateCommand },
+        { name: "garden", summary: "Promote local ontology candidates", root: "live", run: (args, root) => gardenCommand(args, root) },
+        { name: "source-worklist", summary: "List unprocessed source items and their audience", root: "live", run: worklistCommand },
+        { name: "source-yaml-validate", summary: "Validate a source.yaml file", root: "cwd", run: (args) => sourceYamlValidate(args[0]) },
     ];
     const rawArgv = process.argv.slice(2);
     const coreIndex = rawArgv.indexOf("core");
@@ -1170,21 +1176,9 @@ export function registerCoreOntologyNativeCommands(ontology, rootFor) {
             const forwarded = commandIndex >= 0 ? argv.slice(commandIndex + 1)
                 : commandContext.args.length > 0 ? commandContext.args : args;
             const liveRoot = entry.root === "live" ? rootFor() : process.cwd();
-            const { coreNativeOntologyEnabled } = await import("./core-native-family-flag.js");
-            if (!await coreNativeOntologyEnabled()) {
-                const result = runBundledScript({
-                    asset: `${ASSET}${entry.asset}`,
-                    args: forwarded,
-                    cwd: process.cwd(),
-                    ...(entry.root === "live" ? { hqRoot: liveRoot } : {}),
-                });
-                if (result.code !== 0)
-                    process.exitCode = result.code;
-                return;
-            }
             writeResult(entry.run(forwarded, entry.root === "live" ? liveRoot : process.cwd()));
         });
-        describeCoreCommand(command, { execution: "native", asset: `${ASSET}${entry.asset}`, root: entry.root });
+        describeCoreCommand(command, { execution: "native", root: entry.root });
     }
 }
 //# sourceMappingURL=core-ontology-native.js.map

package/dist/commands/core-pipeline-workers-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerCorePipelineWorkerTableCommand(core: Command): void;
+//# sourceMappingURL=core-pipeline-workers-command.d.ts.map