@indigoai-us/hq-cli 5.345.105 → 5.345.107

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

package/dist/commands/core-pipeline-workers-command.js

@@ -0,0 +1,37 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { runBundledScript } from "../utils/run-bundled-script.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { coreNativePipelineEnabled } from "./core-native-pipeline-flag.js";
+import { PIPELINE_WORKER_TABLE_ASSET, pipelineWorkerFallbackArgs, runPipelineWorkerTable, writePipelineWorkerTableResult } from "./core-pipeline-workers-native.js";
+export function registerCorePipelineWorkerTableCommand(core) {
+    const pipeline = core.command("pipeline").description("Pipeline orchestration helpers");
+    const command = pipeline.command("workers")
+        .description("Propose or render the pipeline worker engine table")
+        .helpOption(false)
+        .allowUnknownOption()
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args, _options, current) => {
+        const argv = current.args.length > 0 ? current.args : args;
+        const groupHqRoot = core.opts().hqRoot;
+        if (!await coreNativePipelineEnabled()) {
+            const root = resolveLiveRoot({ hqRoot: groupHqRoot });
+            const result = runBundledScript({
+                asset: PIPELINE_WORKER_TABLE_ASSET,
+                args: pipelineWorkerFallbackArgs(argv, root, process.env),
+                cwd: process.cwd(),
+                hqRoot: root,
+            });
+            if (result.code !== 0)
+                process.exit(result.code);
+            return;
+        }
+        const root = resolveLiveRoot({ hqRoot: groupHqRoot });
+        const result = runPipelineWorkerTable(argv, root);
+        const code = writePipelineWorkerTableResult(result);
+        if (code !== 0)
+            process.exit(code);
+    });
+    describeCoreCommand(command, { execution: "native", asset: PIPELINE_WORKER_TABLE_ASSET, root: "live" });
+}
+//# sourceMappingURL=core-pipeline-workers-command.js.map

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

@@ -0,0 +1,13 @@
+export declare const PIPELINE_WORKER_TABLE_ASSET = "core/scripts/pipeline-worker-table.sh";
+export declare const CORE_NATIVE_PIPELINE_FLAG = "core-native-pipeline";
+type Result = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function pipelineWorkerRoots(argsRoots: string[], root: string, env: NodeJS.ProcessEnv): string[];
+export declare function pipelineWorkerFallbackArgs(args: string[], root: string, env: NodeJS.ProcessEnv): string[];
+export declare function runPipelineWorkerTable(args: string[], root: string, env?: NodeJS.ProcessEnv): Result;
+export declare function writePipelineWorkerTableResult(result: Result): number;
+export {};
+//# sourceMappingURL=core-pipeline-workers-native.d.ts.map