@indigoai-us/hq-cli 5.140.0 → 5.142.0

package/dist/lib/bot/run.js

@@ -69,7 +69,7 @@ import { buildJobTurnPrompt, isCatchUpRun, isJobItem, jobReportHeader, jobRunOut
 import { clearPendingJobCompletion, isCompletionDue, isCompletionExpired, isCompletionForOtherAgent, readPendingJobCompletions, recordPendingJobCompletion } from "./job-completions.js";
 import { isRuntimeSignInFailure, SIGN_IN_RETRY_MS, signInNeededText } from "./runtime-sign-in.js";
 import { HQ_BOT_AGENT_UID_ENV } from "../../commands/onboard-bot-membership.js";
-import { captureHeartbeatIdentityMismatch, isHeartbeatIdentityMismatch, } from "../heartbeat-identity.js";
+import { captureHeartbeatIdentityMismatch, identityMismatchMessage, isHeartbeatIdentityMismatch, } from "../heartbeat-identity.js";
 import { clearBotSession, readBotSession, writeBotSession } from "./session.js";
 import { defaultBotStatus, patchBotStatus, readBotStatus } from "./status.js";
 export const INBOX_POLL_INTERVAL_MS = 2_000;
@@ -459,7 +459,7 @@ export async function runBot(deps) {
                 if (err instanceof BotApiError &&
                     isHeartbeatIdentityMismatch({ status: err.status, code: err.code, message: err.detail })) {
                     const tokenLabel = err.tokenAgentUid ?? "unknown";
-                    const reason = `heartbeat stopped: identity mismatch configured agentUid=${config.agentUid} token agentUid=${tokenLabel}`;
+                    const reason = identityMismatchMessage("heartbeat", config.agentUid, tokenLabel);
                     setStatus({
                         lastHeartbeatOk: false,
                         lastHeartbeatError: reason.slice(0, 400),

package/dist/lib/heartbeat-identity.d.ts

@@ -1,5 +1,6 @@
 import type { CaptureContext } from "@sentry/node";
 export declare const HEARTBEAT_IDENTITY_MISMATCH_CODE = "AGENT_IDENTITY_MISMATCH";
+export declare function identityMismatchMessage(surface: "heartbeat" | "bot jobs", configuredAgentUid: string, tokenAgentUid?: string): string;
 export type HeartbeatRunner = "agent-kit" | "bot";
 export type HeartbeatAgentUidSource = "config_file" | "env" | "flag";
 export type HeartbeatCredsSource = "explicit" | "default";

package/dist/lib/heartbeat-identity.js

@@ -2,6 +2,11 @@ import { CLI_VERSION } from "../cli-version.js";
 import { Sentry } from "../sentry.js";
 import { peekIdToken } from "../utils/id-token.js";
 export const HEARTBEAT_IDENTITY_MISMATCH_CODE = "AGENT_IDENTITY_MISMATCH";
+export function identityMismatchMessage(surface, configuredAgentUid, tokenAgentUid) {
+    return (`${surface} stopped: identity mismatch configured agentUid=${configuredAgentUid} ` +
+        `token agentUid=${tokenAgentUid ?? "unknown"}; fix the bot config to use the token agentUid, ` +
+        `or re-mint credentials for the configured agentUid.`);
+}
 const AGENT_UID_RE = /^agt_[A-Za-z0-9_-]{1,100}$/;
 function normalize(value) {
     return (value ?? "").replace(/[^A-Za-z0-9]/g, "").toLowerCase();

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

@@ -19,7 +19,7 @@
  */
 import type { LaneProvider } from "./types.js";
 export declare const PROVIDER_EFFORT_LEVELS: Record<LaneProvider, readonly string[]>;
-export declare const EFFORT_SOURCES: readonly ["cli", "account", "provider", "default_rule", "none"];
+export declare const EFFORT_SOURCES: readonly ["cli", "profile", "account", "provider", "default_rule", "none"];
 export type EffortSource = (typeof EFFORT_SOURCES)[number];
 export interface ResolvedEffort {
     effort?: string;
@@ -35,9 +35,10 @@ export declare function parseConfigEffort(provider: LaneProvider, raw: unknown,
  * Keyed on the model already chosen for the lane; it does not pick a model.
  */
 export declare function defaultEffortForModel(model: string | undefined): string | undefined;
-/** Precedence: `--effort`, then the account, then the provider, then the default rule. */
+/** Precedence: `--effort`, profile, account, provider, then the default rule. */
 export declare function resolveLaneEffort(input: {
     cliEffort?: string;
+    profileEffort?: string;
     accountEffort?: string;
     providerEffort?: string;
     model?: string;

package/dist/lib/lanes/effort.js

@@ -25,6 +25,7 @@ export const PROVIDER_EFFORT_LEVELS = {
 };
 export const EFFORT_SOURCES = [
     "cli",
+    "profile",
     "account",
     "provider",
     "default_rule",
@@ -65,10 +66,13 @@ export function defaultEffortForModel(model) {
     }
     return undefined;
 }
-/** Precedence: `--effort`, then the account, then the provider, then the default rule. */
+/** Precedence: `--effort`, profile, account, provider, then the default rule. */
 export function resolveLaneEffort(input) {
     if (input.cliEffort !== undefined)
         return { effort: input.cliEffort, source: "cli" };
+    if (input.profileEffort !== undefined) {
+        return { effort: input.profileEffort, source: "profile" };
+    }
     if (input.accountEffort !== undefined) {
         return { effort: input.accountEffort, source: "account" };
     }

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

@@ -34,6 +34,6 @@ export declare class AccountResolutionError extends LanesError {
     constructor(error: "unknown_account" | "account_disabled" | "no_enabled_account" | "account_model_unavailable" | "account_quota_exhausted", message: string, details?: Record<string, unknown>);
 }
 export declare class WorkerResolutionError extends LanesError {
-    constructor(error: "worker_not_found" | "worker_tenancy_unresolved" | "worker_not_available" | "worker_not_active" | "worker_id_conflict" | "package_workers_unmounted" | "worker_registry_unreadable", message: string, details?: Record<string, unknown>);
+    constructor(error: "worker_not_found" | "worker_tenancy_unresolved" | "worker_not_available" | "worker_not_active" | "worker_id_conflict" | "worker_profile_invalid" | "worker_profile_ambiguous" | "package_workers_unmounted" | "worker_registry_unreadable", message: string, details?: Record<string, unknown>);
 }
 //# sourceMappingURL=errors.d.ts.map

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

@@ -45,6 +45,8 @@ export type { KnownModels, KnownModelsDeps, ProbeCommand, ProbeResult } from "./
 export { SESSION_MOVE_REASON, copySessionFiles, encodeClaudeProjectDir, findCodexRollout, planClaudeSessionCopy, planCodexSessionCopy, planSessionCopy, } from "./move-account.js";
 export type { SessionCopyPlan, SessionCopyResult } from "./move-account.js";
 export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorkerRegistryFile, registryPath, resolveContextBasePaths, resolveLaneWorker, resolveSkillFiles, tenancyFromRegistryPath, } from "./registry.js";
+export { ignoredWorkerProfileFields, loadWorkerProfile, materializeWorkerProfile, personalWorkerProfileDir, workerProfileMarker, workerProfilePrompt, } from "./profile.js";
+export type { WorkerProfile, WorkerProfileMeta, WorkerProfileRuntime, } from "./profile.js";
 export type { RegistryWorkerEntry, ResolvedLaneWorker, WorkerTenancy, WorkerYaml, } from "./registry.js";
 export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
 export type { QuestionBody, RaiseLaneQuestionInput } from "./questions.js";

package/dist/lib/lanes/index.js

@@ -25,6 +25,7 @@ export { PROVIDER_REJECTED_REASON, PROVIDER_REJECTION_MESSAGE_CAP, parseClaudeRe
 export { CODEX_MODELS_CACHE_NAME, MODEL_PROBE_TIMEOUT_MS, claudeKnownModels, codexKnownModels, defaultProbe, grokKnownModels, knownModels, modelIsKnown, parseClaudeHelpModels, parseGrokModelsOutput, validateLaneModel, } from "./models.js";
 export { SESSION_MOVE_REASON, copySessionFiles, encodeClaudeProjectDir, findCodexRollout, planClaudeSessionCopy, planCodexSessionCopy, planSessionCopy, } from "./move-account.js";
 export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorkerRegistryFile, registryPath, resolveContextBasePaths, resolveLaneWorker, resolveSkillFiles, tenancyFromRegistryPath, } from "./registry.js";
+export { ignoredWorkerProfileFields, loadWorkerProfile, materializeWorkerProfile, personalWorkerProfileDir, workerProfileMarker, workerProfilePrompt, } from "./profile.js";
 export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
 export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
 export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";

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