@indigoai-us/hq-cli 5.125.0 → 5.127.0

package/dist/lib/lanes/registry.d.ts

@@ -0,0 +1,116 @@
+/**
+ * HQ worker resolution for lanes (spec §5.3).
+ *
+ * Tenancy derives from the registry entry's `path:` prefix, never from the
+ * optional `company:` field. A company path with a missing or contradictory
+ * `company:` is `worker_tenancy_unresolved`, never a global worker.
+ *
+ * Personal workers are indexed by the registry generator when they have a
+ * worker.yaml. A personal directory that exists without one fails by name
+ * and does not fall through to a same-named entry in another tree.
+ *
+ * Package workers are not a fourth generator scan root. `hq core
+ * scan-packages` mounts a declared `contributes.workers` entry into
+ * `core/workers/public/<item>` (a symlink; origin/main writes that link
+ * relative to the host directory, this branch still writes it absolute).
+ * The generator then indexes the mount, and `packAttribution` keeps
+ * recognising it by realpath. Scanning `core/packages` as well would
+ * double-register that mount. A pack that declares a worker whose symlink
+ * is missing fails with `package_workers_unmounted` instead of resolving
+ * some other tree's copy. Tenancy for a mount follows the package: global
+ * when package.yaml has no company and access is public (or omitted),
+ * company-owned when package.yaml names `company`, and
+ * `worker_tenancy_unresolved` when that cannot be determined.
+ */
+import * as fs from "node:fs";
+export declare const WORKER_REGISTRY_REL: string;
+export interface RegistryWorkerEntry {
+    id: string;
+    path: string;
+    type: string;
+    visibility?: string;
+    company?: string;
+    team?: string;
+    status?: string;
+    description?: string;
+}
+export type WorkerTenancy = {
+    kind: "global";
+} | {
+    kind: "company";
+    slug: string;
+};
+export interface WorkerYamlSkill {
+    id?: string;
+    file: string;
+}
+export interface WorkerYaml {
+    worker?: {
+        id?: string;
+        name?: string;
+        description?: string;
+        type?: string;
+        company?: string;
+        status?: string;
+    };
+    instructions?: unknown;
+    skills?: WorkerYamlSkill[];
+    context?: {
+        base?: string[];
+    };
+    knowledge?: unknown;
+    verification?: {
+        approval_required?: boolean;
+        human_checkpoints?: unknown;
+    };
+    execution?: {
+        max_runtime?: unknown;
+        model?: unknown;
+        codex_model?: unknown;
+        codex_flags?: unknown;
+    };
+}
+export interface ResolvedLaneWorker {
+    id: string;
+    path: string;
+    type: string;
+    status: string;
+    visibility?: string;
+    description?: string;
+    tenancy: WorkerTenancy;
+    workerYaml: WorkerYaml;
+    workerDir: string;
+    resolvedContextBase: string[];
+    skillFiles: string[];
+    defaultTimeout: unknown;
+    approvalRequired: boolean;
+    humanCheckpoints: string[];
+    /** Set when the worker's realpath lives in a package. */
+    pack?: string;
+}
+export interface RegistryDeps {
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string, encoding: "utf8") => string;
+    statSync: (p: string) => fs.Stats;
+}
+export declare function registryPath(hqRoot: string): string;
+export declare function personalWorkerDir(hqRoot: string, workerId: string): string;
+export declare function personalWorkerExists(hqRoot: string, workerId: string, deps?: RegistryDeps): boolean;
+export declare function readWorkerRegistryFile(hqRoot: string, deps?: RegistryDeps): RegistryWorkerEntry[];
+/**
+ * Tenancy from path, not from `company:`. A company path whose field is
+ * missing or disagrees is unresolved — never global.
+ */
+export declare function tenancyFromRegistryPath(entry: RegistryWorkerEntry): WorkerTenancy | {
+    kind: "unresolved";
+    pathSlug: string;
+    field?: string;
+};
+/**
+ * Resolve context.base against HQ root, then core/, then the worker directory.
+ * Entries that resolve nowhere are dropped, not passed on.
+ */
+export declare function resolveContextBasePaths(hqRoot: string, workerDir: string, bases: string[] | undefined, deps?: RegistryDeps): string[];
+export declare function resolveSkillFiles(workerDir: string, skills: WorkerYamlSkill[] | undefined, deps?: RegistryDeps): string[];
+export declare function resolveLaneWorker(hqRoot: string, workerId: string, laneCompany: string | undefined, deps?: RegistryDeps): ResolvedLaneWorker;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/lanes/registry.js

@@ -0,0 +1,521 @@
+/**
+ * HQ worker resolution for lanes (spec §5.3).
+ *
+ * Tenancy derives from the registry entry's `path:` prefix, never from the
+ * optional `company:` field. A company path with a missing or contradictory
+ * `company:` is `worker_tenancy_unresolved`, never a global worker.
+ *
+ * Personal workers are indexed by the registry generator when they have a
+ * worker.yaml. A personal directory that exists without one fails by name
+ * and does not fall through to a same-named entry in another tree.
+ *
+ * Package workers are not a fourth generator scan root. `hq core
+ * scan-packages` mounts a declared `contributes.workers` entry into
+ * `core/workers/public/<item>` (a symlink; origin/main writes that link
+ * relative to the host directory, this branch still writes it absolute).
+ * The generator then indexes the mount, and `packAttribution` keeps
+ * recognising it by realpath. Scanning `core/packages` as well would
+ * double-register that mount. A pack that declares a worker whose symlink
+ * is missing fails with `package_workers_unmounted` instead of resolving
+ * some other tree's copy. Tenancy for a mount follows the package: global
+ * when package.yaml has no company and access is public (or omitted),
+ * company-owned when package.yaml names `company`, and
+ * `worker_tenancy_unresolved` when that cannot be determined.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseUserYaml } from "../../utils/user-yaml-error.js";
+import { readContributes } from "../scan-packages/index.js";
+import { contributionLinks, linkStatus, } from "../../utils/pack-contributions.js";
+import { WorkerResolutionError } from "./errors.js";
+export const WORKER_REGISTRY_REL = path.join("core", "workers", "registry.yaml");
+function defaultRegistryDeps() {
+    return {
+        existsSync: (p) => fs.existsSync(p),
+        readFileSync: (p, encoding) => fs.readFileSync(p, encoding),
+        statSync: (p) => fs.statSync(p),
+    };
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function registryPath(hqRoot) {
+    return path.join(hqRoot, WORKER_REGISTRY_REL);
+}
+export function personalWorkerDir(hqRoot, workerId) {
+    return path.join(hqRoot, "personal", "workers", workerId);
+}
+function isExistingPath(p, deps) {
+    try {
+        const st = deps.statSync(p);
+        return st.isFile() || st.isDirectory();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+export function personalWorkerExists(hqRoot, workerId, deps = defaultRegistryDeps()) {
+    const yamlPath = path.join(personalWorkerDir(hqRoot, workerId), "worker.yaml");
+    try {
+        return deps.statSync(yamlPath).isFile();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+export function readWorkerRegistryFile(hqRoot, deps = defaultRegistryDeps()) {
+    const filePath = registryPath(hqRoot);
+    if (!deps.existsSync(filePath)) {
+        throw new WorkerResolutionError("worker_registry_unreadable", `Worker registry missing at ${filePath}`, { path: filePath });
+    }
+    let text;
+    try {
+        text = deps.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        throw new WorkerResolutionError("worker_registry_unreadable", `Failed to read ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
+    }
+    const doc = parseUserYaml(text, filePath);
+    const workers = doc?.workers;
+    if (!Array.isArray(workers)) {
+        throw new WorkerResolutionError("worker_registry_unreadable", `Worker registry workers key is missing or not an array at ${filePath}`, { path: filePath });
+    }
+    const entries = [];
+    for (let i = 0; i < workers.length; i += 1) {
+        const item = workers[i];
+        if (!isPlainObject(item)) {
+            process.stderr.write(`lanes registry: skipping malformed worker entry in ${filePath} at index ${i}: not an object (type=${typeof item})\n`);
+            continue;
+        }
+        if (typeof item.id !== "string" ||
+            item.id.length === 0 ||
+            typeof item.path !== "string" ||
+            item.path.length === 0) {
+            process.stderr.write(`lanes registry: skipping malformed worker entry in ${filePath} at index ${i}: missing id or path (id=${JSON.stringify(item.id)} path=${JSON.stringify(item.path)})\n`);
+            continue;
+        }
+        entries.push({
+            id: item.id,
+            path: item.path,
+            type: typeof item.type === "string" ? item.type : "",
+            visibility: typeof item.visibility === "string" ? item.visibility : undefined,
+            company: typeof item.company === "string" ? item.company : undefined,
+            team: typeof item.team === "string" ? item.team : undefined,
+            status: typeof item.status === "string" ? item.status : undefined,
+            description: typeof item.description === "string" ? item.description : undefined,
+        });
+    }
+    return entries;
+}
+const COMPANY_PATH = /^companies\/([^/]+)\//;
+const PERSONAL_PATH = /^(?:personal\/workers\/)/;
+const CORE_PATH = /^(?:core\/workers\/)/;
+/**
+ * Tenancy from path, not from `company:`. A company path whose field is
+ * missing or disagrees is unresolved — never global.
+ */
+export function tenancyFromRegistryPath(entry) {
+    const normalized = entry.path.replaceAll("\\", "/");
+    // personal/workers is the operator's tree, not a tenant. Path still wins
+    // over a company: field, which is ignored here.
+    if (PERSONAL_PATH.test(normalized)) {
+        return { kind: "global" };
+    }
+    const companyMatch = COMPANY_PATH.exec(normalized);
+    if (companyMatch) {
+        const pathSlug = companyMatch[1] ?? "";
+        if (!pathSlug) {
+            return { kind: "unresolved", pathSlug, field: entry.company };
+        }
+        const field = entry.company?.trim() ?? "";
+        if (!field || field !== pathSlug) {
+            return { kind: "unresolved", pathSlug, field: field || undefined };
+        }
+        return { kind: "company", slug: pathSlug };
+    }
+    if (CORE_PATH.test(normalized) || normalized.startsWith("core/")) {
+        return { kind: "global" };
+    }
+    // Unknown tree: do not treat as global.
+    return { kind: "unresolved", pathSlug: "", field: entry.company };
+}
+function loadWorkerYaml(hqRoot, relativeDir, deps) {
+    const dir = path.join(hqRoot, relativeDir);
+    const filePath = path.join(dir, "worker.yaml");
+    if (!deps.existsSync(filePath)) {
+        throw new WorkerResolutionError("worker_not_found", `worker.yaml missing at ${filePath}`, { path: filePath });
+    }
+    const text = deps.readFileSync(filePath, "utf8");
+    const doc = parseUserYaml(text, filePath);
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        return {};
+    }
+    return doc;
+}
+/**
+ * Resolve context.base against HQ root, then core/, then the worker directory.
+ * Entries that resolve nowhere are dropped, not passed on.
+ */
+export function resolveContextBasePaths(hqRoot, workerDir, bases, deps = defaultRegistryDeps()) {
+    if (!Array.isArray(bases) || bases.length === 0)
+        return [];
+    const resolved = [];
+    for (const entry of bases) {
+        if (typeof entry !== "string" || entry.length === 0)
+            continue;
+        const candidates = [
+            path.isAbsolute(entry) ? entry : path.join(hqRoot, entry),
+            path.join(hqRoot, "core", entry),
+            path.join(workerDir, entry),
+        ];
+        const hit = candidates.find((candidate) => isExistingPath(candidate, deps));
+        if (hit)
+            resolved.push(hit);
+    }
+    return resolved;
+}
+export function resolveSkillFiles(workerDir, skills, deps = defaultRegistryDeps()) {
+    if (!Array.isArray(skills) || skills.length === 0)
+        return [];
+    const files = [];
+    for (const skill of skills) {
+        if (!skill || typeof skill.file !== "string" || skill.file.length === 0) {
+            continue;
+        }
+        const candidate = path.isAbsolute(skill.file)
+            ? skill.file
+            : path.join(workerDir, skill.file);
+        if (isExistingPath(candidate, deps))
+            files.push(candidate);
+    }
+    return files;
+}
+function humanCheckpointsOf(yaml) {
+    const raw = yaml.verification?.human_checkpoints;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => typeof item === "string");
+}
+function normalizeRel(value) {
+    const norm = value.replaceAll("\\", "/").replace(/\/+$/, "");
+    return norm.length > 0 ? `${norm}/` : norm;
+}
+function realpathOf(hqRoot, relativeDir) {
+    const abs = path.join(hqRoot, relativeDir.replace(/\/+$/, ""));
+    try {
+        return fs.realpathSync(abs);
+    }
+    catch {
+        return abs;
+    }
+}
+function workerIdInYaml(filePath, deps) {
+    if (!deps.existsSync(filePath))
+        return null;
+    let doc;
+    try {
+        doc = parseUserYaml(deps.readFileSync(filePath, "utf8"), filePath);
+    }
+    catch {
+        return null;
+    }
+    if (!isPlainObject(doc) || !isPlainObject(doc.worker))
+        return null;
+    const worker = doc.worker;
+    const id = typeof worker.id === "string" ? worker.id.trim() : "";
+    if (!id)
+        return null;
+    return {
+        id,
+        company: typeof worker.company === "string" ? worker.company : undefined,
+        status: typeof worker.status === "string" ? worker.status : undefined,
+        type: typeof worker.type === "string" ? worker.type : undefined,
+        description: typeof worker.description === "string" ? worker.description : undefined,
+    };
+}
+/**
+ * A personal directory with files but no worker.yaml claims the id. An
+ * empty directory is a leftover and does not.
+ */
+function personalDirClaim(hqRoot, workerId, deps) {
+    const dir = personalWorkerDir(hqRoot, workerId);
+    let st;
+    try {
+        st = deps.statSync(dir);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return "none";
+        throw err;
+    }
+    if (!st.isDirectory())
+        return "none";
+    const yamlPath = path.join(dir, "worker.yaml");
+    try {
+        if (deps.statSync(yamlPath).isFile())
+            return "yaml";
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT")
+            throw err;
+    }
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return "none";
+    }
+    const rest = names.filter((name) => name !== "worker.yaml");
+    return rest.length > 0 ? "missing_yaml" : "none";
+}
+function packNameFromRealpath(hqRoot, real) {
+    const rel = path.relative(hqRoot, real).replaceAll("\\", "/");
+    const match = /^core\/packages\/([^/]+)\//.exec(rel);
+    return match?.[1] ?? null;
+}
+function declaredPackWorkers(hqRoot, deps) {
+    const packagesDir = path.join(hqRoot, "core", "packages");
+    if (!deps.existsSync(packagesDir))
+        return [];
+    let names;
+    try {
+        names = fs.readdirSync(packagesDir);
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const pack of names) {
+        if (pack.startsWith("."))
+            continue;
+        const packDir = path.join(packagesDir, pack);
+        const manifest = path.join(packDir, "package.yaml");
+        if (!deps.existsSync(manifest))
+            continue;
+        let contributes;
+        try {
+            contributes = readContributes(manifest);
+        }
+        catch {
+            continue;
+        }
+        for (const link of contributionLinks(hqRoot, packDir, contributes)) {
+            if (link.key !== "workers")
+                continue;
+            const fields = workerIdInYaml(path.join(link.src, "worker.yaml"), deps);
+            found.push({ pack, item: link.item, link, workerId: fields?.id ?? null });
+        }
+    }
+    return found;
+}
+function declarationMatches(row, workerId) {
+    return row.workerId === workerId || row.item === workerId;
+}
+/**
+ * A package is global unless it declares company ownership. `company: <slug>`
+ * in package.yaml is that declaration. No company and access public (or
+ * access omitted, which is how the shipped public packs read) is global.
+ * A missing manifest, a non-string company, a private access with no slug,
+ * or a worker.yaml company that disagrees with the package is unresolved.
+ */
+function tenancyFromPackage(hqRoot, pack, workerCompany, deps) {
+    const manifest = path.join(hqRoot, "core", "packages", pack, "package.yaml");
+    if (!deps.existsSync(manifest)) {
+        return { kind: "unresolved", pathSlug: "", field: undefined };
+    }
+    let doc;
+    try {
+        doc = parseUserYaml(deps.readFileSync(manifest, "utf8"), manifest);
+    }
+    catch {
+        return { kind: "unresolved", pathSlug: "", field: undefined };
+    }
+    if (!isPlainObject(doc)) {
+        return { kind: "unresolved", pathSlug: "", field: undefined };
+    }
+    const access = typeof doc.access === "string" ? doc.access.trim() : "";
+    if (doc.company !== undefined) {
+        if (typeof doc.company !== "string" || doc.company.trim().length === 0) {
+            return {
+                kind: "unresolved",
+                pathSlug: "",
+                field: typeof doc.company === "string" ? doc.company : undefined,
+            };
+        }
+        const slug = doc.company.trim();
+        const field = workerCompany?.trim() ?? "";
+        if (field && field !== slug) {
+            return { kind: "unresolved", pathSlug: slug, field };
+        }
+        return { kind: "company", slug };
+    }
+    if (access === "" || access === "public")
+        return { kind: "global" };
+    return { kind: "unresolved", pathSlug: "", field: access };
+}
+function readRegistryOrEmpty(hqRoot, deps) {
+    if (!deps.existsSync(registryPath(hqRoot)))
+        return [];
+    return readWorkerRegistryFile(hqRoot, deps);
+}
+export function resolveLaneWorker(hqRoot, workerId, laneCompany, deps = defaultRegistryDeps()) {
+    const personalRel = path.posix.join("personal", "workers", workerId);
+    const personalClaim = personalDirClaim(hqRoot, workerId, deps);
+    if (personalClaim === "missing_yaml") {
+        throw new WorkerResolutionError("worker_not_found", `Worker ${JSON.stringify(workerId)} is at ${personalRel}/ but worker.yaml is missing`, { worker: workerId, path: `${personalRel}/`, missing: "worker.yaml" });
+    }
+    const entries = readRegistryOrEmpty(hqRoot, deps);
+    const candidates = [];
+    for (const entry of entries) {
+        if (entry.id !== workerId)
+            continue;
+        const rel = normalizeRel(entry.path);
+        candidates.push({
+            id: entry.id,
+            path: rel,
+            type: entry.type,
+            status: entry.status && entry.status.length > 0 ? entry.status : "active",
+            visibility: entry.visibility,
+            description: entry.description,
+            company: entry.company,
+            realpath: realpathOf(hqRoot, rel),
+        });
+    }
+    if (personalClaim === "yaml") {
+        const rel = normalizeRel(personalRel);
+        const real = realpathOf(hqRoot, rel);
+        if (!candidates.some((item) => item.realpath === real)) {
+            const fields = workerIdInYaml(path.join(hqRoot, rel, "worker.yaml"), deps);
+            candidates.push({
+                id: workerId,
+                path: rel,
+                type: fields?.type ?? "",
+                status: fields?.status && fields.status.length > 0 ? fields.status : "active",
+                description: fields?.description,
+                company: fields?.company,
+                realpath: real,
+            });
+        }
+    }
+    const declarations = declaredPackWorkers(hqRoot, deps).filter((row) => declarationMatches(row, workerId));
+    const unmounted = [];
+    for (const row of declarations) {
+        const status = linkStatus(row.link, path.join(hqRoot, "core", "packages", row.pack));
+        if (status !== "live") {
+            unmounted.push(row);
+            continue;
+        }
+        const yamlPath = path.join(row.link.src, "worker.yaml");
+        if (!deps.existsSync(yamlPath)) {
+            throw new WorkerResolutionError("worker_not_found", `Worker ${JSON.stringify(workerId)} is mounted from pack ${row.pack} but worker.yaml is missing`, {
+                worker: workerId,
+                path: path.relative(hqRoot, row.link.dst).replaceAll("\\", "/"),
+                pack: row.pack,
+                missing: "worker.yaml",
+            });
+        }
+        const rel = normalizeRel(path.relative(hqRoot, row.link.dst));
+        const real = realpathOf(hqRoot, rel);
+        if (candidates.some((item) => item.realpath === real))
+            continue;
+        const fields = workerIdInYaml(yamlPath, deps);
+        candidates.push({
+            id: workerId,
+            path: rel,
+            type: fields?.type ?? "",
+            status: fields?.status && fields.status.length > 0 ? fields.status : "active",
+            description: fields?.description,
+            company: fields?.company,
+            realpath: real,
+        });
+    }
+    if (unmounted.length > 0) {
+        const row = unmounted[0];
+        throw new WorkerResolutionError("package_workers_unmounted", `Worker ${JSON.stringify(workerId)} is declared by pack ${row.pack} but ${path.relative(hqRoot, row.link.dst)} is not a symlink to that pack. Run hq core scan-packages, then regenerate the worker registry.`, {
+            worker: workerId,
+            pack: row.pack,
+            item: row.item,
+            expected: path.relative(hqRoot, row.link.dst).replaceAll("\\", "/"),
+            also_registered_at: candidates.map((item) => item.path),
+        });
+    }
+    const distinct = [];
+    for (const candidate of candidates) {
+        if (distinct.some((item) => item.realpath === candidate.realpath))
+            continue;
+        distinct.push(candidate);
+    }
+    if (distinct.length > 1) {
+        throw new WorkerResolutionError("worker_id_conflict", `Worker ${JSON.stringify(workerId)} exists in more than one tree: ${distinct.map((item) => item.path).join(", ")}. Refusing to pick one.`, { worker: workerId, paths: distinct.map((item) => item.path) });
+    }
+    const entry = distinct[0];
+    if (!entry) {
+        throw new WorkerResolutionError("worker_not_found", `Worker ${JSON.stringify(workerId)} is not in core/workers/registry.yaml`, { worker: workerId });
+    }
+    const relativeDir = entry.path.replace(/\/+$/, "");
+    const workerDir = path.join(hqRoot, relativeDir);
+    const workerYaml = loadWorkerYaml(hqRoot, relativeDir, deps);
+    const pack = packNameFromRealpath(hqRoot, entry.realpath);
+    const workerCompany = typeof workerYaml.worker?.company === "string" ? workerYaml.worker.company : entry.company;
+    const tenancy = pack
+        ? tenancyFromPackage(hqRoot, pack, workerCompany, deps)
+        : tenancyFromRegistryPath({
+            id: entry.id,
+            path: entry.path,
+            type: entry.type,
+            company: workerCompany,
+        });
+    if (tenancy.kind === "unresolved") {
+        throw new WorkerResolutionError("worker_tenancy_unresolved", pack
+            ? `Worker ${JSON.stringify(workerId)} is mounted from pack ${pack} whose company ownership cannot be determined`
+            : `Worker ${JSON.stringify(workerId)} has a company path whose company field is missing or contradicts the path`, {
+            worker: workerId,
+            path: entry.path,
+            path_slug: tenancy.pathSlug,
+            company_field: tenancy.field ?? null,
+            ...(pack ? { pack } : {}),
+        });
+    }
+    if (tenancy.kind === "company") {
+        if (!laneCompany || laneCompany !== tenancy.slug) {
+            throw new WorkerResolutionError("worker_not_available", `Worker ${JSON.stringify(workerId)} belongs to company ${tenancy.slug} and is not available to ${laneCompany ?? "(none)"}`, {
+                worker: workerId,
+                worker_company: tenancy.slug,
+                lane_company: laneCompany ?? null,
+            });
+        }
+    }
+    const status = entry.status && entry.status.length > 0 ? entry.status : "active";
+    if (status !== "active") {
+        throw new WorkerResolutionError("worker_not_active", `Worker ${JSON.stringify(workerId)} has status ${JSON.stringify(status)} (need active)`, { worker: workerId, status });
+    }
+    const resolvedContextBase = resolveContextBasePaths(hqRoot, workerDir, workerYaml.context?.base, deps);
+    const skillFiles = resolveSkillFiles(workerDir, workerYaml.skills, deps);
+    return {
+        id: entry.id,
+        path: entry.path,
+        type: entry.type,
+        status,
+        visibility: entry.visibility,
+        description: entry.description,
+        tenancy,
+        workerYaml,
+        workerDir,
+        resolvedContextBase,
+        skillFiles,
+        defaultTimeout: workerYaml.execution?.max_runtime,
+        approvalRequired: workerYaml.verification?.approval_required === true,
+        humanCheckpoints: humanCheckpointsOf(workerYaml),
+        ...(pack ? { pack } : {}),
+    };
+}
+//# sourceMappingURL=registry.js.map