@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/core-knowledge-prefs.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'commander';
+export type CoreCommandResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runKnowledgePrefs(args: readonly string[], root: string): CoreCommandResult;
+/** Fast-entry adapter; family gating and shell fallback happen before import. */
+export declare function runKnowledgePrefsFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): number;
+export declare function registerCoreKnowledgePrefsCommand(core: Command): void;
+//# sourceMappingURL=core-knowledge-prefs.d.ts.map

package/dist/commands/core-knowledge-prefs.js

@@ -0,0 +1,137 @@
+/**
+ * Native port of core/scripts/knowledge-prefs.sh.
+ *
+ * The shell command reads only HQ_ROOT (the CLI resolves and supplies that
+ * source root) and scans top-level scalar lines without parsing YAML.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { resolveLiveRoot } from '../utils/hq-roots.js';
+import { runBundledScript } from '../utils/run-bundled-script.js';
+import { describeCoreCommand } from './core-command-catalog.js';
+const KNOWLEDGE_PREFS_ASSET = 'core/scripts/knowledge-prefs.sh';
+const DEFAULTS = {
+    signals_enabled: 'true',
+    ontology_enabled: 'true',
+    signals_capture: 'false',
+    ontology_capture: 'false',
+    meeting_notes_source: 'hq-native',
+    notetaker: 'recall',
+};
+const USAGE = 'usage: knowledge-prefs.sh get <company> <field>\n';
+function readField(filePath, field) {
+    let body;
+    try {
+        body = fs.readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR' || code === 'EACCES' || code === 'ELOOP')
+            return undefined;
+        throw error;
+    }
+    for (const line of body.split(/\n/)) {
+        if (!line.startsWith(field + ':'))
+            continue;
+        let value = line.slice(field.length + 1).replace(/^[\s]+/, '');
+        value = value.replace(/[\s]+#.*$/, '');
+        value = value.replace(/^["']|["']$/g, '');
+        if (value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+export function runKnowledgePrefs(args, root) {
+    if (args[0] !== 'get' || !args[1] || !args[2]) {
+        return { code: 2, stdout: '', stderr: USAGE };
+    }
+    const company = args[1];
+    const field = args[2];
+    const fallback = DEFAULTS[field];
+    if (fallback === undefined) {
+        return {
+            code: 2,
+            stdout: '',
+            stderr: "knowledge-prefs: unknown field '" + field + "'\n",
+        };
+    }
+    let companyExists = false;
+    try {
+        companyExists = fs.statSync(path.join(root, 'companies', company)).isDirectory();
+    }
+    catch (error) {
+        // `test -d` returns false for missing, unreadable, or non-directory paths.
+        const code = error.code;
+        if (code !== 'ENOENT' && code !== 'ENOTDIR' && code !== 'EACCES' && code !== 'ELOOP') {
+            throw error;
+        }
+    }
+    if (!companyExists) {
+        return {
+            code: 2,
+            stdout: '',
+            stderr: "knowledge-prefs: no company '" + company + "'\n",
+        };
+    }
+    const companyValue = readField(path.join(root, 'companies', company, 'settings', 'knowledge', 'preferences.yaml'), field);
+    const personalValue = companyValue === undefined
+        ? readField(path.join(root, 'personal', 'settings', 'knowledge-preferences.yaml'), field)
+        : undefined;
+    return {
+        code: 0,
+        stdout: (companyValue ?? personalValue ?? fallback) + '\n',
+        stderr: '',
+    };
+}
+/** Fast-entry adapter; family gating and shell fallback happen before import. */
+export function runKnowledgePrefsFast(args, _stdin, _cwd, hqRoot) {
+    const root = hqRoot ?? resolveLiveRoot();
+    const result = runKnowledgePrefs(args, root);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.code !== 0)
+        process.exitCode = result.code;
+    return result.code;
+}
+export function registerCoreKnowledgePrefsCommand(core) {
+    const command = core
+        .command('knowledge-prefs')
+        .description('Resolve a company knowledge-store preference')
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .helpOption(false)
+        .argument('[args...]', 'arguments passed through to the script')
+        .action(async (args = [], _options, cmd) => {
+        const operands = cmd.args.length > 0 ? cmd.args : args;
+        const hqRoot = resolveLiveRoot({
+            hqRoot: core.opts().hqRoot,
+        });
+        const { coreNativePolicyEnabled } = await import('./core-native-policy-flag.js');
+        if (!await coreNativePolicyEnabled()) {
+            const result = runBundledScript({
+                asset: KNOWLEDGE_PREFS_ASSET,
+                args: operands,
+                cwd: hqRoot,
+                hqRoot,
+            });
+            if (result.code !== 0)
+                process.exitCode = result.code;
+            return;
+        }
+        const result = runKnowledgePrefs(operands, hqRoot);
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+        if (result.code !== 0)
+            process.exitCode = result.code;
+    });
+    describeCoreCommand(command, {
+        execution: 'native',
+        asset: KNOWLEDGE_PREFS_ASSET,
+        root: 'live',
+    });
+}
+//# sourceMappingURL=core-knowledge-prefs.js.map

package/dist/commands/core-migrate-policy-triggers-native.d.ts

@@ -0,0 +1,21 @@
+import * as fs from "node:fs";
+export declare const MIGRATE_POLICY_TRIGGERS_ASSET = "core/scripts/migrate-policy-triggers.sh";
+export type MigratePolicyDependencies = {
+    root: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    now: () => Date;
+    fs: typeof fs;
+    evaluatorExists?: () => boolean;
+    runFlock?: (lockFd: number, cwd: string, pathValue: string) => {
+        status: number | null;
+        error?: Error;
+    };
+};
+export declare function runMigratePolicyTriggers(args: readonly string[], deps: MigratePolicyDependencies): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runMigratePolicyTriggersFast(args: readonly string[], _stdin: string, cwd: string, root?: string): Promise<number>;
+//# sourceMappingURL=core-migrate-policy-triggers-native.d.ts.map

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

@@ -0,0 +1,374 @@
+/** Native implementation of core/scripts/migrate-policy-triggers.sh. */
+import * as crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateTrigger } from "../utils/core-eval-trigger.js";
+export const MIGRATE_POLICY_TRIGGERS_ASSET = "core/scripts/migrate-policy-triggers.sh";
+const ON_LIVE = "[PreToolUse, PostToolUse, UserPromptSubmit, AssistantIntent]";
+const ON_START = "[SessionStart]";
+const TAG_STOP = new Set(("infrastructure consolidated ux safety hq hq-core hq-cli hq-packages " +
+    "hq-discipline basic-users knowledge-repos quiet-mode capabilities narration voice intent delight " +
+    "orchestration abstraction workflow deliverable routing anchor rulesets data-handling shell-injection " +
+    "promotion docs knowledge").split(/\s+/));
+function extractCompany(cwd) {
+    const match = cwd.match(/.*companies\/([^/]+).*/);
+    return match?.[1] ?? "";
+}
+function defaultDirs(deps) {
+    const dirs = [path.join(deps.root, "core/policies"), path.join(deps.root, "personal/policies")];
+    for (const entry of safeDirNames(deps.fs, path.join(deps.root, "personal/workers"))) {
+        const candidate = path.join(deps.root, "personal/workers", entry, "policies");
+        if (isDirectory(deps.fs, candidate))
+            dirs.push(candidate);
+    }
+    const logicalCwd = deps.env.CLAUDE_PROJECT_DIR || deps.cwd;
+    const company = deps.env.HQ_POLICY_COMPANY || extractCompany(logicalCwd);
+    if (company && company !== "." && company !== ".." && !company.includes("/")) {
+        const companyRoot = path.join(deps.root, "companies", company);
+        dirs.push(path.join(companyRoot, "policies"));
+        for (const entry of safeDirNames(deps.fs, path.join(companyRoot, "workers"))) {
+            const candidate = path.join(companyRoot, "workers", entry, "policies");
+            if (isDirectory(deps.fs, candidate))
+                dirs.push(candidate);
+        }
+    }
+    const repoMatch = logicalCwd.match(/.*repos\/(public|private)\/([^/]+).*/);
+    if (repoMatch)
+        dirs.push(path.join(deps.root, "repos", repoMatch[1], repoMatch[2], ".claude/policies"));
+    return dirs;
+}
+function safeDirNames(fileSystem, directory) {
+    try {
+        return fileSystem.readdirSync(directory).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function isDirectory(fileSystem, value) {
+    try {
+        return fileSystem.statSync(value).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function executableInPath(name, env, fileSystem) {
+    for (const directory of (env.PATH ?? "").split(path.delimiter)) {
+        if (!directory)
+            continue;
+        try {
+            const stat = fileSystem.statSync(path.join(directory, name));
+            if (stat.isFile() && (stat.mode & 0o111) !== 0)
+                return true;
+        }
+        catch { /* continue through PATH */ }
+    }
+    return false;
+}
+function runNonblockingFlock(lockFd, cwd, pathValue) {
+    const stdio = [
+        "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", lockFd,
+    ];
+    const result = spawnSync("flock", ["-n", "9"], { cwd, env: { PATH: pathValue }, stdio });
+    return { status: result.status, error: result.error };
+}
+function frontmatterValue(content, key) {
+    let depth = 0;
+    for (const line of content.split("\n")) {
+        if (line === "---") {
+            depth += 1;
+            continue;
+        }
+        if (depth === 1 && line.startsWith(`${key}:`))
+            return line.replace(new RegExp(`^${key}:[\\t\\n\\v\\f\\r ]*`), "");
+    }
+    return "";
+}
+function triggerExpression(trigger) {
+    const t = trigger.toLowerCase();
+    if (t.includes("deploy"))
+        return "deploy";
+    if (["credential", "secret", "op://", "aws_profile", ".env"].some((needle) => t.includes(needle)))
+        return "secret || credential";
+    if (["git push", "gh pr merge", " push ", "push to"].some((needle) => t.includes(needle)))
+        return "git && push";
+    if (t.includes("commitment"))
+        return "";
+    if (t.includes("commit"))
+        return "git && commit";
+    if (t.includes("checkout"))
+        return "git && checkout";
+    if (t.includes("rebase"))
+        return "git && rebase";
+    if (t.includes("git stash") || t.includes(" stash "))
+        return "git && stash";
+    if (t.includes("gh pr") || t.includes("pull request") || t.includes("pr merge"))
+        return "pr";
+    if (t.includes("merge"))
+        return "git && merge";
+    if (["migration", "migrate", "schema", "prisma"].some((needle) => t.includes(needle)))
+        return "migrate || migration || schema";
+    if (["npm install", "pnpm ", "yarn ", " install ", "package install"].some((needle) => t.includes(needle)))
+        return "install";
+    if (t.includes("grep"))
+        return "grep";
+    if (t.includes("slack"))
+        return "slack";
+    if (t.includes("email"))
+        return "email";
+    if (t.includes(" git ") || t.startsWith("git ") || t.endsWith(" git"))
+        return "git";
+    return "";
+}
+function deriveWhen(trigger, rawTags, enforcementRaw) {
+    let enforcement = enforcementRaw.split("#", 1)[0].toLowerCase().replace(/[\s\t\n\r\v\f]/g, "");
+    enforcement = enforcement.replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
+    const triggerExpr = triggerExpression(trigger);
+    const terms = [];
+    const seen = new Set();
+    if (triggerExpr) {
+        const exprTokens = triggerExpr.match(/[a-z_][a-z0-9_./-]*/g) ?? [];
+        for (const token of exprTokens)
+            seen.add(token);
+        terms.push(triggerExpr.includes(" ") ? `( ${triggerExpr} )` : triggerExpr);
+    }
+    const commentStrippedTags = rawTags.replace(/[ \t\v\f\r]+#.*$/, "");
+    const withoutBrackets = commentStrippedTags.replace(/^\[/, "").replace(/\]$/, "");
+    const rawTagParts = withoutBrackets.split(",");
+    for (const raw of rawTagParts) {
+        const tag = raw.toLowerCase().replace(/^\s+|\s+$/g, "").replace(/^vendor:/, "");
+        if (!tag || TAG_STOP.has(tag) || seen.has(tag))
+            continue;
+        seen.add(tag);
+        terms.push(tag);
+    }
+    if (!terms.length)
+        return enforcement === "hard" ? { when: "always", on: ON_START } : null;
+    return { when: terms.join(" || "), on: ON_LIVE };
+}
+function writeAtomic(fileSystem, target, bytes) {
+    const temporary = path.join(path.dirname(target), `.migrate-policy-triggers.${process.pid}.${Math.random().toString(16).slice(2)}`);
+    try {
+        fileSystem.writeFileSync(temporary, bytes, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        fileSystem.chmodSync(temporary, 0o600);
+        fileSystem.renameSync(temporary, target);
+        return true;
+    }
+    catch {
+        try {
+            fileSystem.unlinkSync(temporary);
+        }
+        catch { /* temporary did not survive */ }
+        return false;
+    }
+}
+function unreadablePolicyDiagnostic(filename, error) {
+    const code = error.code;
+    const message = code === "EACCES" || code === "EPERM" ? "Permission denied" : "No such file or directory";
+    const script = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold/core/scripts/migrate-policy-triggers.sh");
+    const awk = `awk: fatal: cannot open file \`${filename}' for reading: ${message}\n`;
+    return `${script}: line 314: ${filename}: ${message}\n${awk.repeat(3)}`;
+}
+function shellGlobMd(fileSystem, directory) {
+    try {
+        return fileSystem.readdirSync(directory).filter((name) => !name.startsWith(".") && name.endsWith(".md"))
+            .sort().map((name) => path.join(directory, name)).filter((name) => {
+            try {
+                return fileSystem.statSync(name).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function runMigratePolicyTriggers(args, deps) {
+    let dryRun = false;
+    const explicitDirs = [];
+    for (const arg of args) {
+        if (arg === "--dry-run")
+            dryRun = true;
+        else
+            explicitDirs.push(arg);
+    }
+    const dirs = explicitDirs.length ? explicitDirs : defaultDirs(deps);
+    const fileSystem = deps.fs;
+    let stateDir = deps.env.HQ_MIGRATE_POLICY_TRIGGERS_STATE_DIR ?? "";
+    if (!stateDir) {
+        if (deps.env.XDG_STATE_HOME)
+            stateDir = path.join(deps.env.XDG_STATE_HOME, "hq-migrate-policy-triggers");
+        else if (deps.env.HOME)
+            stateDir = path.join(deps.env.HOME, ".local/state/hq-migrate-policy-triggers");
+    }
+    const cooldownText = deps.env.HQ_MIGRATE_POLICY_TRIGGERS_COOLDOWN_SECONDS || "3600";
+    const cooldown = /^-?\d+$/.test(cooldownText) ? Number(cooldownText) : 0;
+    const scope = Buffer.concat([Buffer.from(`${deps.root}\0`), ...dirs.map((dir) => Buffer.from(`${dir}\0`))]);
+    const scopeHash = crypto.createHash("sha256").update(scope).digest("hex");
+    const stamp = stateDir ? path.join(stateDir, scopeHash, "last-success") : "";
+    const lock = stateDir ? path.join(stateDir, scopeHash, "migrate.lock") : "";
+    let stateReady = false;
+    if (stateDir) {
+        try {
+            fileSystem.mkdirSync(path.dirname(stamp), { recursive: true });
+            stateReady = true;
+        }
+        catch {
+            stateReady = false;
+        }
+    }
+    let stderr = "";
+    let stdout = "";
+    const nowSeconds = () => Math.floor(deps.now().getTime() / 1000);
+    const bypass = dryRun || !stateReady || deps.env.HQ_MIGRATE_POLICY_TRIGGERS_FORCE === "1" || cooldown <= 0;
+    const cooldownBlocks = () => {
+        if (bypass)
+            return false;
+        try {
+            const last = fileSystem.readFileSync(stamp, "utf8");
+            if (!/^\d+$/.test(last)) {
+                stderr += `migrate-policy-triggers: cooldown stamp is unreadable; running\n`;
+                return false;
+            }
+            const age = nowSeconds() - Number(last);
+            if (age < 0) {
+                stderr += `migrate-policy-triggers: cooldown stamp is in the future; running\n`;
+                return false;
+            }
+            return age < cooldown;
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return false;
+            stderr += `migrate-policy-triggers: cooldown stamp is unreadable; running\n`;
+            return false;
+        }
+    };
+    if (cooldownBlocks())
+        return { code: 0, stdout, stderr };
+    let lockFd;
+    if (stateReady && !dryRun && executableInPath("flock", deps.env, fileSystem)) {
+        try {
+            lockFd = fileSystem.openSync(lock, "w");
+        }
+        catch {
+            return { code: 0, stdout, stderr };
+        }
+        const lockResult = (deps.runFlock ?? runNonblockingFlock)(lockFd, deps.cwd, deps.env.PATH ?? "");
+        if (lockResult.error || lockResult.status !== 0) {
+            fileSystem.closeSync(lockFd);
+            return { code: 0, stdout, stderr };
+        }
+        if (cooldownBlocks()) {
+            fileSystem.closeSync(lockFd);
+            return { code: 0, stdout, stderr };
+        }
+    }
+    const evaluator = deps.evaluatorExists ?? (() => {
+        const evaluatorPath = path.join(deps.root, "core/scripts/eval-trigger.sh");
+        try {
+            return fileSystem.statSync(evaluatorPath).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+    let migrated = 0, untriggered = 0, unparseable = 0, skipped = 0, session = 0;
+    let errorCode = 0;
+    try {
+        for (const dir of dirs) {
+            if (!isDirectory(fileSystem, dir))
+                continue;
+            for (const filename of shellGlobMd(fileSystem, dir)) {
+                const name = path.basename(filename);
+                if (name === "example-policy.md" || name === "README.md")
+                    continue;
+                let original;
+                try {
+                    original = fileSystem.readFileSync(filename, "utf8");
+                }
+                catch (error) {
+                    stderr += unreadablePolicyDiagnostic(filename, error);
+                    untriggered += 1;
+                    continue;
+                }
+                if (original.split("\n").some((line) => line.startsWith("when:"))) {
+                    skipped += 1;
+                    continue;
+                }
+                const derived = deriveWhen(frontmatterValue(original, "trigger"), frontmatterValue(original, "tags"), frontmatterValue(original, "enforcement"));
+                if (!derived) {
+                    untriggered += 1;
+                    continue;
+                }
+                const evaluatorAvailable = evaluator();
+                const parsedStatus = evaluateTrigger(derived.when, "");
+                if (evaluatorAvailable && parsedStatus === 2) {
+                    unparseable += 1;
+                    stderr += `migrate-policy-triggers: refusing to write unparseable when: ${name} -> \`${derived.when}\`\n`;
+                    continue;
+                }
+                if (derived.on === ON_START)
+                    session += 1;
+                if (dryRun) {
+                    const line = `${name.padEnd(52)} when: ${derived.when.padEnd(44)} on: ${derived.on}\n`;
+                    stdout += line;
+                    migrated += 1;
+                    continue;
+                }
+                const anchor = original.split("\n").some((line) => line.startsWith("trigger:")) ? /^trigger:/ : /^id:/;
+                const lines = original.split("\n");
+                let inserted = false;
+                const rewritten = lines.flatMap((line) => {
+                    if (!inserted && anchor.test(line)) {
+                        inserted = true;
+                        return [line, `when: ${derived.when}`, `on: ${derived.on}`];
+                    }
+                    return [line];
+                }).join("\n");
+                // awk print adds a newline even when the source's last line had none.
+                if (!writeAtomic(fileSystem, filename, `${rewritten.endsWith("\n") ? rewritten.slice(0, -1) : rewritten}\n`)) {
+                    errorCode = 1;
+                    break;
+                }
+                migrated += 1;
+            }
+            if (errorCode)
+                break;
+        }
+        if (migrated > 0)
+            stderr += `migrate-policy-triggers: backfilled ${migrated} policy trigger(s) (${session} hard -> SessionStart, ${untriggered} non-hard triggerless left unchanged, ${unparseable} unparseable derivations skipped, ${skipped} already had when)\n`;
+        if (!dryRun && stateReady && !errorCode) {
+            const stampTmp = path.join(path.dirname(stamp), `.last-success.${process.pid}.${Math.random().toString(16).slice(2)}`);
+            try {
+                fileSystem.writeFileSync(stampTmp, `${nowSeconds()}\n`, { mode: 0o600, flag: "wx" });
+                fileSystem.renameSync(stampTmp, stamp);
+            }
+            catch {
+                try {
+                    fileSystem.unlinkSync(stampTmp);
+                }
+                catch { /* ignore stamp failure */ }
+            }
+        }
+    }
+    finally {
+        if (lockFd !== undefined)
+            fileSystem.closeSync(lockFd);
+    }
+    return { code: errorCode, stdout, stderr };
+}
+export async function runMigratePolicyTriggersFast(args, _stdin, cwd, root) {
+    const result = runMigratePolicyTriggers(args, { root: root ?? process.env.HQ_ROOT ?? cwd, cwd, env: process.env, now: () => new Date(), fs });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-migrate-policy-triggers-native.js.map

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

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for the native Wave 2 worktree/resume helpers. */
+export declare const CORE_NATIVE_HANDOFF_FLAG = "core-native-handoff";
+export declare function coreNativeHandoffEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-handoff-flag.d.ts.map

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

@@ -0,0 +1,7 @@
+/** Default-off rollout gate for the native Wave 2 worktree/resume helpers. */
+export const CORE_NATIVE_HANDOFF_FLAG = "core-native-handoff";
+export async function coreNativeHandoffEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_NATIVE_HANDOFF_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-native-handoff-flag.js.map

package/dist/commands/core-native-hook-helper-commands.d.ts

@@ -0,0 +1,4 @@
+/** Complete command-graph registrations for Wave 8 hook helper ports. */
+import type { Command } from "commander";
+export declare function registerCoreHookHelperNativeCommands(core: Command): void;
+//# sourceMappingURL=core-native-hook-helper-commands.d.ts.map

package/dist/commands/core-native-hook-helper-commands.js

@@ -0,0 +1,56 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { runBundledScript } from "../utils/run-bundled-script.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { coreNativeHookHelpersEnabled } from "./core-native-hook-helpers-flag.js";
+import { EVAL_TRIGGER_ASSET, runEvalTriggerFast } from "./core-eval-trigger-native.js";
+import { MIGRATE_POLICY_TRIGGERS_ASSET, runMigratePolicyTriggersFast } from "./core-migrate-policy-triggers-native.js";
+import { REGISTER_PROJECT_ASSET, runRegisterProjectFast } from "./core-register-project-native.js";
+import { WORK_MESH_LIVE_REBIND_ASSET, runWorkMeshLiveRebindFast } from "./core-work-mesh-live-rebind-native.js";
+const entries = [
+    { name: "eval-trigger", asset: EVAL_TRIGGER_ASSET, summary: "Evaluate policy trigger expressions", root: "cwd", shellCwd: "caller", shellRoot: "none", readsStdinFor: (args) => args[0] === "--check", run: runEvalTriggerFast },
+    { name: "migrate-policy-triggers", asset: MIGRATE_POLICY_TRIGGERS_ASSET, summary: "Backfill policy trigger frontmatter", root: "live", shellCwd: "caller", shellRoot: "live", readsStdin: false, run: runMigratePolicyTriggersFast },
+    { name: "register-project", asset: REGISTER_PROJECT_ASSET, summary: "Register a project with Work Mesh", root: "live", shellCwd: "caller", shellRoot: "live", readsStdin: false, run: runRegisterProjectFast },
+    { name: "work-mesh-live-rebind", asset: WORK_MESH_LIVE_REBIND_ASSET, summary: "Rebind a live Work Mesh session to its current project", root: "live", shellCwd: "caller", shellRoot: "live", readsStdin: false, run: runWorkMeshLiveRebindFast },
+];
+export function registerCoreHookHelperNativeCommands(core) {
+    for (const entry of entries) {
+        const command = core.command(entry.name)
+            .description(entry.summary)
+            .allowUnknownOption()
+            .allowExcessArguments()
+            .helpOption(false)
+            .argument("[args...]")
+            .action(async (args = [], _options, cmd) => {
+            const operands = cmd.args.length > 0 ? cmd.args : args;
+            const groupRoot = core.opts().hqRoot;
+            const root = entry.root === "live" ? resolveLiveRoot({ hqRoot: groupRoot }) : undefined;
+            if (!await coreNativeHookHelpersEnabled()) {
+                const result = runBundledScript({
+                    asset: entry.asset,
+                    args: operands,
+                    cwd: entry.shellCwd === "live" ? root ?? process.cwd() : process.cwd(),
+                    ...(entry.shellRoot === "live" ? { hqRoot: root } : {}),
+                    ...(entry.name === "migrate-policy-triggers"
+                        ? { env: { CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR || process.cwd() } }
+                        : {}),
+                });
+                if (result.code !== 0)
+                    process.exitCode = result.code;
+                return;
+            }
+            const readsStdin = entry.readsStdinFor?.(operands) ?? entry.readsStdin;
+            const stdin = readsStdin ? await readStdin() : "";
+            const code = await entry.run(operands, stdin, process.cwd(), root);
+            if (code !== 0)
+                process.exitCode = code;
+        });
+        describeCoreCommand(command, { execution: "native", asset: entry.asset, root: entry.root });
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+//# sourceMappingURL=core-native-hook-helper-commands.js.map

package/dist/commands/core-native-hook-helpers-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for Wave 8 hook-time helper commands. */
+export declare const CORE_NATIVE_HOOK_HELPERS_FLAG = "core-native-hook-helpers";
+export declare function coreNativeHookHelpersEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-hook-helpers-flag.d.ts.map

package/dist/commands/core-native-hook-helpers-flag.js

@@ -0,0 +1,7 @@
+/** Default-off rollout gate for Wave 8 hook-time helper commands. */
+export const CORE_NATIVE_HOOK_HELPERS_FLAG = "core-native-hook-helpers";
+export async function coreNativeHookHelpersEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_NATIVE_HOOK_HELPERS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-native-hook-helpers-flag.js.map

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

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for the native scheduled-jobs helpers. */
+export declare const CORE_NATIVE_JOBS_FLAG = "core-native-jobs";
+export declare function coreNativeJobsEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-jobs-flag.d.ts.map

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

@@ -0,0 +1,7 @@
+/** Default-off rollout gate for the native scheduled-jobs helpers. */
+export const CORE_NATIVE_JOBS_FLAG = "core-native-jobs";
+export async function coreNativeJobsEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_NATIVE_JOBS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-native-jobs-flag.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Default-off rollout gate shared by the native knowledge and policy commands.
+ *
+ * The flag reader is loaded only after command selection. Its process gate reads
+ * the in-memory hq-flags snapshot synchronously and falls back to false.
+ */
+export declare const CORE_NATIVE_POLICY_FLAG = "core-native-policy";
+export declare function coreNativePolicyEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-policy-flag.d.ts.map