@indigoai-us/hq-cli 5.141.0 → 5.142.0

package/dist/lib/lanes/mesh-events.d.ts

@@ -80,11 +80,10 @@ export interface CreateLaneMeshOptions {
     token?: () => Promise<string>;
 }
 export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
-/** Company + thread present. A core/personal lane (company null) emits nothing. */
-export declare function laneCanEmit(lane: Pick<LaneRecord, "company" | "thread_id">): lane is Pick<LaneRecord, "company" | "thread_id"> & {
-    company: LaneCompanyRef;
-    thread_id: string;
-};
+/** Resolve the explicit mesh attribution before falling back to the lane tenant. */
+export declare function laneMeshCompany(lane: Pick<LaneRecord, "company" | "mesh_company">): LaneCompanyRef | undefined;
+/** Company attribution + thread present. Unscoped personal lanes emit nothing. */
+export declare function laneCanEmit(lane: Pick<LaneRecord, "company" | "mesh_company" | "thread_id">): boolean;
 /**
  * Spec §8 terminal-envelope events. `done` → lane_done and story → review;
  * `blocked` → lane_blocked; `ask` → lane_ask with the queue ids. The story is

package/dist/lib/lanes/mesh-events.js

@@ -186,9 +186,13 @@ export function createLaneMesh(opts = {}) {
         },
     };
 }
-/** Company + thread present. A core/personal lane (company null) emits nothing. */
+/** Resolve the explicit mesh attribution before falling back to the lane tenant. */
+export function laneMeshCompany(lane) {
+    return lane.mesh_company ?? lane.company ?? undefined;
+}
+/** Company attribution + thread present. Unscoped personal lanes emit nothing. */
 export function laneCanEmit(lane) {
-    return lane.company !== null && lane.company !== undefined && !!lane.thread_id;
+    return laneMeshCompany(lane) !== undefined && !!lane.thread_id;
 }
 function baseIdentity(lane) {
     const lastMove = lane.account_history?.[lane.account_history.length - 1];
@@ -209,8 +213,10 @@ function baseIdentity(lane) {
 export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
     if (!laneCanEmit(lane))
         return;
-    const company = lane.company;
+    const company = laneMeshCompany(lane);
     const threadId = lane.thread_id;
+    if (!company || !threadId)
+        return;
     switch (envelope.decision) {
         case "done": {
             const outcomes = await Promise.allSettled([
@@ -260,7 +266,11 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
 export async function emitLaneProgressEvent(mesh, lane, detail, signal) {
     if (!laneCanEmit(lane))
         return;
-    await mesh.appendThreadEvent(lane.company, lane.thread_id, "lane_progress", {
+    const company = laneMeshCompany(lane);
+    const threadId = lane.thread_id;
+    if (!company || !threadId)
+        return;
+    await mesh.appendThreadEvent(company, threadId, "lane_progress", {
         ...baseIdentity(lane),
         detail,
     }, signal);

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

@@ -0,0 +1,48 @@
+/**
+ * Reusable lane worker profiles stored under personal/workers/<id>.
+ *
+ * A profile is deliberately independent from the worker registry. The
+ * registry describes a worker persona that can be resolved from the company
+ * and package trees; this module describes the provider launch contract that
+ * must be re-read for every spawn.
+ */
+import { type LaneProvider } from "./types.js";
+export interface WorkerProfileMeta {
+    version?: string;
+    provider: LaneProvider;
+    model: string;
+    account: string;
+    effort: string;
+    fast_mode: boolean;
+    max_concurrent?: number;
+    source?: string;
+    accounts?: string[];
+}
+export interface WorkerProfile {
+    id: string;
+    dir: string;
+    meta: WorkerProfileMeta;
+    systemPrompt: string;
+    settings?: Record<string, unknown>;
+    policyFiles: string[];
+    hookFiles: string[];
+    contentHash: string;
+}
+export interface WorkerProfileRuntime {
+    settingsPath?: string;
+    hooksDir?: string;
+}
+export declare function personalWorkerProfileDir(hqRoot: string, id: string): string;
+/** A meta.yaml file is the explicit marker for a personal worker profile. */
+export declare function workerProfileMarker(hqRoot: string, id: string): "absent" | "present";
+export declare function loadWorkerProfile(hqRoot: string, id: string): WorkerProfile;
+export declare function workerProfilePrompt(profile: WorkerProfile): string;
+export declare function ignoredWorkerProfileFields(provider: LaneProvider): string[];
+/**
+ * Materialize provider settings and hook files in the lane run directory.
+ * The path is intentionally run-local so every fresh, resumed, moved, and
+ * repair spawn gets the profile currently on disk without mutating an account
+ * home or a shared provider configuration.
+ */
+export declare function materializeWorkerProfile(profile: WorkerProfile, runDir: string): WorkerProfileRuntime;
+//# sourceMappingURL=profile.d.ts.map

package/dist/lib/lanes/profile.js

@@ -0,0 +1,405 @@
+/**
+ * Reusable lane worker profiles stored under personal/workers/<id>.
+ *
+ * A profile is deliberately independent from the worker registry. The
+ * registry describes a worker persona that can be resolved from the company
+ * and package trees; this module describes the provider launch contract that
+ * must be re-read for every spawn.
+ */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseUserYaml } from "../../utils/user-yaml-error.js";
+import { WorkerResolutionError } from "./errors.js";
+import { PROVIDER_EFFORT_LEVELS } from "./effort.js";
+import { LANE_PROVIDERS, isLaneProvider, } from "./types.js";
+const PROFILE_META = "meta.yaml";
+const PROFILE_SYSTEM_PROMPT = "system-prompt.md";
+const PROFILE_SETTINGS = "settings.json";
+const PROFILE_POLICIES = "policies";
+const PROFILE_HOOKS = "hooks";
+const PROFILE_META_KEYS = new Set([
+    "version",
+    "provider",
+    "model",
+    "account",
+    "effort",
+    "fast_mode",
+    "max_concurrent",
+    "source",
+    "accounts",
+]);
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function profileError(id, dir, message, details = {}) {
+    return new WorkerResolutionError("worker_profile_invalid", `Worker profile ${JSON.stringify(id)} at ${dir}: ${message}`, { worker: id, path: dir, ...details });
+}
+function validProfileId(id) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id);
+}
+function lstatOrAbsent(filePath) {
+    try {
+        return fs.lstatSync(filePath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+function requireRegularFile(id, dir, filePath, field) {
+    let stat;
+    try {
+        stat = fs.lstatSync(filePath);
+    }
+    catch (err) {
+        throw profileError(id, dir, `cannot read ${field}: ${err instanceof Error ? err.message : String(err)}`, { field, file: filePath });
+    }
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw profileError(id, dir, `${field} must be a regular file`, {
+            field,
+            file: filePath,
+        });
+    }
+    return stat;
+}
+function readRequiredText(id, dir, filePath, field) {
+    requireRegularFile(id, dir, filePath, field);
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        throw profileError(id, dir, `cannot read ${field}: ${err instanceof Error ? err.message : String(err)}`, { field, file: filePath });
+    }
+}
+function collectFiles(id, dir, relativeDir) {
+    const absoluteDir = path.join(dir, relativeDir);
+    const stat = lstatOrAbsent(absoluteDir);
+    if (stat === null)
+        return [];
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw profileError(id, dir, `${relativeDir} must be a directory`, {
+            field: relativeDir,
+        });
+    }
+    const files = [];
+    const visit = (current, currentRelative) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch (err) {
+            throw profileError(id, dir, `cannot read ${currentRelative}: ${err instanceof Error ? err.message : String(err)}`, { field: currentRelative });
+        }
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            const entryRelative = path.posix.join(currentRelative, entry.name);
+            const entryPath = path.join(dir, entryRelative);
+            if (entry.isSymbolicLink()) {
+                throw profileError(id, dir, `${entryRelative} must not be a symlink`, {
+                    field: entryRelative,
+                });
+            }
+            if (entry.isDirectory()) {
+                visit(entryPath, entryRelative);
+                continue;
+            }
+            if (!entry.isFile()) {
+                throw profileError(id, dir, `${entryRelative} must be a regular file`, {
+                    field: entryRelative,
+                });
+            }
+            files.push(entryRelative);
+        }
+    };
+    visit(absoluteDir, relativeDir);
+    return files.sort((a, b) => a.localeCompare(b));
+}
+function parseMeta(id, dir, raw) {
+    if (!isPlainObject(raw)) {
+        throw profileError(id, dir, "meta.yaml must contain an object");
+    }
+    const unknown = Object.keys(raw).filter((key) => !PROFILE_META_KEYS.has(key));
+    if (unknown.length > 0) {
+        throw profileError(id, dir, `meta.yaml has unknown field(s): ${unknown.join(", ")}`, {
+            fields: unknown,
+        });
+    }
+    const provider = raw.provider;
+    if (typeof provider !== "string" || !isLaneProvider(provider.trim())) {
+        throw profileError(id, dir, "meta.yaml provider must be claude, codex, or grok", {
+            field: "provider",
+            value: provider,
+            accepted: [...LANE_PROVIDERS],
+        });
+    }
+    const providerValue = provider.trim();
+    const requiredString = (field) => {
+        const value = raw[field];
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw profileError(id, dir, `meta.yaml ${field} must be a non-empty string`, {
+                field,
+                value,
+            });
+        }
+        return value.trim();
+    };
+    const model = requiredString("model");
+    const account = requiredString("account");
+    const effort = requiredString("effort");
+    if (!PROVIDER_EFFORT_LEVELS[providerValue].includes(effort)) {
+        throw profileError(id, dir, `meta.yaml effort ${JSON.stringify(effort)} is invalid for ${providerValue}`, {
+            field: "effort",
+            provider: providerValue,
+            value: effort,
+            accepted: [...PROVIDER_EFFORT_LEVELS[providerValue]],
+        });
+    }
+    if (typeof raw.fast_mode !== "boolean") {
+        throw profileError(id, dir, "meta.yaml fast_mode must be a boolean", {
+            field: "fast_mode",
+            value: raw.fast_mode,
+        });
+    }
+    let version;
+    if (raw.version !== undefined) {
+        if (typeof raw.version !== "string" || raw.version.trim().length === 0) {
+            throw profileError(id, dir, "meta.yaml version must be a non-empty string", {
+                field: "version",
+                value: raw.version,
+            });
+        }
+        version = raw.version.trim();
+    }
+    let maxConcurrent;
+    if (raw.max_concurrent !== undefined) {
+        if (typeof raw.max_concurrent !== "number" || !Number.isInteger(raw.max_concurrent) || raw.max_concurrent < 1) {
+            throw profileError(id, dir, "meta.yaml max_concurrent must be a positive integer", {
+                field: "max_concurrent",
+                value: raw.max_concurrent,
+            });
+        }
+        maxConcurrent = raw.max_concurrent;
+    }
+    let source;
+    if (raw.source !== undefined) {
+        if (typeof raw.source !== "string" || raw.source.trim().length === 0) {
+            throw profileError(id, dir, "meta.yaml source must be a non-empty string when present", {
+                field: "source",
+                value: raw.source,
+            });
+        }
+        source = raw.source.trim();
+    }
+    let accounts;
+    if (raw.accounts !== undefined) {
+        if (!Array.isArray(raw.accounts) || raw.accounts.length === 0 || raw.accounts.some((item) => typeof item !== "string" || item.trim().length === 0)) {
+            throw profileError(id, dir, "meta.yaml accounts must be a non-empty string array when present", {
+                field: "accounts",
+                value: raw.accounts,
+            });
+        }
+        accounts = raw.accounts.map((item) => item.trim());
+    }
+    return {
+        ...(version !== undefined ? { version } : {}),
+        provider: providerValue,
+        model,
+        account,
+        effort,
+        fast_mode: raw.fast_mode,
+        ...(maxConcurrent !== undefined ? { max_concurrent: maxConcurrent } : {}),
+        ...(source !== undefined ? { source } : {}),
+        ...(accounts !== undefined ? { accounts } : {}),
+    };
+}
+function readSettings(id, dir) {
+    const filePath = path.join(dir, PROFILE_SETTINGS);
+    const stat = lstatOrAbsent(filePath);
+    if (stat === null)
+        return {};
+    requireRegularFile(id, dir, filePath, PROFILE_SETTINGS);
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (err) {
+        throw profileError(id, dir, `settings.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, {
+            field: PROFILE_SETTINGS,
+        });
+    }
+    if (!isPlainObject(parsed)) {
+        throw profileError(id, dir, "settings.json must contain a JSON object", {
+            field: PROFILE_SETTINGS,
+        });
+    }
+    return { settings: parsed, relative: PROFILE_SETTINGS };
+}
+function hashProfileFiles(dir, relativeFiles) {
+    const hash = createHash("sha256");
+    for (const relative of relativeFiles.sort((a, b) => a.localeCompare(b))) {
+        const file = path.join(dir, relative);
+        hash.update(relative);
+        hash.update("\0");
+        hash.update(fs.readFileSync(file));
+        hash.update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+export function personalWorkerProfileDir(hqRoot, id) {
+    return path.join(hqRoot, "personal", "workers", id);
+}
+/** A meta.yaml file is the explicit marker for a personal worker profile. */
+export function workerProfileMarker(hqRoot, id) {
+    if (!validProfileId(id))
+        return "absent";
+    const dirStat = lstatOrAbsent(personalWorkerProfileDir(hqRoot, id));
+    if (dirStat === null || dirStat.isSymbolicLink() || !dirStat.isDirectory()) {
+        return "absent";
+    }
+    const stat = lstatOrAbsent(path.join(personalWorkerProfileDir(hqRoot, id), PROFILE_META));
+    if (stat === null)
+        return "absent";
+    if (stat.isSymbolicLink() || !stat.isFile())
+        return "present";
+    return "present";
+}
+export function loadWorkerProfile(hqRoot, id) {
+    const dir = personalWorkerProfileDir(hqRoot, id);
+    if (!validProfileId(id)) {
+        throw profileError(id, dir, "profile id must be a simple directory name", {
+            field: "worker",
+        });
+    }
+    const dirStat = lstatOrAbsent(dir);
+    if (dirStat === null) {
+        throw profileError(id, dir, "profile directory does not exist", {
+            field: "profile",
+        });
+    }
+    if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) {
+        throw profileError(id, dir, "profile directory must be a regular directory", {
+            field: "profile",
+        });
+    }
+    const metaPath = path.join(dir, PROFILE_META);
+    const metaStat = lstatOrAbsent(metaPath);
+    if (metaStat === null) {
+        throw new WorkerResolutionError("worker_profile_invalid", `Worker profile ${JSON.stringify(id)} is missing ${metaPath}`, { worker: id, path: dir, missing: PROFILE_META });
+    }
+    const metaText = readRequiredText(id, dir, metaPath, PROFILE_META);
+    let metaRaw;
+    try {
+        metaRaw = parseUserYaml(metaText, metaPath);
+    }
+    catch (err) {
+        throw profileError(id, dir, `meta.yaml is not valid YAML: ${err instanceof Error ? err.message : String(err)}`, {
+            field: PROFILE_META,
+        });
+    }
+    const meta = parseMeta(id, dir, metaRaw);
+    const systemPromptPath = path.join(dir, PROFILE_SYSTEM_PROMPT);
+    const systemPrompt = readRequiredText(id, dir, systemPromptPath, PROFILE_SYSTEM_PROMPT);
+    if (systemPrompt.trim().length === 0) {
+        throw profileError(id, dir, "system-prompt.md must not be empty", {
+            field: PROFILE_SYSTEM_PROMPT,
+        });
+    }
+    const settingsResult = readSettings(id, dir);
+    const policyFiles = collectFiles(id, dir, PROFILE_POLICIES);
+    const hookFiles = collectFiles(id, dir, PROFILE_HOOKS);
+    const hashFiles = [
+        PROFILE_META,
+        PROFILE_SYSTEM_PROMPT,
+        ...(settingsResult.relative ? [settingsResult.relative] : []),
+        ...policyFiles,
+        ...hookFiles,
+    ];
+    return {
+        id,
+        dir,
+        meta,
+        systemPrompt,
+        ...(settingsResult.settings !== undefined ? { settings: settingsResult.settings } : {}),
+        policyFiles,
+        hookFiles,
+        contentHash: hashProfileFiles(dir, hashFiles),
+    };
+}
+export function workerProfilePrompt(profile) {
+    const parts = [profile.systemPrompt.trimEnd()];
+    for (const relative of profile.policyFiles) {
+        const content = readRequiredText(profile.id, profile.dir, path.join(profile.dir, relative), relative);
+        parts.push(`\n## Profile policy: ${relative}\n${content.trimEnd()}`);
+    }
+    return parts.join("\n");
+}
+export function ignoredWorkerProfileFields(provider) {
+    return provider === "claude" ? [] : ["settings", "hooks"];
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Hooks may be flat (`hooks/check.sh`) or grouped by Claude lifecycle event
+ * (`hooks/PreToolUse/check.sh`). Flat hooks run at SessionStart.
+ */
+function profileHookEvent(relative) {
+    const parts = relative.split("/");
+    return parts.length >= 3 && parts[1] ? parts[1] : "SessionStart";
+}
+/**
+ * Materialize provider settings and hook files in the lane run directory.
+ * The path is intentionally run-local so every fresh, resumed, moved, and
+ * repair spawn gets the profile currently on disk without mutating an account
+ * home or a shared provider configuration.
+ */
+export function materializeWorkerProfile(profile, runDir) {
+    const runtimeDir = path.join(runDir, "worker-profile");
+    fs.rmSync(runtimeDir, { recursive: true, force: true });
+    const hooksDir = profile.hookFiles.length > 0 ? path.join(runtimeDir, PROFILE_HOOKS) : undefined;
+    if (hooksDir !== undefined)
+        fs.mkdirSync(hooksDir, { recursive: true });
+    for (const relative of profile.hookFiles) {
+        const destination = path.join(runtimeDir, relative);
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+        const source = path.join(profile.dir, relative);
+        fs.copyFileSync(source, destination);
+        fs.chmodSync(destination, fs.statSync(source).mode & 0o777);
+    }
+    const settingsPath = profile.settings !== undefined || hooksDir !== undefined
+        ? path.join(runtimeDir, "settings.json")
+        : undefined;
+    if (settingsPath !== undefined) {
+        fs.mkdirSync(runtimeDir, { recursive: true });
+        const settings = profile.settings === undefined
+            ? {}
+            : JSON.parse(JSON.stringify(profile.settings));
+        if (hooksDir !== undefined) {
+            const registeredHooks = isPlainObject(settings.hooks)
+                ? { ...settings.hooks }
+                : {};
+            for (const relative of profile.hookFiles) {
+                const event = profileHookEvent(relative);
+                const eventHooks = Array.isArray(registeredHooks[event])
+                    ? [...registeredHooks[event]]
+                    : [];
+                eventHooks.push({
+                    hooks: [{
+                            type: "command",
+                            command: `bash ${shellQuote(path.join(runtimeDir, relative))}`,
+                        }],
+                });
+                registeredHooks[event] = eventHooks;
+            }
+            settings.hooks = registeredHooks;
+        }
+        fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+    }
+    return {
+        ...(settingsPath !== undefined ? { settingsPath } : {}),
+        ...(hooksDir !== undefined ? { hooksDir } : {}),
+    };
+}
+//# sourceMappingURL=profile.js.map

package/dist/lib/lanes/reconcile.js

@@ -11,6 +11,7 @@ import { parseUserYaml } from "../../utils/user-yaml-error.js";
 import { accountMaxRunning, loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { LanesError, isLaneVersionConflict } from "./errors.js";
+import { loadWorkerProfile } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, spawnEnvelopeRepair, spawnLaneWorker, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
@@ -18,7 +19,7 @@ import { applyThrottleDecision, defaultThrottleDeps, emptyThrottleState, evaluat
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
 import { SILENCE_MS, classifyLaneExit, isPidAlive, readLatestEnvelope, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
-import { createLaneMesh, emitLaneDecisionEvents } from "./mesh-events.js";
+import { createLaneMesh, emitLaneDecisionEvents, laneMeshCompany } from "./mesh-events.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -317,13 +318,14 @@ async function emitAgedQuestionAtUser(summary, deps, lane, question) {
     if (deps.dryRun)
         return;
     const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
-    if (!mesh || !lane.company || !lane.thread_id)
+    const company = laneMeshCompany(lane);
+    if (!mesh || !company || !lane.thread_id)
         return;
     const timeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
     let timer;
     try {
         await Promise.race([
-            mesh.appendThreadEvent(lane.company, lane.thread_id, "lane_question_at_user", { lane_id: lane.lane_id, question_id: question.question_id }),
+            mesh.appendThreadEvent(company, lane.thread_id, "lane_question_at_user", { lane_id: lane.lane_id, question_id: question.question_id }),
             new Promise((_resolve, reject) => {
                 timer = setTimeout(() => reject(new Error(`question-at-user mesh emit timed out after ${timeoutMs}ms`)), timeoutMs);
             }),
@@ -1011,6 +1013,26 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
                 continue;
             }
         }
+        let profileMaxConcurrent;
+        if (lane.worker_profile !== undefined) {
+            try {
+                profileMaxConcurrent = loadWorkerProfile(hqRoot, lane.worker_profile).meta.max_concurrent;
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: `profile admission failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+        if (profileMaxConcurrent !== undefined) {
+            const profileRunning = running.filter((row) => row.worker_profile === lane.worker_profile).length +
+                spawned.filter((row) => row.worker_profile === lane.worker_profile).length;
+            if (profileRunning >= profileMaxConcurrent)
+                continue;
+        }
         try {
             if (deps.dryRun) {
                 summary.admitted.push({

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

@@ -23,6 +23,7 @@
  * `worker_tenancy_unresolved` when that cannot be determined.
  */
 import * as fs from "node:fs";
+import { type WorkerProfile } from "./profile.js";
 export declare const WORKER_REGISTRY_REL: string;
 export interface RegistryWorkerEntry {
     id: string;
@@ -87,6 +88,8 @@ export interface ResolvedLaneWorker {
     humanCheckpoints: string[];
     /** Set when the worker's realpath lives in a package. */
     pack?: string;
+    /** Set when this worker was resolved from personal/workers/<id>/meta.yaml. */
+    profile?: WorkerProfile;
 }
 export interface RegistryDeps {
     existsSync: (p: string) => boolean;

package/dist/lib/lanes/registry.js

@@ -28,6 +28,7 @@ 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";
+import { loadWorkerProfile, workerProfileMarker, } from "./profile.js";
 export const WORKER_REGISTRY_REL = path.join("core", "workers", "registry.yaml");
 function defaultRegistryDeps() {
     return {
@@ -247,6 +248,9 @@ function personalDirClaim(hqRoot, workerId, deps) {
     const dir = personalWorkerDir(hqRoot, workerId);
     let st;
     try {
+        const linkStat = fs.lstatSync(dir);
+        if (linkStat.isSymbolicLink())
+            return "none";
         st = deps.statSync(dir);
     }
     catch (err) {
@@ -369,7 +373,10 @@ function readRegistryOrEmpty(hqRoot, deps) {
 }
 export function resolveLaneWorker(hqRoot, workerId, laneCompany, deps = defaultRegistryDeps()) {
     const personalRel = path.posix.join("personal", "workers", workerId);
-    const personalClaim = personalDirClaim(hqRoot, workerId, deps);
+    const profile = workerProfileMarker(hqRoot, workerId) === "present"
+        ? loadWorkerProfile(hqRoot, workerId)
+        : undefined;
+    const personalClaim = profile ? "profile" : 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" });
     }
@@ -390,6 +397,43 @@ export function resolveLaneWorker(hqRoot, workerId, laneCompany, deps = defaultR
             realpath: realpathOf(hqRoot, rel),
         });
     }
+    if (profile !== undefined && candidates.length > 0) {
+        throw new WorkerResolutionError("worker_profile_ambiguous", "Worker " +
+            JSON.stringify(workerId) +
+            " has both a personal profile and a registry worker; name one explicitly instead of falling through", {
+            worker: workerId,
+            profile_path: personalRel + "/",
+            registry_paths: candidates.map((item) => item.path),
+        });
+    }
+    if (profile !== undefined) {
+        const description = "Reusable worker profile " + profile.id;
+        return {
+            id: profile.id,
+            path: personalRel + "/",
+            type: "WorkerProfile",
+            status: "active",
+            description,
+            tenancy: { kind: "global" },
+            workerYaml: {
+                worker: {
+                    id: profile.id,
+                    name: profile.id,
+                    description,
+                    type: "WorkerProfile",
+                    status: "active",
+                },
+                instructions: "Apply reusable worker profile " + profile.id + " at every provider spawn.",
+            },
+            workerDir: profile.dir,
+            resolvedContextBase: [],
+            skillFiles: [],
+            defaultTimeout: undefined,
+            approvalRequired: false,
+            humanCheckpoints: [],
+            profile,
+        };
+    }
     if (personalClaim === "yaml") {
         const rel = normalizeRel(personalRel);
         const real = realpathOf(hqRoot, rel);