@indigoai-us/hq-cli 5.310.0 → 5.311.1

package/dist/commands/core-worker-lint-native.js

@@ -0,0 +1,160 @@
+/** Native port of lint-shared-worker-skills.sh. */
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+import { errorCode, missingOrUnreadable, resolveWorkerCallerRoot, } from "./core-worker-skills-runtime.js";
+export const WORKER_SKILL_LINT_ASSET = "core/scripts/lint-shared-worker-skills.sh";
+const DEFAULT_ROOTS = ["core/workers", "core/packages"];
+function joinFindPath(parent, child) {
+    return `${parent}${parent.endsWith("/") ? "" : "/"}${child}`;
+}
+function matchesFindPredicate(displayPath) {
+    // GNU/BSD find's `-path '*/skills/*.md'` glob lets `*` span `/`, but still
+    // requires a slash before `skills/`. In particular `skills/x.md` does not
+    // match while `./skills/x.md` and `workers/a/skills/x.md` do.
+    if (!/.+\/skills\/.*\.md$/.test(displayPath))
+        return false;
+    const name = displayPath.slice(displayPath.lastIndexOf("/") + 1);
+    if (name.startsWith("._"))
+        return false;
+    // Mirrors find's `-not -path '*/.*/*'`: a hidden directory is excluded only
+    // when it has a slash before and after the dot-prefixed component.
+    return !/\/\.[^/]*\//.test(displayPath);
+}
+function collectEntries(rootArg, cwd, fileSystem) {
+    const entries = [];
+    const visit = (displayPath) => {
+        const absolutePath = path.resolve(cwd, displayPath);
+        let info;
+        try {
+            info = fileSystem.lstatSync(absolutePath);
+        }
+        catch (error) {
+            if (missingOrUnreadable(error))
+                return;
+            throw error;
+        }
+        if (info.isDirectory()) {
+            let names;
+            try {
+                names = fileSystem.readdirSync(absolutePath);
+            }
+            catch (error) {
+                if (missingOrUnreadable(error))
+                    return;
+                throw error;
+            }
+            for (const name of names)
+                visit(joinFindPath(displayPath, name));
+            return;
+        }
+        if ((info.isFile() || info.isSymbolicLink()) && matchesFindPredicate(displayPath)) {
+            entries.push({ displayPath, absolutePath, symlink: info.isSymbolicLink() });
+        }
+    };
+    visit(rootArg);
+    return entries;
+}
+function ownershipDomain(displayPath) {
+    const value = displayPath.startsWith("./") ? displayPath.slice(2) : displayPath;
+    if (value.startsWith("core/packages/")) {
+        const rest = value.slice("core/packages/".length);
+        return `core/packages/${rest.split("/", 1)[0]}`;
+    }
+    if (value.startsWith("companies/")) {
+        const rest = value.slice("companies/".length);
+        return `companies/${rest.split("/", 1)[0]}`;
+    }
+    if (value === "core/workers" || value.startsWith("core/workers/"))
+        return "core/workers";
+    return value.split("/", 1)[0] ?? "";
+}
+function readFileForHash(filePath, fileSystem) {
+    const content = fileSystem.readFileSync(filePath);
+    return Buffer.isBuffer(content) ? content : Buffer.from(content);
+}
+function brokenLink(filePath, fileSystem) {
+    try {
+        fileSystem.statSync(filePath);
+        return false;
+    }
+    catch (error) {
+        if (missingOrUnreadable(error))
+            return true;
+        throw error;
+    }
+}
+function sorted(entries) {
+    // The legacy command pipes `find` into `sort`; the project environment uses
+    // the C locale, so preserve its byte ordering instead of ICU collation.
+    return entries.sort((left, right) => left.displayPath < right.displayPath ? -1 : left.displayPath > right.displayPath ? 1 : 0);
+}
+function resultError(error) {
+    const code = errorCode(error);
+    if (code === "EACCES" || code === "EPERM") {
+        return { code: 1, stdout: "", stderr: `md5sum: failed to read file: ${error instanceof Error ? error.message : String(error)}\n` };
+    }
+    throw error;
+}
+export function runWorkerSkillLint(args, dependencies) {
+    const { root, fs: fileSystem } = resolveWorkerCallerRoot(dependencies);
+    const roots = args.length > 0 ? args : DEFAULT_ROOTS;
+    const entries = sorted(roots.flatMap((entry) => collectEntries(entry, root, fileSystem)));
+    if (entries.length === 0) {
+        return {
+            code: 0,
+            stdout: `OK: worker-scoped skills are single-sourced (0 skill entries under: ${roots.join(" ")})\n`,
+            stderr: "",
+        };
+    }
+    const broken = [];
+    const hashGroups = new Map();
+    try {
+        for (const entry of entries) {
+            if (entry.symlink) {
+                if (brokenLink(entry.absolutePath, fileSystem))
+                    broken.push(entry.displayPath);
+                continue;
+            }
+            const digest = crypto.createHash("md5").update(readFileForHash(entry.absolutePath, fileSystem)).digest("hex");
+            const domain = ownershipDomain(entry.displayPath);
+            const key = `${domain}|${digest}`;
+            const group = hashGroups.get(key);
+            if (group)
+                group.paths.push(entry.displayPath);
+            else
+                hashGroups.set(key, { domain, paths: [entry.displayPath] });
+        }
+    }
+    catch (error) {
+        return resultError(error);
+    }
+    const duplicates = [...hashGroups.values()].filter((group) => group.paths.length >= 2);
+    const findings = duplicates.length + broken.length;
+    if (findings === 0) {
+        return {
+            code: 0,
+            stdout: `OK: worker-scoped skills are single-sourced (${entries.length} skill entries scanned under: ${roots.join(" ")})\n`,
+            stderr: "",
+        };
+    }
+    const lines = [];
+    if (duplicates.length > 0) {
+        lines.push("lint-shared-worker-skills: FAIL — duplicated worker skills (single-source these via _shared-skills/ + relative symlinks):");
+    }
+    for (const group of duplicates) {
+        lines.push(`  DUPLICATE in domain '${group.domain}' (identical content, ${group.paths.length} copies — pick one canonical and symlink the rest):`);
+        // The shell prefixes the newline-joined group only once, so only the first
+        // path carries these spaces in the resulting stderr.
+        lines.push(`    ${group.paths.join("\n")}`);
+    }
+    if (broken.length > 0) {
+        if (duplicates.length === 0)
+            lines.push("lint-shared-worker-skills: FAIL — broken shared-skill symlink(s):");
+        lines.push("  BROKEN (symlink target does not resolve):");
+        for (const filePath of broken)
+            lines.push(`    ${filePath}`);
+    }
+    lines.push("", "  Fix: keep ONE canonical file in the narrowest-scope _shared-skills/ store", "  (core/workers/_shared-skills, core/packages/<pack>/workers/_shared-skills,", "  or companies/<co>/workers/_shared-skills) and replace each duplicate with a", "  relative symlink. Helper: hq core worker share", "  Doc: core/knowledge/public/hq-core/shared-worker-skills.md");
+    return { code: 1, stdout: "", stderr: `${lines.join("\n")}\n` };
+}
+//# sourceMappingURL=core-worker-lint-native.js.map

package/dist/commands/core-worker-share-native.d.ts

@@ -0,0 +1,5 @@
+import { type WorkerSkillDependencies, type WorkerSkillResult } from "./core-worker-skills-runtime.js";
+export declare const WORKER_SKILL_SHARE_ASSET = "core/scripts/share-worker-skill.sh";
+export declare const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
+export declare function runWorkerSkillShare(argv: string[], dependencies: WorkerSkillDependencies): WorkerSkillResult;
+//# sourceMappingURL=core-worker-share-native.d.ts.map

package/dist/commands/core-worker-share-native.js

@@ -0,0 +1,260 @@
+/** Native port of share-worker-skill.sh. */
+import * as path from "node:path";
+import { resolveBundledAsset } from "../utils/hq-roots.js";
+import { existsFollowingLinks, isDirectory, isSymlink, resolveWorkerCallerRoot, runGit, errorCode, } from "./core-worker-skills-runtime.js";
+export const WORKER_SKILL_SHARE_ASSET = "core/scripts/share-worker-skill.sh";
+export const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
+function error(message, code = 2) {
+    return { code, stdout: "", stderr: `${message}\n` };
+}
+function toolFailure(output, tool, target, caught, destination) {
+    const code = errorCode(caught);
+    const reason = code === "EACCES" || code === "EPERM" ? "Permission denied"
+        : code === "ENOENT" ? "No such file or directory"
+            : code === "ENOTDIR" ? "Not a directory"
+                : code === "EEXIST" ? "File exists"
+                    : code === "ENOSPC" ? "No space left on device"
+                        : code === "EXDEV" ? "Invalid cross-device link"
+                            : caught instanceof Error ? caught.message : String(caught);
+    const message = tool === "mkdir" ? `mkdir: cannot create directory ‘${target}’: ${reason}`
+        : tool === "mv" ? `mv: cannot move '${target}' to '${destination ?? ""}': ${reason}`
+            : tool === "rm" ? `rm: cannot remove '${target}': ${reason}`
+                : `ln: failed to create symbolic link '${target}': ${reason}`;
+    return { code: 1, stdout: `${output.join("\n")}\n`, stderr: `${message}\n` };
+}
+function removeOneTrailingSlash(value) {
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function stripOneDotSlash(value) {
+    return value.startsWith("./") ? value.slice(2) : value;
+}
+function isUnderScope(workerPath, scopeDir) {
+    const worker = stripOneDotSlash(workerPath);
+    const scope = stripOneDotSlash(scopeDir);
+    return worker.startsWith(`${scope}/`);
+}
+function relativePath(fromDirectory, toFile) {
+    const from = stripOneDotSlash(fromDirectory);
+    const to = stripOneDotSlash(toFile);
+    const fromParts = from.split("/");
+    const toParts = to.split("/");
+    let index = 0;
+    while (index < fromParts.length && index < toParts.length && fromParts[index] === toParts[index])
+        index += 1;
+    const up = "../".repeat(fromParts.length - index);
+    const down = toParts.slice(index).join("/");
+    return `${up}${down}`;
+}
+function isRegularFile(filePath, fileSystem) {
+    if (isSymlink(filePath, fileSystem))
+        return false;
+    try {
+        return fileSystem.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readLink(filePath, fileSystem) {
+    return fileSystem.readlinkSync(filePath);
+}
+function sameBytes(leftPath, rightPath, fileSystem) {
+    try {
+        const left = fileSystem.readFileSync(leftPath);
+        const right = fileSystem.readFileSync(rightPath);
+        return Buffer.from(left).equals(Buffer.from(right));
+    }
+    catch {
+        // The shell sends cmp's diagnostics to /dev/null and treats every nonzero
+        // result as a drifted copy.
+        return false;
+    }
+}
+function unlinkIfPresent(filePath, fileSystem) {
+    try {
+        fileSystem.unlinkSync(filePath);
+    }
+    catch (caught) {
+        const code = caught && typeof caught === "object" && "code" in caught
+            ? caught.code
+            : undefined;
+        if (code !== "ENOENT")
+            throw caught;
+    }
+}
+function forceSymlink(target, filePath, fileSystem) {
+    unlinkIfPresent(filePath, fileSystem);
+    fileSystem.symlinkSync(target, filePath);
+}
+function runtimeScriptPath(dependencies) {
+    return dependencies.scriptPath ?? resolveBundledAsset(WORKER_SKILL_SHARE_ASSET);
+}
+export function runWorkerSkillShare(argv, dependencies) {
+    let apply = false;
+    let force = false;
+    const args = [];
+    for (const value of argv) {
+        if (value === "--apply")
+            apply = true;
+        else if (value === "--force")
+            force = true;
+        else if (value.startsWith("-"))
+            return error(`unknown flag: ${value}`);
+        else
+            args.push(value);
+    }
+    if (args.length < 3) {
+        return error(WORKER_SKILL_SHARE_USAGE.replace("$0", runtimeScriptPath(dependencies)).trimEnd());
+    }
+    const { root, env, fs: fileSystem } = resolveWorkerCallerRoot(dependencies);
+    const scopeDir = removeOneTrailingSlash(args[0]);
+    const skillName = args[1];
+    const workerPaths = args.slice(2);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(skillName)) {
+        return error(`error: skill-name '${skillName}' is not a bare skill name (no slashes, no .md)`);
+    }
+    if (scopeDir === "" || !isDirectory(path.resolve(root, scopeDir), fileSystem)) {
+        return error(`error: scope dir does not exist: ${scopeDir}`);
+    }
+    const canonical = `${scopeDir}/_shared-skills/${skillName}.md`;
+    const canonicalPath = path.resolve(root, canonical);
+    for (const originalPath of workerPaths) {
+        const workerPath = stripOneDotSlash(originalPath);
+        if (!isUnderScope(workerPath, scopeDir)) {
+            return error(`error: worker path '${workerPath}' is not under scope dir '${scopeDir}'\n       canonical must live in the narrowest scope covering all sharers;\n       cross-scope symlinks are disallowed. Aborting (no changes made).`);
+        }
+    }
+    const output = [`Canonical: ${canonical}`, `Scope:     ${scopeDir}`];
+    if (!apply)
+        output.push("(dry run — pass --apply to make changes)");
+    const note = (message) => { output.push(message); };
+    const would = (message) => {
+        note(apply ? `  did:   ${message}` : `  would: ${message}`);
+    };
+    const canonicalIsReusable = existsFollowingLinks(canonicalPath, fileSystem) && !isSymlink(canonicalPath, fileSystem);
+    if (canonicalIsReusable) {
+        note("canonical already exists (regular file) — reusing it");
+    }
+    else {
+        const seed = workerPaths.find((workerPath) => isRegularFile(path.resolve(root, stripOneDotSlash(workerPath)), fileSystem));
+        if (seed === undefined) {
+            return {
+                ...error("error: no canonical exists and no worker path is a regular file to seed it from"),
+                stdout: `${output.join("\n")}\n`,
+            };
+        }
+        would(`mkdir -p ${scopeDir}/_shared-skills`);
+        would(`git mv ${seed} ${canonical}  (promote first copy to canonical)`);
+        if (apply) {
+            try {
+                fileSystem.mkdirSync(path.resolve(root, `${scopeDir}/_shared-skills`), { recursive: true });
+            }
+            catch (caught) {
+                return toolFailure(output, "mkdir", `${scopeDir}/_shared-skills`, caught);
+            }
+            let moved;
+            try {
+                moved = runGit(["mv", seed, canonical], root, env, dependencies.runGit);
+            }
+            catch (caught) {
+                if (errorCode(caught) === undefined)
+                    throw caught;
+                moved = { code: 127, stdout: "" };
+            }
+            if (moved.code !== 0) {
+                try {
+                    fileSystem.renameSync(path.resolve(root, stripOneDotSlash(seed)), canonicalPath);
+                }
+                catch (caught) {
+                    return toolFailure(output, "mv", seed, caught, canonical);
+                }
+            }
+        }
+    }
+    for (const originalPath of workerPaths) {
+        const workerPath = stripOneDotSlash(originalPath);
+        const targetDir = path.posix.dirname(workerPath);
+        const relative = relativePath(targetDir, canonical);
+        const absoluteWorkerPath = path.resolve(root, workerPath);
+        if (isSymlink(absoluteWorkerPath, fileSystem)) {
+            const current = readLink(absoluteWorkerPath, fileSystem);
+            if (current === relative) {
+                note(`ok: ${workerPath} already links to canonical`);
+                continue;
+            }
+            would(`relink ${workerPath} -> ${relative} (was: ${current})`);
+            if (apply) {
+                try {
+                    forceSymlink(relative, absoluteWorkerPath, fileSystem);
+                }
+                catch (caught) {
+                    return toolFailure(output, "ln", workerPath, caught);
+                }
+            }
+            continue;
+        }
+        if (existsFollowingLinks(absoluteWorkerPath, fileSystem)) {
+            if (sameBytes(absoluteWorkerPath, canonicalPath, fileSystem)) {
+                would(`replace identical copy ${workerPath} with symlink -> ${relative}`);
+                if (apply) {
+                    try {
+                        unlinkIfPresent(absoluteWorkerPath, fileSystem);
+                    }
+                    catch (caught) {
+                        return toolFailure(output, "rm", workerPath, caught);
+                    }
+                    try {
+                        fileSystem.symlinkSync(relative, absoluteWorkerPath);
+                    }
+                    catch (caught) {
+                        return toolFailure(output, "ln", workerPath, caught);
+                    }
+                }
+            }
+            else if (force) {
+                would(`FORCE replace DRIFTED copy ${workerPath} with symlink -> ${relative} (content discarded)`);
+                if (apply) {
+                    try {
+                        unlinkIfPresent(absoluteWorkerPath, fileSystem);
+                    }
+                    catch (caught) {
+                        return toolFailure(output, "rm", workerPath, caught);
+                    }
+                    try {
+                        fileSystem.symlinkSync(relative, absoluteWorkerPath);
+                    }
+                    catch (caught) {
+                        return toolFailure(output, "ln", workerPath, caught);
+                    }
+                }
+            }
+            else {
+                return {
+                    code: 3,
+                    stdout: `${output.join("\n")}\n`,
+                    stderr: `  DRIFT: ${workerPath} differs from canonical — reconcile by hand, then re-run\n         (diff ${workerPath} ${canonical}), or pass --force to accept canonical.\n`,
+                };
+            }
+        }
+        else {
+            would(`create symlink ${workerPath} -> ${relative}`);
+            if (apply) {
+                try {
+                    fileSystem.mkdirSync(path.resolve(root, targetDir), { recursive: true });
+                }
+                catch (caught) {
+                    return toolFailure(output, "mkdir", targetDir, caught);
+                }
+                try {
+                    fileSystem.symlinkSync(relative, absoluteWorkerPath);
+                }
+                catch (caught) {
+                    return toolFailure(output, "ln", workerPath, caught);
+                }
+            }
+        }
+    }
+    output.push("done.");
+    return { code: 0, stdout: `${output.join("\n")}\n`, stderr: "" };
+}
+//# sourceMappingURL=core-worker-share-native.js.map

package/dist/commands/core-worker-skills-command.d.ts

@@ -0,0 +1,8 @@
+export type WorkerSkillCommandName = "lint" | "share";
+export type WorkerSkillCommandContext = {
+    cwd: string;
+    hqRoot?: string;
+};
+/** Keep the shell rollback route byte-transparent while the family flag is off. */
+export declare function runWorkerSkillCommand(name: WorkerSkillCommandName, args: string[], context: WorkerSkillCommandContext): Promise<number>;
+//# sourceMappingURL=core-worker-skills-command.d.ts.map

package/dist/commands/core-worker-skills-command.js

@@ -0,0 +1,33 @@
+import { runBundledScript } from "../utils/run-bundled-script.js";
+import { coreNativeWorkerSkillsEnabled } from "./core-native-worker-skills-flag.js";
+import { runWorkerSkillLint, WORKER_SKILL_LINT_ASSET } from "./core-worker-lint-native.js";
+import { runWorkerSkillShare, WORKER_SKILL_SHARE_ASSET } from "./core-worker-share-native.js";
+const assets = {
+    lint: WORKER_SKILL_LINT_ASSET,
+    share: WORKER_SKILL_SHARE_ASSET,
+};
+/** Keep the shell rollback route byte-transparent while the family flag is off. */
+export async function runWorkerSkillCommand(name, args, context) {
+    if (!(await coreNativeWorkerSkillsEnabled())) {
+        const result = runBundledScript({
+            asset: assets[name],
+            args,
+            cwd: context.cwd,
+            hqRoot: context.hqRoot,
+        });
+        if (result.code !== 0)
+            process.exit(result.code);
+        return result.code;
+    }
+    const result = name === "lint"
+        ? runWorkerSkillLint(args, { cwd: context.cwd })
+        : runWorkerSkillShare(args, { cwd: context.cwd });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.code !== 0)
+        process.exit(result.code);
+    return result.code;
+}
+//# sourceMappingURL=core-worker-skills-command.js.map

package/dist/commands/core-worker-skills-runtime.d.ts

@@ -0,0 +1,33 @@
+import * as fs from "node:fs";
+export type WorkerSkillResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export type WorkerSkillFs = Pick<typeof fs, "lstatSync" | "statSync" | "readdirSync" | "readFileSync" | "readlinkSync" | "existsSync" | "mkdirSync" | "renameSync" | "unlinkSync" | "symlinkSync">;
+export type GitResult = {
+    code: number;
+    stdout: string;
+};
+export type GitRunner = (args: string[], cwd: string, env: NodeJS.ProcessEnv) => GitResult;
+export type WorkerSkillDependencies = {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    fs?: WorkerSkillFs;
+    runGit?: GitRunner;
+    /** The bundled shell's absolute $0, used for byte-identical usage text. */
+    scriptPath?: string;
+};
+export declare function runGit(args: string[], cwd: string, env: NodeJS.ProcessEnv, injected?: GitRunner): GitResult;
+/** Match `git rev-parse --show-toplevel || pwd` without consulting HQ_ROOT. */
+export declare function resolveWorkerCallerRoot(dependencies: WorkerSkillDependencies): {
+    root: string;
+    env: NodeJS.ProcessEnv;
+    fs: WorkerSkillFs;
+};
+export declare function errorCode(error: unknown): string | undefined;
+export declare function missingOrUnreadable(error: unknown): boolean;
+export declare function isDirectory(filePath: string, fileSystem: WorkerSkillFs): boolean;
+export declare function isSymlink(filePath: string, fileSystem: WorkerSkillFs): boolean;
+export declare function existsFollowingLinks(filePath: string, fileSystem: WorkerSkillFs): boolean;
+//# sourceMappingURL=core-worker-skills-runtime.d.ts.map

package/dist/commands/core-worker-skills-runtime.js

@@ -0,0 +1,86 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+const SYSTEM_FS = fs;
+function processGit(args, cwd, env) {
+    // Tests that set this marker must inject a runner. This guard catches an
+    // accidental escape from a synthetic fixture before any real executable can
+    // be reached through PATH.
+    if (env.HQ_CORE_STUBS === "1") {
+        throw new Error("real git execution is disabled while HQ_CORE_STUBS=1");
+    }
+    const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
+    return {
+        code: result.status ?? 127,
+        stdout: result.stdout ?? "",
+    };
+}
+export function runGit(args, cwd, env, injected) {
+    return (injected ?? processGit)(args, cwd, env);
+}
+function shellPwd(cwd, env, fileSystem) {
+    const logical = env.PWD;
+    if (!logical || !logical.startsWith("/"))
+        return cwd;
+    try {
+        const logicalStat = fileSystem.statSync(logical);
+        const cwdStat = fileSystem.statSync(cwd);
+        if (logicalStat.dev === cwdStat.dev && logicalStat.ino === cwdStat.ino)
+            return logical;
+    }
+    catch {
+        // Bash falls back to its physical cwd when PWD no longer names this inode.
+    }
+    return cwd;
+}
+/** Match `git rev-parse --show-toplevel || pwd` without consulting HQ_ROOT. */
+export function resolveWorkerCallerRoot(dependencies) {
+    const env = dependencies.env ?? process.env;
+    const fileSystem = dependencies.fs ?? SYSTEM_FS;
+    const git = runGit(["rev-parse", "--show-toplevel"], dependencies.cwd, env, dependencies.runGit);
+    if (git.code === 0) {
+        // Command substitution removes every trailing LF and no other whitespace.
+        return { root: git.stdout.replace(/\n+$/, ""), env, fs: fileSystem };
+    }
+    return { root: shellPwd(dependencies.cwd, env, fileSystem), env, fs: fileSystem };
+}
+export function errorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
+}
+export function missingOrUnreadable(error) {
+    return ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(errorCode(error) ?? "");
+}
+export function isDirectory(filePath, fileSystem) {
+    try {
+        return fileSystem.statSync(filePath).isDirectory();
+    }
+    catch (error) {
+        if (missingOrUnreadable(error))
+            return false;
+        throw error;
+    }
+}
+export function isSymlink(filePath, fileSystem) {
+    try {
+        return fileSystem.lstatSync(filePath).isSymbolicLink();
+    }
+    catch (error) {
+        if (missingOrUnreadable(error))
+            return false;
+        throw error;
+    }
+}
+export function existsFollowingLinks(filePath, fileSystem) {
+    try {
+        fileSystem.statSync(filePath);
+        return true;
+    }
+    catch (error) {
+        if (missingOrUnreadable(error))
+            return false;
+        throw error;
+    }
+}
+//# sourceMappingURL=core-worker-skills-runtime.js.map

package/dist/commands/core.js

@@ -65,6 +65,7 @@ import { readSentryReportStdin, reportSentryEvent } from "../lib/core-utils/sent
 import { CLEAN_HANDOFF_ASSET, RESUME_LOCK_ASSET, VERIFY_DELIVERABLES_ASSET, WORKTREE_GC_ASSET, runCleanWorktreeReconcileHandoff, runResumeThreadLock, runVerifyStoryDeliverables, runWorktreeGc, } from "../lib/core-utils/worktree-resume.js";
 import { coreNativeHandoffEnabled } from "./core-native-handoff-flag.js";
 import { coreCompanyIndexScopeEnabled } from "./core-company-index-scope-flag.js";
+import { runWorkerSkillCommand } from "./core-worker-skills-command.js";
 import { describeCoreCommand, registeredCoreCommandListing, } from "./core-command-catalog.js";
 /**
  * These commands are now native implementations. Their retained shell assets
@@ -357,6 +358,7 @@ export function registerCoreCommands(program) {
     const core = program
         .command("core", { hidden: true })
         .description("HQ scaffold scripts hosted by the CLI (core; not a stable surface)")
+        .addHelpText("afterAll", "exact-company-directory-match-v1")
         // The root override lives on the GROUP, not the subcommands, so it can never
         // collide with a wrapped script's own flags — everything after the
         // subcommand name is passed through untouched.
@@ -478,10 +480,10 @@ export function registerCoreCommands(program) {
             .allowExcessArguments()
             .helpOption(false)
             .argument("[args...]", "arguments passed through to the script")
-            .action((args = [], _opts, cmd) => {
+            .action(async (args = [], _opts, cmd) => {
             const scope = core.opts();
             const operands = cmd.args.length > 0 ? cmd.args : args;
-            runEntry(entry, scope, operands);
+            await runWorkerSkillCommand(entry.name, operands, resolveEntryRoot(entry, scope));
         });
         describeCoreCommand(command, {
             execution: interpreterFor(entry.asset) === "node" ? "bundled-node" : "bundled-shell",

package/dist/commands/dm.d.ts

@@ -71,7 +71,7 @@ export interface ChannelMember {
     handle?: string;
 }
 /** A structured mention as the POST messages route expects it. */
-export interface ChannelMention {
+interface ChannelMention {
     participantUid: string;
     participantType: "agent" | "human";
     displayName: string;
@@ -133,7 +133,7 @@ export declare function resolveMentions(tokens: string[], members: ChannelMember
  * Returns null on anything that doesn't match. Pure → unit-testable.
  */
 export declare function parseDuration(input: string): number | null;
-export type DmAudience = "human" | "agent" | "both";
+type DmAudience = "human" | "agent" | "both";
 export interface DmSendBody {
     toEmail?: string;
     toPersonUid?: string;
@@ -321,7 +321,6 @@ export interface CallerIdentity {
  * Pure → unit-testable.
  */
 export declare function callerFromToken(token: string): CallerIdentity;
-export declare function isCallerMessage(m: ChannelMessageItem, me: CallerIdentity): boolean;
 /**
  * Newest-first channel history → the caller's most recent top-level eventId.
  * Replies (those with rootEventId) are skipped. Pure → unit-testable.
@@ -366,9 +365,6 @@ export declare function formatChannelTranscript(messages: ChannelMessageItem[],
  */
 export declare function agentCallerUid(token: string, machine?: () => boolean): string | null;
 export declare const AGENT_THREAD_UNAVAILABLE: string;
-/** One-line summary of an agent inbox item (DM, email, … — shapes vary by channel). Pure. */
-export declare function formatAgentInboxItem(item: Record<string, unknown>): string;
-/** Remove delegated execution context before agent inbox items can be emitted. */
-export declare function redactAgentInboxItem<T extends object>(item: T): Omit<T, "actingContext">;
 export declare function registerDmCommand(program: Command): void;
+export {};
 //# sourceMappingURL=dm.d.ts.map