@indigoai-us/hq-cli 5.345.105 → 5.345.107

package/dist/fast-scaffold.js

@@ -9,6 +9,142 @@
  * on every turn's Stop. The entrypoint routes eligible commands before loading
  * the graph, and this module holds the parser + table that routing needs.
  */
+export const CORE_COMMAND_PATH_OPERANDS = {
+    "audit-log": "comma:--files",
+    "codex-skill-bridge": "options:--root,--old-root",
+    "git-pack-extension-check": "options:--root",
+    "job notify": "options:--hq-root,--log-path",
+    "hq-status-summary": "options:--porcelain-file,--session-files-file",
+    "ontology-readme-drift": "options:--root",
+    "policy age-report": "options:--dir",
+    "policy retire": "options:--dir,--report-dir",
+    "policy frontmatter": "all-nonoptions",
+    "qmd-reindex-after-sync": "first-nonoption",
+    "refresh-vault-access": "options:--root",
+    "resize-screenshot": "position:0",
+    "token-usage-report": "options:--project-dir",
+    worktree: "options:--source",
+};
+/** True when argv names a command that declares path operands. */
+export function coreCommandHasPathOperands(argv) {
+    if (argv[2] !== "core")
+        return false;
+    const coreArgs = argv.slice(3);
+    if (coreArgs.some((value, index) => (value === "--hq-root" && coreArgs[index + 1]?.startsWith("/")) ||
+        (value.startsWith("--hq-root=") && value.slice("--hq-root=".length).startsWith("/")))) {
+        return true;
+    }
+    let commandStart = 3;
+    if (argv[commandStart] === "--hq-root")
+        commandStart += 2;
+    else if (argv[commandStart]?.startsWith("--hq-root="))
+        commandStart += 1;
+    return Object.keys(CORE_COMMAND_PATH_OPERANDS).some((name) => name.split(" ").every((part, index) => argv[commandStart + index] === part));
+}
+/** Apply the manifest's operand rule to a copied process.argv vector. */
+export function normalizeCorePathOperands(argv, platform = process.platform, convertPath = (value) => value) {
+    const normalized = [...argv];
+    if (platform !== "win32" || normalized[2] !== "core")
+        return normalized;
+    let commandStart = 3;
+    if (normalized[commandStart] === "--hq-root") {
+        const root = normalized[commandStart + 1];
+        if (root?.startsWith("/"))
+            normalized[commandStart + 1] = convertPath(root);
+        commandStart += 2;
+    }
+    else if (normalized[commandStart]?.startsWith("--hq-root=")) {
+        const value = normalized[commandStart].slice("--hq-root=".length);
+        if (value.startsWith("/"))
+            normalized[commandStart] = `--hq-root=${convertPath(value)}`;
+        commandStart += 1;
+    }
+    // Commander accepts the core group's root override after the subcommand too.
+    // Fast parsing defers that form, but normalize it before either route sees argv.
+    for (let index = commandStart; index < normalized.length; index += 1) {
+        const value = normalized[index];
+        if (value === "--")
+            break;
+        if (value === "--hq-root") {
+            index += 1;
+            if (normalized[index]?.startsWith("/"))
+                normalized[index] = convertPath(normalized[index]);
+        }
+        else if (value.startsWith("--hq-root=")) {
+            const root = value.slice("--hq-root=".length);
+            if (root.startsWith("/"))
+                normalized[index] = `--hq-root=${convertPath(root)}`;
+        }
+    }
+    const commandName = Object.keys(CORE_COMMAND_PATH_OPERANDS)
+        .sort((left, right) => right.split(" ").length - left.split(" ").length)
+        .find((name) => name.split(" ").every((part, index) => normalized[commandStart + index] === part));
+    if (!commandName)
+        return normalized;
+    const argsStart = commandStart + commandName.split(" ").length;
+    const args = normalized.slice(argsStart);
+    const convert = (index) => {
+        const value = args[index];
+        if (value?.startsWith("/"))
+            args[index] = convertPath(value);
+    };
+    const rule = CORE_COMMAND_PATH_OPERANDS[commandName];
+    if (rule === "all-nonoptions") {
+        args.forEach((value, index) => { if (!value.startsWith("--"))
+            convert(index); });
+    }
+    else if (rule === "first-nonoption") {
+        const index = args.findIndex((value) => !value.startsWith("--"));
+        if (index >= 0)
+            convert(index);
+    }
+    else if (rule.startsWith("position:")) {
+        convert(Number(rule.slice("position:".length)));
+    }
+    else if (rule.startsWith("options:")) {
+        const options = new Set(rule.slice("options:".length).split(","));
+        for (let index = 0; index < args.length; index += 1) {
+            const value = args[index];
+            if (options.has(value)) {
+                index += 1;
+                if (index < args.length)
+                    convert(index);
+            }
+            else {
+                const equalsAt = value.indexOf("=");
+                if (equalsAt >= 0 && options.has(value.slice(0, equalsAt)) && value.slice(equalsAt + 1).startsWith("/")) {
+                    args[index] = `${value.slice(0, equalsAt + 1)}${convertPath(value.slice(equalsAt + 1))}`;
+                }
+            }
+        }
+    }
+    else if (rule.startsWith("comma:")) {
+        const option = rule.slice("comma:".length);
+        for (let index = 0; index < args.length; index += 1) {
+            if (args[index] === option && index + 1 < args.length) {
+                index += 1;
+                args[index] = convertCommaPaths(args[index]);
+                break;
+            }
+            const prefix = `${option}=`;
+            if (args[index].startsWith(prefix)) {
+                const value = args[index].slice(prefix.length);
+                if (value.startsWith("/")) {
+                    args[index] = `${prefix}${convertCommaPaths(value)}`;
+                }
+                break;
+            }
+        }
+    }
+    normalized.splice(argsStart, args.length, ...args);
+    return normalized;
+    function convertCommaPaths(value) {
+        const parts = value.split(",");
+        while (parts.at(-1) === "")
+            parts.pop();
+        return parts.map((part) => part.startsWith("/") ? convertPath(part) : part).join(",");
+    }
+}
 /** Family kill switches whose owner-approved default is enabled. */
 export const CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS = [
     "core-native-session",
@@ -16,8 +152,8 @@ export const CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS = [
     "core-native-policy",
     "core-native-utilities",
     "core-native-jobs",
-    "core-native-ontology",
     "core-native-handoff",
+    "core-native-bucket-c",
     "core-native-delegate",
 ];
 const defaultOnFamilyFlags = new Set(CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS);
@@ -470,11 +606,7 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         modulePath: "./commands/core-ontology-native.js",
         exportName: "runOntologyNativeFast",
         flagKey: "hq-core-native-fast-route",
-        familyFlagKey: "core-native-ontology",
-        asset: `core/scripts/${name === "audience-grant" ? "ontology-audience-grant" : name === "source-worklist" ? "ontology-source-worklist" : name === "source-yaml-validate" ? "source-yaml-validate" : `ontology-${name}`}.${name === "brief" || name === "garden" ? "mjs" : "sh"}`,
         root: name === "source-yaml-validate" ? "cwd" : "live",
-        shellCwd: "caller",
-        shellHqRoot: name === "source-yaml-validate" ? "none" : "live",
     })),
     {
         name: "audit-log",
@@ -577,6 +709,18 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellHqRoot: "live",
         requiresNodeNetworkCompatibility: true,
     },
+    {
+        name: "hq-task",
+        kind: "native",
+        modulePath: "./commands/core-hq-task-fast.js",
+        exportName: "runHqTaskFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-bucket-c",
+        asset: "core/scripts/hq-task.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
 ];
 /**
  * Parse the small, non-ambiguous `hq secrets env` surface for the gated entry