@indigoai-us/hq-cli 5.141.0 → 5.142.0

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

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

@@ -242,6 +242,8 @@ export interface LaneRecord {
     lane_id: string;
     /** `null` is a core/personal lane (spec §6.2 / §10). Not an empty slug. */
     company: LaneCompanyRef | null;
+    /** Explicit Work Mesh attribution for a personal lane; never inferred from cwd. */
+    mesh_company?: LaneCompanyRef;
     project_id: string;
     story_id: string;
     thread_id?: string;
@@ -265,6 +267,12 @@ export interface LaneRecord {
     worker_path?: string;
     /** Package name when the worker's realpath is under core/packages. */
     worker_pack?: string;
+    /** Personal worker profile id applied to every spawn. */
+    worker_profile?: string;
+    /** Content hash of the profile last applied to this lane. */
+    worker_profile_hash?: string;
+    /** Profile fields intentionally unsupported by the selected provider. */
+    worker_profile_ignored?: string[];
     provider: LaneProvider;
     account?: string;
     /**
@@ -296,10 +304,12 @@ export interface LaneRecord {
     last_envelope?: LastEnvelopeRef;
     /** Effective model id recorded at create/spawn. Omitted when the provider chooses. */
     model?: string;
+    /** Where the effective model came from; profile values are re-read on spawn. */
+    model_source?: "cli" | "profile" | "account" | "provider" | "none";
     /** Effective effort level passed to the provider at the last spawn (effort.ts). */
     effort?: string;
     /** Where `effort` came from. `cli` pins it across later spawns. */
-    effort_source?: "cli" | "account" | "provider" | "default_rule" | "none";
+    effort_source?: "cli" | "profile" | "account" | "provider" | "default_rule" | "none";
     /** Whether the last spawn used Codex fast mode, including false when disabled. */
     fast_mode?: boolean;
     /** Time of the last operator message accepted for this lane. Drives compaction. */

package/dist/lib/lanes/types.js

@@ -195,15 +195,15 @@ export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spaw
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
     schema_version: ["creator"], lane_id: ["creator"], company: ["creator"],
-    project_id: ["command"], story_id: ["command"], thread_id: ["creator", "command"],
+    project_id: ["command"], story_id: ["command"], thread_id: ["creator", "command"], mesh_company: ["creator"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
-    priority: ["command"], worker: ["creator"], worker_path: ["creator"], worker_pack: ["creator"],
+    priority: ["command"], worker: ["creator"], worker_path: ["creator"], worker_pack: ["creator"], worker_profile: ["creator"], worker_profile_hash: ["creator", "spawn"], worker_profile_ignored: ["creator", "spawn"],
     provider: ["creator"], account: ["creator", "spawn", "command"], account_history: ["command"], pending_resume: ["command", "spawn"], host: ["creator"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
-    last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
+    last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
     last_message_at: ["command"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.141.0",
+  "version": "5.142.0",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {