@indigoai-us/hq-cli 5.345.117 → 5.345.119

package/assets/scaffold/core/scripts/pipeline-envelope.sh

@@ -0,0 +1,211 @@
+#!/usr/bin/env bash
+# pipeline-envelope.sh - validate the HQ phase envelope / phase handoff shape,
+# and normalize raw engine replies into a single JSON object.
+#
+# Usage:
+#   pipeline-envelope.sh validate [--kind envelope|handoff] <file|->
+#   pipeline-envelope.sh normalize <file|->
+#
+# validate: exit 0 when valid; otherwise exit 1 and print each problem to
+#   stderr as "missing field: <name>" or "wrong type: <name> (want <type>)".
+#   Unparseable JSON, empty input, a missing file, or a non-object top level
+#   always exit non-zero.
+# normalize: extract one JSON object from a reply that may be wrapped in a
+#   ```json fence or surrounded by prose; print it compactly to stdout.
+#
+# Shapes are documented in .claude/skills/_shared/lane-dispatch-protocol.md §8.
+# Portable to bash 3.2; parsing is done by node.
+
+set -u
+
+usage() {
+  echo "usage: pipeline-envelope.sh validate [--kind envelope|handoff] <file|->" >&2
+  echo "       pipeline-envelope.sh normalize <file|->" >&2
+  exit 2
+}
+
+command -v node >/dev/null 2>&1 || { echo "pipeline-envelope: node required" >&2; exit 2; }
+
+[ $# -ge 1 ] || usage
+cmd="$1"; shift
+kind=""
+case "$cmd" in
+  validate)
+    if [ "${1:-}" = "--kind" ]; then
+      [ $# -ge 2 ] || usage
+      kind="$2"; shift 2
+      case "$kind" in envelope|handoff) ;; *) echo "pipeline-envelope: bad --kind: $kind" >&2; exit 2 ;; esac
+    fi
+    ;;
+  normalize) ;;
+  -h|--help) usage ;;
+  *) usage ;;
+esac
+[ $# -eq 1 ] || usage
+src="$1"
+
+# node reads its program from a heredoc, so stdin must be spooled first.
+if [ "$src" = "-" ]; then
+  spool="$(mktemp "${TMPDIR:-/tmp}/pe-stdin.XXXXXX")" || exit 1
+  trap 'rm -f "$spool"' EXIT
+  cat > "$spool"
+  src="$spool"
+fi
+
+if [ ! -f "$src" ]; then
+  echo "pipeline-envelope: file not found: $src" >&2
+  exit 1
+fi
+
+PE_CMD="$cmd" PE_KIND="$kind" PE_SRC="$src" node - <<'JS'
+'use strict';
+const fs = require('fs');
+const cmd = process.env.PE_CMD; let kind = process.env.PE_KIND; const src = process.env.PE_SRC;
+const err = (m) => process.stderr.write(m + '\n');
+let text;
+try {
+  text = new TextDecoder('utf-8', { fatal: true }).decode(fs.readFileSync(src));
+  if (text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+  text = text.replace(/\r\n?/g, '\n');
+} catch (e) {
+  err('pipeline-envelope: cannot read input: ' + (e && e.message ? e.message : e)); process.exit(1);
+}
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+// Python json.dumps default output: ", " and ": " separators.
+function dumpStr(s, ascii) {
+  let o = JSON.stringify(s);
+  if (ascii) o = o.replace(/[\u0080-￿]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'));
+  return o;
+}
+function dumpNum(n) {
+  if (!Number.isFinite(n)) return n > 0 ? 'Infinity' : n < 0 ? '-Infinity' : 'NaN';
+  if (Number.isInteger(n) && Math.abs(n) < 1e16) return String(n);
+  let s = String(n);
+  const m = /^(-?)(\d)(?:\.(\d+))?e([+-])(\d+)$/.exec(s);
+  if (m) s = m[1] + m[2] + (m[3] ? '.' + m[3] : '') + 'e' + m[4] + m[5].padStart(2, '0');
+  return s;
+}
+function dumps(v, ascii) {
+  if (v === null) return 'null';
+  if (v === true) return 'true';
+  if (v === false) return 'false';
+  if (typeof v === 'number') return dumpNum(v);
+  if (typeof v === 'string') return dumpStr(v, ascii);
+  if (Array.isArray(v)) return '[' + v.map((x) => dumps(x, ascii)).join(', ') + ']';
+  return '{' + Object.keys(v).map((k) => dumpStr(k, ascii) + ': ' + dumps(v[k], ascii)).join(', ') + '}';
+}
+// end index (exclusive) of the balanced {...} starting at j, string-aware; -1 when unbalanced
+function balancedEnd(t, j) {
+  let depth = 0, inStr = false;
+  for (let i = j; i < t.length; i++) {
+    const c = t[i];
+    if (inStr) {
+      if (c === '\\') i++;
+      else if (c === '"') inStr = false;
+      continue;
+    }
+    if (c === '"') inStr = true;
+    else if (c === '{' || c === '[') depth++;
+    else if (c === '}' || c === ']') { depth--; if (depth === 0) return i + 1; if (depth < 0) return -1; }
+  }
+  return -1;
+}
+
+if (cmd === 'normalize') {
+  let cands = [];
+  // 1. fenced blocks first (```json ... ``` or ``` ... ```)
+  const fence = /```[A-Za-z0-9_-]*\s*\n([\s\S]*?)```/g;
+  let m;
+  while ((m = fence.exec(text)) !== null) {
+    try { const v = JSON.parse(m[1].trim()); if (isObj(v)) cands.push(v); } catch (e) { /* skip */ }
+  }
+  // 2. otherwise scan for top-level JSON objects in the prose
+  if (!cands.length) {
+    let i = 0;
+    while (i < text.length) {
+      const j = text.indexOf('{', i);
+      if (j < 0) break;
+      const end = balancedEnd(text, j);
+      let v, ok = false;
+      if (end > 0) { try { v = JSON.parse(text.slice(j, end)); ok = true; } catch (e) { ok = false; } }
+      if (ok) { if (isObj(v)) cands.push(v); i = end; } else i = j + 1;
+    }
+  }
+  if (!cands.length) { err('normalize: no JSON object found'); process.exit(1); }
+  if (cands.length > 1) {
+    // prefer the one carrying a known schema, if exactly one does
+    const tagged = cands.filter((c) => c.schema === 'hq-phase-handoff/v1' || c.schema === 'hq-phase-envelope/v1');
+    if (tagged.length !== 1) { err('normalize: ' + cands.length + ' JSON objects found, expected exactly one'); process.exit(1); }
+    cands = tagged;
+  }
+  process.stdout.write(dumps(cands[0], false) + '\n');
+  process.exit(0);
+}
+
+// ---- validate ----
+if (!text.trim()) { err('invalid: empty input'); process.exit(1); }
+let doc;
+try { doc = JSON.parse(text); } catch (e) { err('invalid: unparseable JSON (' + e.message + ')'); process.exit(1); }
+if (!isObj(doc)) {
+  const tn = doc === null ? 'NoneType' : Array.isArray(doc) ? 'list' : typeof doc === 'string' ? 'str'
+    : typeof doc === 'boolean' ? 'bool' : Number.isInteger(doc) ? 'int' : 'float';
+  err('invalid: top level must be a JSON object, got ' + tn); process.exit(1);
+}
+const has = (k) => Object.prototype.hasOwnProperty.call(doc, k);
+const SCHEMAS = { envelope: 'hq-phase-envelope/v1', handoff: 'hq-phase-handoff/v1' };
+if (!kind) {
+  for (const k of Object.keys(SCHEMAS)) if (doc.schema === SCHEMAS[k]) kind = k;
+  if (!kind) {
+    if (!has('schema')) err('missing field: schema');
+    else err('wrong type: schema (want ' + SCHEMAS.envelope + ' or ' + SCHEMAS.handoff + ')');
+    process.exit(1);
+  }
+}
+const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]00:?00)\n?$/;
+const problems = [];
+const isStr = (v) => typeof v === 'string';
+const isBool = (v) => typeof v === 'boolean';
+const strList = (v) => Array.isArray(v) && v.every(isStr);
+function check(name, ok, want, required = true) {
+  if (!has(name)) { if (required) problems.push('missing field: ' + name); return; }
+  if (!ok(doc[name])) problems.push('wrong type: ' + name + ' (want ' + want + ')');
+}
+const sch = has('schema') ? doc.schema : null;
+if (sch !== null && sch !== SCHEMAS[kind]) problems.push('wrong type: schema (want ' + SCHEMAS[kind] + ')');
+else if (!has('schema')) problems.push('missing field: schema');
+
+const nonEmpty = (v) => isStr(v) && v !== '';
+if (kind === 'envelope') {
+  for (const f of ['story_id', 'phase', 'worker_id']) check(f, nonEmpty, 'non-empty string');
+  check('worktree', nonEmpty, 'string path');
+  check('incoming_handoff', (v) => v === null || nonEmpty(v), 'string path or null');
+  check('acceptance_criteria', strList, 'array of strings');
+  check('deadline', (v) => isStr(v) && ISO.test(v), 'ISO8601 UTC string');
+  check('fresh_call', isBool, 'boolean');
+  for (const f of ['project', 'engine', 'result_path', 'story_title', 'story_description', 'reopen_note', 'repo', 'branch',
+    'prior_handoff']) check(f, isStr, 'string', false);
+  check('resumed_after_interrupt', isBool, 'boolean', false);
+  check('constraints', strList, 'array of strings', false);
+} else {
+  for (const f of ['story_id', 'phase', 'worker_id']) check(f, nonEmpty, 'non-empty string');
+  check('status', (v) => v === 'passed' || v === 'failed' || v === 'blocked', 'one of passed|failed|blocked');
+  check('summary', isStr, 'string');
+  check('files_changed', strList, 'array of strings');
+  check('commits', strList, 'array of strings');
+  if (!has('back_pressure')) problems.push('missing field: back_pressure');
+  else if (!isObj(doc.back_pressure)) problems.push('wrong type: back_pressure (want object)');
+  else {
+    const bp = doc.back_pressure;
+    for (const g of ['tests', 'lint', 'typecheck', 'build']) {
+      if (!Object.prototype.hasOwnProperty.call(bp, g)) problems.push('missing field: back_pressure.' + g);
+      else if (!['pass', 'fail', 'skip'].includes(bp[g])) problems.push('wrong type: back_pressure.' + g + ' (want one of pass|fail|skip)');
+    }
+  }
+  check('context_for_next', isStr, 'string');
+  for (const f of ['engine', 'notes']) check(f, isStr, 'string', false);
+}
+if (problems.length) { for (const p of problems) err(p); process.exit(1); }
+process.stdout.write('valid ' + kind + '\n');
+process.exit(0);
+JS

package/dist/command-catalog.generated.d.ts

@@ -8626,6 +8626,40 @@ export declare const COMMAND_CATALOG: readonly [{
             }];
             readonly options: readonly [];
             readonly subcommands: readonly [];
+        }, {
+            readonly name: "conductor";
+            readonly description: "Route and supervise pipeline stories";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly helpOption: false;
+            readonly helpCommand: false;
+            readonly usage: "[args...]";
+            readonly helpText: readonly [];
+            readonly arguments: readonly [{
+                readonly name: "args";
+                readonly required: false;
+                readonly variadic: true;
+                readonly description: "";
+            }];
+            readonly options: readonly [];
+            readonly subcommands: readonly [];
+        }, {
+            readonly name: "driver";
+            readonly description: "Run the detached pipeline queue driver";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly helpOption: false;
+            readonly helpCommand: false;
+            readonly usage: "[args...]";
+            readonly helpText: readonly [];
+            readonly arguments: readonly [{
+                readonly name: "args";
+                readonly required: false;
+                readonly variadic: true;
+                readonly description: "";
+            }];
+            readonly options: readonly [];
+            readonly subcommands: readonly [];
         }];
     }, {
         readonly name: "resolve-company";

package/dist/command-catalog.generated.js

@@ -10482,6 +10482,46 @@ export const COMMAND_CATALOG = [
                         ],
                         "options": [],
                         "subcommands": []
+                    },
+                    {
+                        "name": "conductor",
+                        "description": "Route and supervise pipeline stories",
+                        "aliases": [],
+                        "hidden": false,
+                        "helpOption": false,
+                        "helpCommand": false,
+                        "usage": "[args...]",
+                        "helpText": [],
+                        "arguments": [
+                            {
+                                "name": "args",
+                                "required": false,
+                                "variadic": true,
+                                "description": ""
+                            }
+                        ],
+                        "options": [],
+                        "subcommands": []
+                    },
+                    {
+                        "name": "driver",
+                        "description": "Run the detached pipeline queue driver",
+                        "aliases": [],
+                        "hidden": false,
+                        "helpOption": false,
+                        "helpCommand": false,
+                        "usage": "[args...]",
+                        "helpText": [],
+                        "arguments": [
+                            {
+                                "name": "args",
+                                "required": false,
+                                "variadic": true,
+                                "description": ""
+                            }
+                        ],
+                        "options": [],
+                        "subcommands": []
                     }
                 ]
             },

package/dist/commands/core-checkpoint-native.d.ts

@@ -8,6 +8,11 @@
  */
 import * as fs from "node:fs";
 import { Command } from "commander";
+/**
+ * A run without a report older than this no longer counts as a crash. A
+ * transient failure (a DNS blip, a brief outage) must not pin the choice.
+ */
+export declare const CRASHED_RUN_MAX_AGE_MS: number;
 /**
  * Wall-clock cap on one sibling run. The supervisor kills the sibling and its
  * descendants at this point. It stays under the lock TTL so a capped run
@@ -59,11 +64,20 @@ export type WriteStampsOptions = {
     waitForRetry?: (delayMs: number) => void;
 };
 export declare function writeStamps(liveRoot: string, sessionId: string | undefined, options?: WriteStampsOptions): string[];
+/**
+ * Backends whose most recent run died without producing a report.
+ *
+ * A version probe cannot catch a backend that starts cleanly and then fails at
+ * runtime — an expired login, a sandbox it cannot write in, a model it is not
+ * entitled to. The evidence for that is a finished run directory with no
+ * report.md in it, so prefer a different backend for the next checkpoint. Only
+ * the newest run per backend counts: one that has since succeeded is healthy.
+ */
+export declare function crashedBackends(siblingRoot: string, now?: number): Set<string>;
 /**
  * Preference order for `--backend auto`: the caller's own backend first, so a
- * claude session keeps using claude and a codex session keeps using codex
- * (same-engine continuity), then the fallback priority claude -> codex -> grok
- * for whatever the caller is not. Deterministic and env-only, so it is unit
+ * claude session keeps using claude, then the fallback priority claude -> grok.
+ * Codex is never in this list: it runs only when explicitly requested. Deterministic and env-only, so it is unit
  * tested directly. `preferGrok` (the company's grok-backend flag) puts grok
  * ahead of that order and leaves the rest as the fallback.
  */

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

@@ -58,7 +58,19 @@ const SIBLING_SETTING = "HQ_CHECKPOINT_AGENT";
 const GATE_SETTING = "HQ_CHECKPOINT_GATE";
 const SIBLING_SETTING_OFF = new Set(["0", "false", "off", "no"]);
 const SIBLING_SETTING_ON = new Set(["1", "true", "on", "yes"]);
-const FALLBACK_BACKEND_ORDER = ["claude", "codex", "grok"];
+/**
+ * Backends `--backend auto` may pick on its own. Codex is deliberately absent:
+ * it runs only when an operator names it (`--backend codex` or
+ * HQ_CHECKPOINT_BACKEND=codex).
+ */
+const FALLBACK_BACKEND_ORDER = ["claude", "grok"];
+/** Operator setting that replaces `--backend auto` with a named backend. */
+const BACKEND_SETTING = "HQ_CHECKPOINT_BACKEND";
+/**
+ * A run without a report older than this no longer counts as a crash. A
+ * transient failure (a DNS blip, a brief outage) must not pin the choice.
+ */
+export const CRASHED_RUN_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 /** A backend that cannot answer `--version` this fast is treated as broken. */
 const BACKEND_PROBE_TIMEOUT_MS = 10_000;
 /** A sibling still holding the lock after this long is treated as abandoned. */
@@ -626,7 +638,7 @@ function processAlive(pid) {
  * report.md in it, so prefer a different backend for the next checkpoint. Only
  * the newest run per backend counts: one that has since succeeded is healthy.
  */
-function crashedBackends(siblingRoot) {
+export function crashedBackends(siblingRoot, now = Date.now()) {
     const crashed = new Set();
     let runDirs;
     try {
@@ -655,6 +667,14 @@ function crashedBackends(siblingRoot) {
         seen.add(backend);
         if (fs.existsSync(path.join(absolute, "report.md")))
             continue;
+        // Old failures expire so one transient crash cannot pin the choice.
+        try {
+            if (now - fs.statSync(path.join(absolute, "payload.json")).mtimeMs > CRASHED_RUN_MAX_AGE_MS)
+                continue;
+        }
+        catch {
+            continue;
+        }
         // A missing report only means a crash once the process itself is gone.
         let pid = Number.NaN;
         try {
@@ -680,13 +700,13 @@ function crashedBackends(siblingRoot) {
  */
 function callerBackend() {
     const runtime = checkpointGateRuntime();
-    return runtime === "claude" || runtime === "codex" ? runtime : null;
+    // A codex caller does not pull the sibling onto codex: codex is opt-in only.
+    return runtime === "claude" ? runtime : null;
 }
 /**
  * Preference order for `--backend auto`: the caller's own backend first, so a
- * claude session keeps using claude and a codex session keeps using codex
- * (same-engine continuity), then the fallback priority claude -> codex -> grok
- * for whatever the caller is not. Deterministic and env-only, so it is unit
+ * claude session keeps using claude, then the fallback priority claude -> grok.
+ * Codex is never in this list: it runs only when explicitly requested. Deterministic and env-only, so it is unit
  * tested directly. `preferGrok` (the company's grok-backend flag) puts grok
  * ahead of that order and leaves the rest as the fallback.
  */
@@ -807,14 +827,34 @@ function assertKnownBackend(requested) {
         usage(`checkpoint: unknown backend: ${value}`);
     return value;
 }
+/** HQ_CHECKPOINT_BACKEND from the environment, then the HQ settings file. */
+function backendSetting(liveRoot) {
+    const fromEnv = process.env[BACKEND_SETTING]?.trim().toLowerCase();
+    if (fromEnv)
+        return fromEnv;
+    const lookup = settingsEnvValue(liveRoot, BACKEND_SETTING);
+    return lookup.kind === "value" ? lookup.value.trim().toLowerCase() || undefined : undefined;
+}
 async function resolveBackend(requested, liveRoot, company) {
-    const value = assertKnownBackend(requested);
+    let value = assertKnownBackend(requested);
+    if (value === "auto") {
+        const setting = backendSetting(liveRoot);
+        if (setting && setting !== "auto") {
+            if (BACKENDS.has(setting))
+                value = setting;
+            else
+                printError(`checkpoint: ignoring ${BACKEND_SETTING}=${setting} (expected auto, claude, codex, grok or none)`);
+        }
+    }
     // An explicitly named backend is honoured as given; only `auto` shops around.
     if (value !== "auto")
         return value;
     const available = autoBackendPreference(await companyPrefersGrok(liveRoot, company)).filter((name) => backendOnPath(name) && backendResponds(name));
-    if (available.length === 0)
+    if (available.length === 0) {
+        printError("checkpoint: sibling skipped: no allowed backend available (claude, grok); " +
+            `codex runs only with --backend codex or ${BACKEND_SETTING}=codex`);
         return "none";
+    }
     const crashed = crashedBackends(path.join(liveRoot, "workspace", "checkpoints", "sibling"));
     // If every candidate failed last time, still try the preferred one: a stale
     // failure is a weaker signal than running no maintenance sibling at all.

package/dist/commands/core-derive-trigger-facts-native.js

@@ -6,11 +6,13 @@ import { isByteOrientedLocale } from "../lib/core-utils/byte-oriented-locale.js"
 export const DERIVE_TRIGGER_FACTS_ASSET = "core/scripts/derive-trigger-facts.sh";
 const TRANSCRIPT_TAIL_MAX_BYTES = 1_048_576;
 function effectiveEnvironment(options) {
+    const environment = { ...process.env, ...(options.env ?? {}) };
     return {
-        ...process.env,
-        ...(options.env ?? {}),
+        ...environment,
         HQ_ROOT: options.hqRoot,
-        CLAUDE_PROJECT_DIR: options.hqRoot,
+        // HQ_ROOT locates session metadata; the shell still uses its project cwd
+        // independently for repo and branch facts.
+        CLAUDE_PROJECT_DIR: environment.CLAUDE_PROJECT_DIR || options.cwd,
     };
 }
 class ShellFallbackRequired extends Error {
@@ -457,6 +459,7 @@ function computeOutput(options) {
     // fact (plus any static session facts); it does not validate the event.
     const paired = withAssistantIntent && (event === "PreToolUse" || event === "UserPromptSubmit");
     const env = effectiveEnvironment(options);
+    const initialEnv = { ...process.env, ...(options.env ?? {}) };
     const jqAvailable = options.jqAvailable ?? commandOnPath("jq", env);
     let payload = {
         tool: "", command: "", runInBackground: "", toolResponse: "", prompt: "",
@@ -464,8 +467,8 @@ function computeOutput(options) {
     };
     if (jqAvailable)
         payload = parsePayload(options.stdin || "{}");
-    const payloadCwd = payload.cwd || env.CLAUDE_PROJECT_DIR || options.hqRoot;
-    const company = resolveCompanyFact(payload.cwd, payload.sessionId, options.hqRoot, options.hqRoot, env);
+    const payloadCwd = payload.cwd || env.CLAUDE_PROJECT_DIR || options.cwd;
+    const company = resolveCompanyFact(payload.cwd, payload.sessionId, options.hqRoot, options.cwd, env);
     const derive = (kind) => {
         const facts = ["always"];
         let branch = "";
@@ -508,7 +511,12 @@ function computeOutput(options) {
             }
         }
         else {
-            if (payloadCwd.includes("repos/public/") || payloadCwd.includes("repos/private/"))
+            // Bash's PWD is slash-separated on Git Bash even though Node receives a
+            // Windows cwd with backslashes. But explicit payload/environment paths
+            // reach the shell unchanged, so normalize only the PWD fallback.
+            const usesPwdFallback = !payload.cwd && !initialEnv.CLAUDE_PROJECT_DIR;
+            const shellCwd = usesPwdFallback ? payloadCwd.replaceAll("\\", "/") : payloadCwd;
+            if (shellCwd.includes("repos/public/") || shellCwd.includes("repos/private/"))
                 facts.push("repo");
             branch = options.gitBranch ?? readBranch(payloadCwd, env);
         }
@@ -607,6 +615,6 @@ export function runDeriveTriggerFactsFastResult(argv, stdin, cwd, hqRoot) {
             stderr: result.stderr ?? Buffer.alloc(0),
         };
     }
-    return runDeriveTriggerFacts({ argv, stdin, cwd, hqRoot: hqRoot ?? cwd });
+    return runDeriveTriggerFacts({ argv, stdin, cwd, hqRoot: hqRoot ?? (process.env.HQ_ROOT?.trim() || cwd) });
 }
 //# sourceMappingURL=core-derive-trigger-facts-native.js.map

package/dist/commands/core-migrate-policy-triggers-native.js

@@ -245,7 +245,9 @@ export function runMigratePolicyTriggers(args, deps) {
         if (bypass)
             return false;
         try {
-            const last = fileSystem.readFileSync(stamp, "utf8");
+            // Bash command substitution strips trailing LF bytes before validating
+            // the decimal value. The shell writes one newline in every stamp.
+            const last = fileSystem.readFileSync(stamp, "utf8").replace(/\n+$/, "");
             if (!/^\d+$/.test(last)) {
                 stderr += `migrate-policy-triggers: cooldown stamp is unreadable; running\n`;
                 return false;

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

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+export declare const PIPELINE_CONDUCTOR_ASSET = "core/scripts/pipeline-conductor.sh";
+export declare const PIPELINE_DRIVER_ASSET = "core/scripts/pipeline-driver.sh";
+export declare function registerCorePipelineRuntimeCommands(core: Command): void;
+//# sourceMappingURL=core-pipeline-conductor-command.d.ts.map