@indigoai-us/hq-cli 5.141.0 → 5.143.0

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);

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

@@ -11,7 +11,7 @@ import { PROVIDER_HOME_ENV } from "./accounts.js";
 import { type RunCompactionFn } from "./compaction.js";
 import { type LaunchTrigger } from "./delivery.js";
 import { type MachineIdentity } from "./machine-identity.js";
-import { type LaneProvider, type LaneRecord } from "./types.js";
+import { type LaneCompanyRef, type LaneProvider, type LaneRecord } from "./types.js";
 export declare const LANES_RUNS_REL: string;
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
 export declare const ANSWERED_QUESTIONS_FILE = "answered-questions.json";
@@ -27,12 +27,18 @@ export declare const CODEX_FAST_MODE_FLAGS: readonly ["-c", "service_tier=\"fast
 export declare function parseCliModel(raw: string | undefined): string | undefined;
 export declare function resolveLaneModel(input: {
     cliModel?: string;
+    profileModel?: string;
     accountModel?: string;
     providerModel?: string;
 }): string | undefined;
 export declare function appendModelFlag(provider: LaneProvider, args: string[], model: string | undefined): string[];
 /** Add Codex fast-mode flags before the prompt/positional separator. */
 export declare function appendFastModeFlags(provider: LaneProvider, args: string[], enabled: boolean | undefined): string[];
+export interface ProviderProfileLaunch {
+    systemPrompt: string;
+    settingsPath?: string;
+    ignoredFields?: readonly string[];
+}
 export type DetachedStdio = ["ignore", number, number];
 export interface DetachedSpawnOptions {
     detached: true;
@@ -197,6 +203,8 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
     effort?: string;
     /** Enable Codex's fast service tier for this resolved model. */
     fastMode?: boolean;
+    /** Per-spawn worker profile instructions and materialized settings. */
+    profile?: ProviderProfileLaunch;
     /** Continue a recorded session. Only providers in PROVIDER_SESSION_RESUME accept this. */
     resume?: ProviderResumeInput;
     /**
@@ -209,7 +217,7 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
 export declare function workerEnv(base: NodeJS.ProcessEnv, resolved: {
     envVar: string;
     home: string;
-}, laneId: string, hqRoot: string, autoCompactTokens?: number): NodeJS.ProcessEnv;
+}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef): NodeJS.ProcessEnv;
 export declare function markSpawnFailure(hqRoot: string, laneId: string, reasonRaw: string, details: Record<string, unknown>): LaneRecord;
 /**
  * Spec §5.2 executing-side check. Compares this machine's identity to
@@ -227,6 +235,10 @@ export interface SpawnManifestFile {
     /** Byte length of logs/worker.out before this run started; its result is after this. */
     worker_out_offset?: number;
     fast_mode?: boolean;
+    worker_profile?: string;
+    worker_profile_hash?: string;
+    worker_profile_ignored?: string[];
+    worker_profile_settings?: string;
 }
 /** Read the per-run manifest. Missing file or field reads as absent. */
 export declare function readSpawnManifest(runDir: string): SpawnManifestFile;