@indigoai-us/hq-cli 5.140.0 → 5.142.0

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;

package/dist/lib/lanes/spawn.js

@@ -18,6 +18,7 @@ import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } f
 import { appendEffortFlag, resolveLaneEffort } from "./effort.js";
 import { claimableStatesFor, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
 import { AccountResolutionError, LanesError } from "./errors.js";
+import { ignoredWorkerProfileFields, loadWorkerProfile, materializeWorkerProfile, workerProfilePrompt, } from "./profile.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { readLane, retryUpdateLane } from "./store.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, parseLaneProvider, } from "./types.js";
@@ -86,6 +87,9 @@ export function parseCliModel(raw) {
 export function resolveLaneModel(input) {
     if (input.cliModel !== undefined)
         return input.cliModel;
+    if (input.profileModel !== undefined && input.profileModel.trim().length > 0) {
+        return input.profileModel.trim();
+    }
     if (input.accountModel !== undefined && input.accountModel.trim().length > 0) {
         return input.accountModel.trim();
     }
@@ -119,6 +123,40 @@ export function appendFastModeFlags(provider, args, enabled) {
         return [...args, ...flags];
     return [...args.slice(0, end), ...flags, ...args.slice(end)];
 }
+function appendProviderProfileFlags(provider, args, profile) {
+    if (profile === undefined)
+        return args;
+    const ignored = new Set(profile.ignoredFields ?? []);
+    switch (provider) {
+        case "claude": {
+            const flags = [
+                "--append-system-prompt",
+                profile.systemPrompt,
+                // A profile is a per-spawn input. Do not let Claude's session resume
+                // snapshot hide a changed profile from the next launch.
+                "--system-prompt-snapshot",
+                "off",
+                ...(profile.settingsPath !== undefined && !ignored.has("settings")
+                    ? ["--settings", profile.settingsPath]
+                    : []),
+            ];
+            return [...args, ...flags];
+        }
+        case "codex": {
+            const flags = ["-c", `developer_instructions=${JSON.stringify(profile.systemPrompt)}`];
+            const end = args.indexOf("--");
+            if (end === -1)
+                return [...args, ...flags];
+            return [...args.slice(0, end), ...flags, ...args.slice(end)];
+        }
+        case "grok":
+            return [...args, "--rules", profile.systemPrompt];
+        default: {
+            const _exhaustive = provider;
+            return _exhaustive;
+        }
+    }
+}
 export const PID_LIVENESS_DECISIONS = [
     "esrch",
     "starttime_mismatch",
@@ -713,10 +751,10 @@ export function buildProviderCommand(provider, input) {
     }
     return {
         command,
-        args: appendFastModeFlags(parsed, appendEffortFlag(parsed, appendModelFlag(parsed, args, input.model), input.effort), input.fastMode),
+        args: appendFastModeFlags(parsed, appendEffortFlag(parsed, appendModelFlag(parsed, appendProviderProfileFlags(parsed, args, input.profile), input.model), input.effort), input.fastMode),
     };
 }
-export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens) {
+export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany) {
     const accepted = Object.values(PROVIDER_HOME_ENV);
     if (!accepted.includes(resolved.envVar)) {
         throw new LanesError("unknown_provider_home_env", `Unknown provider home variable ${JSON.stringify(resolved.envVar)}. Accepted: ${accepted.join(", ")}`, { accepted, value: resolved.envVar });
@@ -731,6 +769,12 @@ export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens) {
     }
     env.HQ_LANE_ID = laneId;
     env.HQ_ROOT = hqRoot;
+    if (meshCompany) {
+        env.HQ_SPAWN_COMPANY = meshCompany.slug || meshCompany.uid;
+    }
+    else {
+        delete env.HQ_SPAWN_COMPANY;
+    }
     return env;
 }
 function ensureDir(dir) {
@@ -752,6 +796,15 @@ function writeText(filePath, text) {
     ensureDir(path.dirname(filePath));
     fs.writeFileSync(filePath, text, "utf8");
 }
+function appendWorkerProfileEvent(runDir, event) {
+    const eventsPath = path.join(runDir, "watcher", "profile-events.jsonl");
+    ensureDir(path.dirname(eventsPath));
+    fs.appendFileSync(eventsPath, `${JSON.stringify({
+        event: "profile_applied",
+        ...event,
+        at: new Date().toISOString(),
+    })}\n`);
+}
 function openLog(filePath) {
     ensureDir(path.dirname(filePath));
     return fs.openSync(filePath, "a");
@@ -906,6 +959,16 @@ function writeSpawnManifest(runDir, input) {
         resume: input.resume,
         worker_out_offset: input.workerOutOffset,
         ...(input.fastMode ? { fast_mode: true } : {}),
+        ...(input.profile
+            ? {
+                worker_profile: input.profile.id,
+                worker_profile_hash: input.profile.hash,
+                worker_profile_ignored: [...input.profile.ignoredFields],
+                ...(input.profile.settingsPath
+                    ? { worker_profile_settings: input.profile.settingsPath }
+                    : {}),
+            }
+            : {}),
     }, null, 2)}\n`);
 }
 /** Arm (or re-arm) the detached per-lane watcher. */
@@ -969,6 +1032,15 @@ export function readSpawnManifest(runDir) {
     }
     if (typeof rec.fast_mode === "boolean")
         out.fast_mode = rec.fast_mode;
+    if (typeof rec.worker_profile === "string")
+        out.worker_profile = rec.worker_profile;
+    if (typeof rec.worker_profile_hash === "string")
+        out.worker_profile_hash = rec.worker_profile_hash;
+    if (Array.isArray(rec.worker_profile_ignored) && rec.worker_profile_ignored.every((item) => typeof item === "string")) {
+        out.worker_profile_ignored = rec.worker_profile_ignored;
+    }
+    if (typeof rec.worker_profile_settings === "string")
+        out.worker_profile_settings = rec.worker_profile_settings;
     if (rec.resume &&
         typeof rec.resume === "object" &&
         typeof rec.resume.session_id === "string") {
@@ -1024,13 +1096,38 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const logsDir = path.join(runDir, "logs");
     ensureDir(logsDir);
     ensureDir(path.join(runDir, "envelopes"));
+    const profile = existing.worker_profile
+        ? loadWorkerProfile(hqRoot, existing.worker_profile)
+        : undefined;
+    const profileDefaultsApply = profile !== undefined && profile.meta.provider === existing.provider;
+    const profileModel = profileDefaultsApply ? profile.meta.model : undefined;
+    const profileEffort = profileDefaultsApply ? profile.meta.effort : undefined;
+    const ignoredProfileFields = profile
+        ? ignoredWorkerProfileFields(existing.provider)
+        : [];
+    const profileRuntime = profile
+        ? materializeWorkerProfile(profile, runDir)
+        : undefined;
+    const profileLaunch = profile
+        ? {
+            systemPrompt: workerProfilePrompt(profile),
+            ...(profileRuntime?.settingsPath !== undefined
+                ? { settingsPath: profileRuntime.settingsPath }
+                : {}),
+            ignoredFields: ignoredProfileFields,
+        }
+        : undefined;
+    const profileChanged = profile !== undefined && existing.worker_profile_hash !== profile.contentHash;
     const config = loadLanesConfig(hqRoot);
+    const pinnedModel = existing.model_source === undefined || existing.model_source === "cli"
+        ? existing.model
+        : undefined;
     let resolved;
     try {
         resolved = resolveAccount(lane.provider, lane.account, config, {
             hqRoot,
             existsSync,
-            model: lane.model,
+            model: pinnedModel ?? profileModel,
         });
     }
     catch (err) {
@@ -1078,21 +1175,26 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const autoCompactTokens = lane.provider === "claude"
         ? providerAutoCompactTokens(config.providers.claude)
         : undefined;
-    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens);
+    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined);
     const model = resolveLaneModel({
-        cliModel: lane.model,
+        cliModel: pinnedModel,
+        profileModel,
         accountModel: accountCfg?.model,
         providerModel: config.providers[lane.provider].model,
     });
     const effort = resolveLaneEffort({
         cliEffort: existing.effort_source === "cli" ? existing.effort : undefined,
+        profileEffort,
         accountEffort: accountCfg?.effort,
         providerEffort: config.providers[lane.provider].effort,
         model,
     });
-    const fastMode = lane.provider === "codex" &&
-        model !== undefined &&
-        (config.providers.codex.fast_mode_models ?? []).includes(model);
+    const fastMode = lane.provider === "codex"
+        ? profileDefaultsApply
+            ? profile?.meta.fast_mode === true
+            : model !== undefined &&
+                (config.providers.codex.fast_mode_models ?? []).includes(model)
+        : false;
     const resume = plan.mode === "resume"
         ? {
             session_id: plan.session_id,
@@ -1122,6 +1224,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         model,
         effort: effort.effort,
         fastMode,
+        profile: profileLaunch,
         resume,
     });
     // A systemd PATH mismatch is an environment defect, not a lane failure.
@@ -1170,6 +1273,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 model,
                 effort: effort.effort,
                 fastMode,
+                profile: profileLaunch,
                 resume: { session_id: resume.session_id, prompt: COMPACTION_PROMPT },
             });
             compaction = compactLaneSession({
@@ -1213,13 +1317,36 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             pending_resume: undefined,
             account: resolved.id,
             ...(model !== undefined ? { model } : {}),
+            ...(model !== undefined
+                ? {
+                    model_source: pinnedModel !== undefined
+                        ? "cli"
+                        : profileDefaultsApply
+                            ? "profile"
+                            : accountCfg?.model !== undefined
+                                ? "account"
+                                : config.providers[lane.provider].model !== undefined
+                                    ? "provider"
+                                    : "none",
+                }
+                : { model_source: "none" }),
             effort_source: effort.source,
             last_host_report_at: nowIso,
+            ...(profile
+                ? {
+                    worker_profile_hash: profile.contentHash,
+                    worker_profile_ignored: [...ignoredProfileFields],
+                }
+                : {}),
         };
         if (effort.effort !== undefined)
             next.effort = effort.effort;
         else
             delete next.effort;
+        // `undefined` deliberately overlays the CAS merge's current record so a
+        // dynamic default disappearing removes the stale persisted model.
+        if (model === undefined)
+            next.model = undefined;
         if (fastMode)
             next.fast_mode = true;
         else
@@ -1295,7 +1422,28 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             resume: resume ? { session_id: resume.session_id } : null,
             workerOutOffset,
             fastMode,
+            ...(profile
+                ? {
+                    profile: {
+                        id: profile.id,
+                        hash: profile.contentHash,
+                        ignoredFields: ignoredProfileFields,
+                        ...(profileRuntime?.settingsPath !== undefined
+                            ? { settingsPath: profileRuntime.settingsPath }
+                            : {}),
+                    },
+                }
+                : {}),
         });
+        if (profile !== undefined) {
+            appendWorkerProfileEvent(runDir, {
+                profile_id: profile.id,
+                profile_hash: profile.contentHash,
+                changed: profileChanged,
+                provider: lane.provider,
+                ignored_fields: ignoredProfileFields,
+            });
+        }
     }
     catch (err) {
         if (workerPid !== undefined)
@@ -1355,30 +1503,59 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     const logsDir = path.join(runDir, "logs");
     ensureDir(logsDir);
     const config = loadLanesConfig(hqRoot);
+    const profile = lane.worker_profile
+        ? loadWorkerProfile(hqRoot, lane.worker_profile)
+        : undefined;
+    const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
+    const profileModel = profileDefaultsApply ? profile.meta.model : undefined;
+    const profileEffort = profileDefaultsApply ? profile.meta.effort : undefined;
+    const ignoredProfileFields = profile
+        ? ignoredWorkerProfileFields(lane.provider)
+        : [];
+    const profileRuntime = profile
+        ? materializeWorkerProfile(profile, runDir)
+        : undefined;
+    const profileLaunch = profile
+        ? {
+            systemPrompt: workerProfilePrompt(profile),
+            ...(profileRuntime?.settingsPath !== undefined
+                ? { settingsPath: profileRuntime.settingsPath }
+                : {}),
+            ignoredFields: ignoredProfileFields,
+        }
+        : undefined;
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+        ? lane.model
+        : undefined;
     const resolved = resolveAccount(lane.provider, lane.account, config, {
         hqRoot,
         existsSync,
-        model: lane.model,
+        model: pinnedModel ?? profileModel,
     });
     const autoCompactTokens = lane.provider === "claude"
         ? providerAutoCompactTokens(config.providers.claude)
         : undefined;
-    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens);
+    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined);
     const accountCfg = config.providers[lane.provider].accounts[resolved.id];
     const model = resolveLaneModel({
-        cliModel: lane.model,
+        cliModel: pinnedModel,
+        profileModel,
         accountModel: accountCfg?.model,
         providerModel: config.providers[lane.provider].model,
     });
     const effort = resolveLaneEffort({
         cliEffort: lane.effort_source === "cli" ? lane.effort : undefined,
+        profileEffort,
         accountEffort: accountCfg?.effort,
         providerEffort: config.providers[lane.provider].effort,
         model,
     });
-    const fastMode = lane.provider === "codex" &&
-        model !== undefined &&
-        (config.providers.codex.fast_mode_models ?? []).includes(model);
+    const fastMode = lane.provider === "codex"
+        ? profileDefaultsApply
+            ? profile?.meta.fast_mode === true
+            : model !== undefined &&
+                (config.providers.codex.fast_mode_models ?? []).includes(model)
+        : false;
     const repairPrompt = envelopeRepairPrompt({
         envelopePath: input.envelopePath,
         error: input.error,
@@ -1392,6 +1569,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
         model,
         effort: effort.effort,
         fastMode,
+        profile: profileLaunch,
         ...(mode === "resume" && sessionId !== null
             ? { resume: { session_id: sessionId, prompt: repairPrompt } }
             : { freshTurnPrompt: repairPrompt }),
@@ -1418,9 +1596,55 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             resume: mode === "resume" && sessionId !== null ? { session_id: sessionId } : null,
             workerOutOffset,
             fastMode,
+            ...(profile
+                ? {
+                    profile: {
+                        id: profile.id,
+                        hash: profile.contentHash,
+                        ignoredFields: ignoredProfileFields,
+                        ...(profileRuntime?.settingsPath !== undefined
+                            ? { settingsPath: profileRuntime.settingsPath }
+                            : {}),
+                    },
+                }
+                : {}),
         });
+        if (profile !== undefined) {
+            appendWorkerProfileEvent(runDir, {
+                profile_id: profile.id,
+                profile_hash: profile.contentHash,
+                changed: lane.worker_profile_hash !== profile.contentHash,
+                provider: lane.provider,
+                ignored_fields: ignoredProfileFields,
+            });
+        }
         retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
             const next = { ...current };
+            if (profile !== undefined) {
+                next.worker_profile_hash = profile.contentHash;
+                next.worker_profile_ignored = [...ignoredProfileFields];
+                if (model !== undefined) {
+                    next.model = model;
+                    next.model_source = pinnedModel !== undefined
+                        ? "cli"
+                        : profileDefaultsApply
+                            ? "profile"
+                            : accountCfg?.model !== undefined
+                                ? "account"
+                                : config.providers[lane.provider].model !== undefined
+                                    ? "provider"
+                                    : "none";
+                }
+                else {
+                    next.model = undefined;
+                    next.model_source = "none";
+                }
+                next.effort_source = effort.source;
+                if (effort.effort !== undefined)
+                    next.effort = effort.effort;
+                else
+                    delete next.effort;
+            }
             if (fastMode)
                 next.fast_mode = true;
             else

package/dist/lib/lanes/store.js

@@ -268,6 +268,15 @@ function parseOptionalCompanyField(raw, filePath) {
     requireString(raw.company.slug, "company.slug");
     requireString(raw.company.uid, "company.uid");
 }
+function parseOptionalMeshCompanyField(raw, filePath) {
+    if (raw.mesh_company === undefined)
+        return;
+    if (!isPlainObject(raw.mesh_company)) {
+        throw new LaneSchemaError("mesh_company must be an object", { path: filePath });
+    }
+    requireString(raw.mesh_company.slug, "mesh_company.slug");
+    requireString(raw.mesh_company.uid, "mesh_company.uid");
+}
 export function parseLaneRecord(raw, filePath) {
     if (!isPlainObject(raw)) {
         throw new LaneSchemaError("Lane record must be a JSON object", {
@@ -294,6 +303,7 @@ export function parseLaneRecord(raw, filePath) {
         throw new LaneSchemaError(`Unknown provider ${JSON.stringify(raw.provider)}`, { path: filePath, value: raw.provider });
     }
     parseOptionalCompanyField(raw, filePath);
+    parseOptionalMeshCompanyField(raw, filePath);
     if (!isPlainObject(raw.senior)) {
         throw new LaneSchemaError("senior must be an object", { path: filePath });
     }