@indigoai-us/hq-cli 5.345.106 → 5.345.108

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

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

@@ -0,0 +1,361 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const PIPELINE_WORKER_TABLE_ASSET = "core/scripts/pipeline-worker-table.sh";
+export const CORE_NATIVE_PIPELINE_FLAG = "core-native-pipeline";
+const USAGE = "# pipeline-worker-table.sh — the per-worker engine/model table behind\n# /run-project --pipeline.\n#\n# Each worker lane runs on its own engine and model. This script proposes that\n# table from a prd.json and, once the owner has confirmed it, turns it into the\n# launcher exports each lane starts with. It never reads an engine or model\n# default from a settings file (orchestrator.yaml, settings.json, ...): the only\n# seed is each worker's own worker.yaml, and anything that cannot be read off\n# it is left empty and flagged for the owner to answer.\n#\n# Usage:\n#   pipeline-worker-table.sh [--workers-root <dir>]... [--overlay <file>] <prd.json>\n#   pipeline-worker-table.sh [--workers-root <dir>]... [--overlay <file>] --confirmed <table.tsv> <prd.json>\n#\n# PROPOSE MODE (no --confirmed) prints tab-separated lines:\n#\n#   row   <worker> <engine> <model> <effort> <status> <stories> <note>\n#   hint  <worker> <story>  <model>\n#   unclassified <story>\n#\n#   status is `ok` or `needs-answer`. The lane set is the union of every\n#   story's worker sequence: one `row` per distinct worker that appears in any\n#   sequence (architect and qa-tester included), in first-seen order. A `hint`\n#   line is a story's model_hint, shown for the owner; a confirmed table pin wins\n#   over it (see CONFIRMED MODE).\n#\n# WORKER SEQUENCE (story -> workers, the full phase sequence in order), first\n# match wins; pipeline-conductor.sh classify reads the same three sources:\n#   1. --overlay <file> (the run's <state>/overlay.json, or the preflight plan):\n#      {id: {\"worker_sequence\": [...]}}, {id: [...]}, or\n#      {\"ordered_stories\": [{\"id\": .., \"worker_sequence\": [...]}]}.\n#   2. worker_preference — a string or an array of worker ids, used as given.\n#   3. Fallback, only when both are empty: the keyword table from\n#      .claude/skills/execute-task/SKILL.md step 3, matched case-insensitively\n#      against title + description + labels:\n#        schema_change   (database|migration|schema|prisma|sql)   -> database-dev\n#        ui_component    (component|page|form|button|react|ui)    -> frontend-dev\n#        api_development (endpoint|api|rest|graphql|route|service) -> backend-dev\n#      giving architect, the matched implementers (backend-dev also for a\n#      schema change), then qa-tester.\n#      A story matching none is printed as `unclassified`; no worker is guessed.\n#\n# UNKNOWN WORKERS: a worker with no worker.yaml under the worker roots gets an\n# empty, needs-answer row noted \"no worker.yaml\", and a line on stderr naming\n# the id, the roots searched and every known id. pipeline-conductor.sh classify\n# refuses such a worker before launch.\n#\n# ENGINE SEED (from worker.yaml `execution:`):\n#   model only        -> engine claude, model = execution.model\n#   codex_model only  -> engine codex,  model = execution.codex_model,\n#                        effort = `--reasoning <x>` from execution.codex_flags\n#   both set          -> ambiguous: engine and model empty, needs-answer, the\n#                        candidates listed in the note column\n#   neither / no file -> engine and model empty, needs-answer\n#   worker.yaml has no grok field, so grok is never seeded; the owner chooses it\n#   in the confirmed table.\n#\n# CONFIRMED MODE: --confirmed <file> holds one lane per line,\n#   <worker> <engine> <model> <effort>   (tabs or spaces; # comments allowed;\n#   effort may be omitted). engine must be claude, codex, or grok and model must\n#   be non-empty, or the script exits 2. Output per lane, using the pins in\n#   core/scripts/workflow-runner.mjs, plus HQ_CONDUCT_ENGINE=<engine> for\n#   every lane (a loop lane runs pipeline phase envelopes on that engine):\n#     claude      -> HQ_WORKFLOW_CLAUDE_PLAN_MODEL, HQ_WORKFLOW_CLAUDE_EXEC_MODEL,\n#                    HQ_WORKFLOW_CLAUDE_EFFORT\n#     codex|grok  -> HQ_WORKFLOW_MODEL, HQ_WORKFLOW_EFFORT\n#   The effort export is omitted when effort is empty (runner default applies).\n#   A story's model_hint never overrides the lane: the lane's table pin wins.\n#   Each hinted story on a confirmed lane gets a `# lane <w> story <id>\n#   (model_hint)` block whose exports are commented out and that says \"hint\n#   ignored, table pins <model>\". A bare alias (opus, sonnet, haiku, fable) is\n#   never printed as a model.\n#\n# Worker roots: --workers-root (repeatable) or PIPELINE_WORKERS_ROOTS\n# (colon-separated). Default: <hq>/core/workers, <hq>/companies/*/workers,\n# <hq>/personal/workers. A worker is the directory named <id> holding worker.yaml.\n#\n# POSIX sh (dash-clean); JSON work is done by jq.\n";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+function sequence(value) {
+    if (Array.isArray(value))
+        return value.filter((item) => typeof item === "string" && item.length > 0);
+    if (typeof value === "string")
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    if (isRecord(value))
+        return sequence(value.worker_sequence ?? []);
+    return [];
+}
+function asciiLower(text) {
+    return text.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+function storyText(story) {
+    const title = story.title ?? "";
+    const description = story.description ?? "";
+    const labels = Array.isArray(story.labels) ? story.labels.join(" ") : "";
+    return asciiLower([stringValue(title === "" ? "" : title), stringValue(description === "" ? "" : description), labels].join(" "));
+}
+const WORD = {
+    schema: /\b(database|migration|schema|prisma|sql)\b/,
+    ui: /\b(component|page|form|button|react|ui)\b/,
+    api: /\b(endpoint|api|rest|graphql|route|service)\b/,
+};
+function fallbackSequence(story) {
+    const text = storyText(story);
+    const schema = WORD.schema.test(text);
+    const ui = WORD.ui.test(text);
+    const api = WORD.api.test(text);
+    if (!schema && !ui && !api)
+        return [];
+    return [
+        "architect",
+        ...(schema ? ["database-dev"] : []),
+        ...(api || schema ? ["backend-dev"] : []),
+        ...(ui ? ["frontend-dev"] : []),
+        "qa-tester",
+    ];
+}
+function storyId(story) {
+    return story.id === null || story.id === undefined ? "" : stringValue(story.id);
+}
+function deriveSequences(stories, overlay) {
+    const overrides = {};
+    if (Array.isArray(overlay.ordered_stories)) {
+        for (const row of overlay.ordered_stories) {
+            if (isRecord(row) && typeof row.id === "string")
+                overrides[row.id] = sequence(row.worker_sequence ?? []);
+        }
+    }
+    else {
+        for (const [id, value] of Object.entries(overlay))
+            overrides[id] = sequence(value);
+    }
+    return stories.map((story) => {
+        const id = storyId(story);
+        const override = overrides[id] ?? [];
+        const preferred = sequence(story.worker_preference ?? []);
+        const workers = override.length > 0 ? override : preferred.length > 0 ? preferred : fallbackSequence(story);
+        return { id, workers, story };
+    });
+}
+function parseArgs(args) {
+    const roots = [];
+    let confirmed = "";
+    let overlay = "";
+    let prd = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--workers-root" || arg === "--confirmed" || arg === "--overlay") {
+            const value = args[i + 1];
+            if (value === undefined)
+                return `${arg} needs ${arg === "--workers-root" ? "a dir" : "a file"}`;
+            if (arg === "--workers-root")
+                roots.push(value);
+            if (arg === "--confirmed")
+                confirmed = value;
+            if (arg === "--overlay")
+                overlay = value;
+            i += 1;
+        }
+        else if (arg === "-h" || arg === "--help") {
+            return { roots, confirmed, overlay, prd, help: true };
+        }
+        else if (arg.startsWith("-")) {
+            return `unknown flag: ${arg}`;
+        }
+        else if (!prd) {
+            prd = arg;
+        }
+        else {
+            return "only one prd.json";
+        }
+    }
+    if (!prd)
+        return "usage: pipeline-worker-table.sh [--workers-root <dir>] [--overlay <file>] [--confirmed <table.tsv>] <prd.json>";
+    return { roots, confirmed, overlay, prd, help: false };
+}
+function readJson(file) {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+export function pipelineWorkerRoots(argsRoots, root, env) {
+    if (argsRoots.length > 0)
+        return argsRoots;
+    if (env.PIPELINE_WORKERS_ROOTS !== undefined)
+        return env.PIPELINE_WORKERS_ROOTS.split(":");
+    const roots = [path.join(root, "core/workers")];
+    const companies = path.join(root, "companies");
+    try {
+        for (const name of fs.readdirSync(companies).sort()) {
+            const workers = path.join(companies, name, "workers");
+            try {
+                if (fs.statSync(workers).isDirectory())
+                    roots.push(workers);
+            }
+            catch { /* shell skips missing company worker roots */ }
+        }
+    }
+    catch { /* shell glob has no matches when companies is absent */ }
+    roots.push(path.join(root, "personal/workers"));
+    return roots;
+}
+export function pipelineWorkerFallbackArgs(args, root, env) {
+    if (args.includes("--workers-root") || env.PIPELINE_WORKERS_ROOTS !== undefined)
+        return args;
+    const roots = pipelineWorkerRoots([], root, env);
+    return [...roots.flatMap((workerRoot) => ["--workers-root", workerRoot]), ...args];
+}
+function listWorkerYaml(root) {
+    const results = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (let i = entries.length - 1; i >= 0; i -= 1) {
+            const entry = entries[i];
+            const file = path.join(current, entry.name);
+            if (entry.isDirectory())
+                stack.push(file);
+            else if (entry.isFile() && entry.name === "worker.yaml")
+                results.push(file);
+        }
+    }
+    return results;
+}
+function findWorkerYaml(worker, roots) {
+    for (const root of roots) {
+        for (const file of listWorkerYaml(root)) {
+            if (path.basename(path.dirname(file)) === worker)
+                return file;
+        }
+    }
+    return undefined;
+}
+function knownWorkers(roots) {
+    return [...new Set(roots.flatMap((root) => listWorkerYaml(root).map((file) => path.basename(path.dirname(file)))))].sort();
+}
+function executionField(file, key) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+    let inExecution = false;
+    for (const line of text.split(/\r?\n/)) {
+        if (/^[^\s#]/.test(line)) {
+            inExecution = /^execution:\s*$/.test(line);
+            continue;
+        }
+        if (!inExecution)
+            continue;
+        const match = new RegExp(`^[\\t ]+${key}:[\\t ]*(.*)$`).exec(line);
+        if (!match)
+            continue;
+        let value = match[1].replace(/[\t ]+#.*$/, "").replace(/[\t ]+$/, "");
+        if (value.startsWith("\"") || value.startsWith("'"))
+            value = value.slice(1);
+        if (value.endsWith("\"") || value.endsWith("'"))
+            value = value.slice(0, -1);
+        return value;
+    }
+    return "";
+}
+function quoteShell(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function emitExports(engine, model, effort, prefix = "") {
+    let output = `${prefix}export HQ_CONDUCT_ENGINE=${quoteShell(engine)}\n`;
+    if (engine === "claude") {
+        output += `${prefix}export HQ_WORKFLOW_CLAUDE_PLAN_MODEL=${quoteShell(model)}\n`;
+        output += `${prefix}export HQ_WORKFLOW_CLAUDE_EXEC_MODEL=${quoteShell(model)}\n`;
+        if (effort)
+            output += `${prefix}export HQ_WORKFLOW_CLAUDE_EFFORT=${quoteShell(effort)}\n`;
+    }
+    else if (engine === "codex" || engine === "grok") {
+        output += `${prefix}export HQ_WORKFLOW_MODEL=${quoteShell(model)}\n`;
+        if (effort)
+            output += `${prefix}export HQ_WORKFLOW_EFFORT=${quoteShell(effort)}\n`;
+    }
+    return output;
+}
+function bareAlias(hint) {
+    return ["opus", "sonnet", "haiku", "fable", "Opus", "Sonnet", "Haiku", "Fable"].includes(hint);
+}
+function confirmedOutput(file, stories, sequences) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return { code: 1, stdout: "", stderr: `pipeline-worker-table: no such confirmed table: ${file}\n` };
+    }
+    let stdout = "";
+    for (const line of text.split(/\r?\n/)) {
+        const columns = line.trim().split(/\s+/);
+        if (!columns[0] || columns[0].startsWith("#") || columns[0] === "worker")
+            continue;
+        const [worker, engine, model, effort = ""] = columns;
+        if (!(engine === "claude" || engine === "codex" || engine === "grok")) {
+            return { code: 2, stdout: "", stderr: `pipeline-worker-table: lane ${worker}: engine must be claude, codex, or grok (got '${engine ?? ""}')\n` };
+        }
+        if (!model)
+            return { code: 2, stdout: "", stderr: `pipeline-worker-table: lane ${worker}: model is empty — answer it before launch\n` };
+        stdout += `# lane ${worker} (${engine})\n${emitExports(engine, model, effort)}`;
+        for (const story of stories) {
+            const id = storyId(story);
+            const hint = story.model_hint !== null && story.model_hint !== undefined && story.model_hint !== "" ? stringValue(story.model_hint) : "";
+            if (!hint || !sequences.some((row) => row.id === id && row.workers.includes(worker)))
+                continue;
+            if (bareAlias(hint))
+                stdout += `# lane ${worker} story ${id} (model_hint) bare alias ignored, table pins ${model}\n`;
+            else {
+                stdout += `# lane ${worker} story ${id} (model_hint) hint ignored, table pins ${model}\n`;
+                stdout += emitExports(engine, hint, effort, "# ");
+            }
+        }
+    }
+    return { code: 0, stdout, stderr: "" };
+}
+export function runPipelineWorkerTable(args, root, env = process.env) {
+    const parsed = parseArgs(args);
+    if (typeof parsed === "string")
+        return { code: parsed.startsWith("usage:") ? 1 : 1, stdout: "", stderr: `pipeline-worker-table: ${parsed}\n` };
+    if (parsed.help)
+        return { code: 0, stdout: USAGE, stderr: "" };
+    let prd;
+    try {
+        prd = readJson(parsed.prd);
+    }
+    catch {
+        return { code: 1, stdout: "", stderr: `pipeline-worker-table: not a prd (no userStories array): ${parsed.prd}\n` };
+    }
+    if (!isRecord(prd) || !Array.isArray(prd.userStories))
+        return { code: 1, stdout: "", stderr: `pipeline-worker-table: not a prd (no userStories array): ${parsed.prd}\n` };
+    let overlay = {};
+    if (parsed.overlay) {
+        try {
+            overlay = readJson(parsed.overlay);
+        }
+        catch {
+            return { code: 1, stdout: "", stderr: `pipeline-worker-table: overlay is not a JSON object: ${parsed.overlay}\n` };
+        }
+        if (!isRecord(overlay))
+            return { code: 1, stdout: "", stderr: `pipeline-worker-table: overlay is not a JSON object: ${parsed.overlay}\n` };
+    }
+    if (parsed.confirmed) {
+        if (!fs.existsSync(parsed.confirmed))
+            return { code: 1, stdout: "", stderr: `pipeline-worker-table: no such confirmed table: ${parsed.confirmed}\n` };
+        return confirmedOutput(parsed.confirmed, prd.userStories, deriveSequences(prd.userStories, overlay));
+    }
+    const roots = pipelineWorkerRoots(parsed.roots, root, env);
+    const sequences = deriveSequences(prd.userStories, overlay);
+    const workers = [];
+    const seen = new Set();
+    for (const row of sequences)
+        for (const worker of row.workers)
+            if (!seen.has(worker)) {
+                seen.add(worker);
+                workers.push(worker);
+            }
+    let stdout = "";
+    let stderr = "";
+    for (const row of sequences)
+        if (row.workers.length === 0)
+            stdout += `unclassified\t${row.id}\n`;
+    for (const worker of workers) {
+        const file = findWorkerYaml(worker, roots);
+        let engine = "";
+        let model = "";
+        let effort = "";
+        let status = "needs-answer";
+        let note = "";
+        if (!file) {
+            note = "no worker.yaml";
+            const rootText = roots.join(" ");
+            const known = knownWorkers(roots).join(" ") || "none";
+            stderr += `pipeline-worker-table: unknown worker ${worker}: no worker.yaml under ${rootText}; known: ${known}\n`;
+        }
+        else {
+            const claudeModel = executionField(file, "model");
+            const codexModel = executionField(file, "codex_model");
+            if (claudeModel && codexModel)
+                note = `ambiguous: claude:${claudeModel} codex:${codexModel}`;
+            else if (claudeModel) {
+                engine = "claude";
+                model = claudeModel;
+                status = "ok";
+            }
+            else if (codexModel) {
+                engine = "codex";
+                model = codexModel;
+                status = "ok";
+                const flags = executionField(file, "codex_flags");
+                effort = /.*--reasoning[= ]([A-Za-z]*).*/.exec(flags)?.[1] ?? "";
+            }
+            else
+                note = "no execution.model or execution.codex_model";
+        }
+        const storiesText = sequences.filter((row) => row.workers.includes(worker)).map((row) => row.id).join(" ");
+        stdout += `row\t${worker}\t${engine}\t${model}\t${effort}\t${status}\t${storiesText}\t${note}\n`;
+    }
+    for (const story of prd.userStories) {
+        const hint = story.model_hint !== null && story.model_hint !== undefined && story.model_hint !== "" ? stringValue(story.model_hint) : "";
+        if (!hint)
+            continue;
+        const id = storyId(story);
+        for (const worker of sequences.find((row) => row.id === id)?.workers ?? [])
+            stdout += `hint\t${worker}\t${id}\t${hint}\n`;
+    }
+    return { code: 0, stdout, stderr };
+}
+export function writePipelineWorkerTableResult(result) {
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-pipeline-workers-native.js.map

package/dist/commands/core.js

@@ -50,6 +50,7 @@ import { registerCoreDeriveTriggerFactsCommand } from "./core-derive-trigger-fac
 import { DERIVE_TRIGGER_FACTS_ASSET } from "./core-derive-trigger-facts-native.js";
 import { registerCoreHookStateHelpers } from "./core-hook-state-helpers-native.js";
 import { registerCoreHookBatchCommand } from "./core-hook-batch-command.js";
+import { registerCorePipelineWorkerTableCommand } from "./core-pipeline-workers-command.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";
 import { CompanyIndexUserError, renderIndexTarget } from "../lib/index-render/index.js";
@@ -218,6 +219,12 @@ export const REBUILD_INDEX_TARGETS = [
  * would make the forwarders harder to audit against this table.
  */
 export const SCAFFOLD_COMMANDS = [
+    {
+        name: "hq-task",
+        asset: "core/scripts/hq-task.sh",
+        root: "live",
+        summary: "List and update tasks on personal or company boards",
+    },
     // Session/harness plumbing relocated out of the HQ tree so a single published
     // CLI owns it. Both are `root: "live"`: they read and write the live HQ tree
     // (workspace/sessions, companies/, workspace/orchestrator/hook-state), so the
@@ -243,6 +250,7 @@ export const SCAFFOLD_COMMANDS = [
  * direct `hq core` command.
  */
 export const SCAFFOLD_ONLY_ASSETS = [
+    { asset: "core/scripts/hq-task.mjs", root: "live", summary: "Sibling implementation used by the hq-task shell rollback companion" },
     { asset: "core/scripts/session-journal.sh", root: "live", summary: "Rollback companion for native session journal" },
     { asset: "core/scripts/session-project.sh", root: "live", summary: "Rollback companion for native session project" },
     { asset: "core/scripts/session-title.sh", root: "live", summary: "Rollback companion for native session title" },
@@ -255,6 +263,7 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/hq-job-run.sh", root: "live", summary: "Scheduled jobs runner used by generated systemd units" },
     { asset: "core/scripts/hq-job-notify.sh", root: "live", summary: "Scheduled jobs failure notification helper" },
     { asset: "core/scripts/hq-job-remediate.sh", root: "live", summary: "Scheduled jobs bounded remediation helper" },
+    { asset: "core/scripts/pipeline-worker-table.sh", root: "live", summary: "Rollback companion for native pipeline worker-table" },
     { asset: "core/scripts/hq-dm-bind.sh", root: "live", summary: "Rollback shell for native dm-bind" },
     { asset: "core/scripts/work-mesh-live-bind-trusted.sh", root: "live", summary: "Rollback shell for native work-mesh-bind-trusted" },
     { asset: "core/scripts/share-suggestion-state.sh", root: "live", summary: "Rollback shell for native share-suggestion-state" },
@@ -295,16 +304,8 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/hq-delegate-send.sh", root: "live", summary: "Rollback shell for native delegate send" },
     { asset: "core/scripts/hq-delegate-verify.sh", root: "live", summary: "Rollback shell for native delegate verify" },
     { asset: "core/scripts/lib/secret-patterns.sh", root: "live", summary: "Secret-pattern library sourced by the delegate rollback shells" },
-    // Retained rollback companions for the gated native ontology commands. These
-    // are loose HQ-tree assets, but `hq core ontology` dispatches natively.
-    { asset: "core/scripts/ontology-audience-grant.sh", root: "live", summary: "Rollback companion for native ontology audience grant" },
-    { asset: "core/scripts/ontology-brief.mjs", root: "live", summary: "Rollback companion for native ontology brief" },
-    { asset: "core/scripts/ontology-candidate.sh", root: "live", summary: "Rollback companion for native ontology candidate" },
-    { asset: "core/scripts/ontology-garden.mjs", root: "live", summary: "Rollback companion for native ontology garden" },
-    { asset: "core/scripts/ontology-source-worklist.sh", root: "live", summary: "Rollback companion for native ontology source worklist" },
-    { asset: "core/scripts/source-yaml-validate.sh", root: "cwd", summary: "Rollback companion for native source YAML validation" },
-    // Shared by native knowledge-prefs and the ontology candidate shell fallback.
-    { asset: "core/scripts/knowledge-prefs.sh", root: "live", summary: "Sibling dependency for ontology candidate rollback companion" },
+    // Native knowledge-prefs retains its own shell companion until its family PR.
+    { asset: "core/scripts/knowledge-prefs.sh", root: "live", summary: "Rollback companion for native knowledge-prefs" },
     // Rollback companions for the default-off native knowledge and policy routes.
     // policy-retire also runs the scaffold validator in-process when native, but
     // its bundled shell fallback needs both helper assets at these exact paths.
@@ -412,6 +413,7 @@ export function registerCoreCommands(program) {
     registerCoreKnowledgePrefsCommand(core);
     registerCorePolicyCommand(core);
     registerCoreJobsNativeCommand(core);
+    registerCorePipelineWorkerTableCommand(core);
     registerCoreResolveCompanyNativeCommand(core);
     registerCoreAuditLogNative(core);
     registerCoreGitPackExtensionCheckNative(core);