@indigoai-us/hq-cli 5.314.0 → 5.315.0

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

@@ -0,0 +1,69 @@
+/**
+ * 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 LaneRecord, type LaneProvider } from "./types.js";
+import type { RegistryWorkerRecord } from "./types.js";
+import { type RegistryPersona } from "./registry-persona.js";
+export declare const REGISTRY_PERSONA_PROMPT_MAX_CHARS = 12000;
+export interface WorkerProfileMeta {
+    version?: string;
+    provider: LaneProvider;
+    model?: string;
+    account?: string;
+    effort?: string;
+    fast_mode?: boolean;
+    max_concurrent?: number;
+    source?: string;
+    accounts?: string[];
+    keep_alive?: boolean;
+    registry_worker?: string;
+}
+export interface WorkerProfile {
+    id: string;
+    dir: string;
+    meta: WorkerProfileMeta;
+    systemPrompt: string;
+    settings?: Record<string, unknown>;
+    policyFiles: string[];
+    hookFiles: string[];
+    contentHash: string;
+    registryWorker?: RegistryPersona;
+}
+export interface WorkerProfileRuntime {
+    settingsPath?: string;
+    hooksDir?: string;
+}
+export interface LoadWorkerProfileOptions {
+    /** Unknown keys may be ignored only by callers with an explicit recovery path. */
+    onUnknownMetaFields?: (fields: readonly string[]) => void;
+}
+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, options?: LoadWorkerProfileOptions): WorkerProfile;
+export declare function loadWorkerProfileWithRegistry(hqRoot: string, id: string, options?: {
+    laneCompany?: string;
+    registryWorkerRecord?: RegistryWorkerRecord;
+    onUnknownMetaFields?: (fields: readonly string[]) => void;
+}): WorkerProfile;
+export interface EffectiveLaneKeepAlive {
+    enabled: boolean;
+    source: "lane" | "none";
+}
+/** Resolve keep-alive from the lane record; profile metadata only seeds new spawns. */
+export declare function resolveLaneKeepAlive(_hqRoot: string, lane: Pick<LaneRecord, "keep_alive">): EffectiveLaneKeepAlive;
+export declare function workerProfilePrompt(profile: WorkerProfile, delivery?: "hook" | "prompt"): 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,552 @@
+/**
+ * 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 { policyLoadDiagnostic } from "../policy-validator.js";
+import { WorkerResolutionError } from "./errors.js";
+import { PROVIDER_EFFORT_LEVELS } from "./effort.js";
+import { LANE_PROVIDERS, isLaneProvider, } from "./types.js";
+import { loadRegistryPersonaFromRecord, registryWorkerRecord, resolveRegistryPersona, } from "./registry-persona.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";
+export const REGISTRY_PERSONA_PROMPT_MAX_CHARS = 12_000;
+const PROFILE_META_KEYS = new Set([
+    "version",
+    "provider",
+    "model",
+    "account",
+    "effort",
+    "fast_mode",
+    "max_concurrent",
+    "source",
+    "accounts",
+    "keep_alive",
+    "registry_worker",
+]);
+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, options = {}) {
+    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) {
+        if (options.onUnknownMetaFields === undefined) {
+            throw profileError(id, dir, `meta.yaml has unknown field(s): ${unknown.join(", ")}`, {
+                fields: unknown,
+            });
+        }
+        options.onUnknownMetaFields(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 optionalString = (field) => {
+        const value = raw[field];
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw profileError(id, dir, `meta.yaml ${field} must be a non-empty string when present`, {
+                field,
+                value,
+            });
+        }
+        return value.trim();
+    };
+    const model = optionalString("model");
+    const account = optionalString("account");
+    const effort = optionalString("effort");
+    if (effort !== undefined && !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 (raw.fast_mode !== undefined && typeof raw.fast_mode !== "boolean") {
+        throw profileError(id, dir, "meta.yaml fast_mode must be a boolean when present", {
+            field: "fast_mode",
+            value: raw.fast_mode,
+        });
+    }
+    if (raw.keep_alive !== undefined && typeof raw.keep_alive !== "boolean") {
+        throw profileError(id, dir, "meta.yaml keep_alive must be a boolean when present", {
+            field: "keep_alive",
+            value: raw.keep_alive,
+        });
+    }
+    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());
+    }
+    const registryWorker = optionalString("registry_worker");
+    return {
+        ...(version !== undefined ? { version } : {}),
+        provider: providerValue,
+        ...(model !== undefined ? { model } : {}),
+        ...(account !== undefined ? { account } : {}),
+        ...(effort !== undefined ? { effort } : {}),
+        ...(raw.fast_mode !== undefined ? { fast_mode: raw.fast_mode } : {}),
+        ...(raw.keep_alive !== undefined ? { keep_alive: raw.keep_alive } : {}),
+        ...(maxConcurrent !== undefined ? { max_concurrent: maxConcurrent } : {}),
+        ...(source !== undefined ? { source } : {}),
+        ...(accounts !== undefined ? { accounts } : {}),
+        ...(registryWorker !== undefined ? { registry_worker: registryWorker } : {}),
+    };
+}
+function validatePolicyFrontmatter(id, profileDir, relative) {
+    const filePath = path.join(profileDir, relative);
+    const content = readRequiredText(id, profileDir, filePath, relative);
+    const lines = content.split(/\r?\n/);
+    if (lines[0] !== "---") {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} must start with YAML frontmatter`, { worker: id, file: filePath, field: "frontmatter" });
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line === "---");
+    if (closing < 0 || closing === 1) {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} must contain a non-empty YAML frontmatter block`, { worker: id, file: filePath, field: "frontmatter" });
+    }
+    let frontmatter;
+    try {
+        frontmatter = parseUserYaml(lines.slice(1, closing).join("\n"), filePath);
+    }
+    catch (err) {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} has invalid YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`, { worker: id, file: filePath, field: "frontmatter" });
+    }
+    if (!isPlainObject(frontmatter)) {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} frontmatter must contain a YAML object`, { worker: id, file: filePath, field: "frontmatter" });
+    }
+    if (typeof frontmatter.when !== "string" || frontmatter.when.trim().length === 0) {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} frontmatter must include a non-empty when field`, { worker: id, file: filePath, field: "when" });
+    }
+    if (!Array.isArray(frontmatter.on) ||
+        frontmatter.on.length === 0 ||
+        frontmatter.on.some((value) => typeof value !== "string" || value.trim().length === 0)) {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} frontmatter must include a non-empty on string array`, { worker: id, file: filePath, field: "on" });
+    }
+    const diagnostic = policyLoadDiagnostic(content, filePath);
+    if (diagnostic) {
+        throw new WorkerResolutionError("worker_policy_invalid", `Worker policy ${filePath} failed policy validation: ${diagnostic.split("\n", 1)[0]}`, { worker: id, file: filePath, field: "frontmatter", diagnostic });
+    }
+}
+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, options = {}) {
+    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, options);
+    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);
+    for (const relative of policyFiles.filter((file) => file.toLowerCase().endsWith(".md"))) {
+        validatePolicyFrontmatter(id, dir, relative);
+    }
+    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 loadWorkerProfileWithRegistry(hqRoot, id, options = {}) {
+    const profile = loadWorkerProfile(hqRoot, id, options);
+    const requestedId = profile.meta.registry_worker;
+    if (requestedId === undefined) {
+        if (options.registryWorkerRecord !== undefined) {
+            throw new WorkerResolutionError("registry_worker_invalid", `Worker profile ${JSON.stringify(id)} no longer names its recorded registry worker`, { worker: id, registry_worker: options.registryWorkerRecord.id });
+        }
+        return profile;
+    }
+    const persona = options.registryWorkerRecord !== undefined
+        ? (() => {
+            if (options.registryWorkerRecord?.id !== requestedId) {
+                throw new WorkerResolutionError("registry_worker_invalid", `Worker profile ${JSON.stringify(id)} names registry worker ${JSON.stringify(requestedId)}, but the lane records ${JSON.stringify(options.registryWorkerRecord?.id)}`, {
+                    worker: id,
+                    profile_registry_worker: requestedId,
+                    lane_registry_worker: options.registryWorkerRecord?.id,
+                });
+            }
+            return loadRegistryPersonaFromRecord(hqRoot, options.registryWorkerRecord);
+        })()
+        : resolveRegistryPersona(hqRoot, requestedId, options.laneCompany);
+    const record = registryWorkerRecord(persona);
+    const hash = createHash("sha256")
+        .update(profile.contentHash)
+        .update("\0registry_worker\0")
+        .update(JSON.stringify({ id: record.id, path: record.path, worker_yaml_sha256: record.worker_yaml_sha256 }))
+        .digest("hex");
+    return {
+        ...profile,
+        registryWorker: persona,
+        contentHash: `sha256:${hash}`,
+    };
+}
+/** Resolve keep-alive from the lane record; profile metadata only seeds new spawns. */
+export function resolveLaneKeepAlive(_hqRoot, lane) {
+    return lane.keep_alive === undefined
+        ? { enabled: false, source: "none" }
+        : { enabled: lane.keep_alive, source: "lane" };
+}
+export function workerProfilePrompt(profile, delivery = "prompt") {
+    const parts = [profile.systemPrompt.trimEnd()];
+    if (profile.registryWorker !== undefined) {
+        parts.push(formatRegistryWorkerPrompt(profile.registryWorker));
+    }
+    if (delivery === "hook")
+        return parts.join("\n");
+    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");
+}
+function formatRegistryWorkerPrompt(persona) {
+    const lines = [
+        "## Registry worker",
+        `Description: ${persona.description}`,
+        "",
+        "Instructions:",
+        persona.instructions || "No additional instructions were supplied.",
+    ];
+    if (persona.skillFiles.length > 0) {
+        lines.push("", "Skills (path references only; do not inline these files):");
+        for (const file of persona.skillFiles)
+            lines.push(`- ${file}`);
+    }
+    if (persona.postExecute.length > 0) {
+        lines.push("", "Done criteria:");
+        for (const command of persona.postExecute)
+            lines.push(`- ${command}`);
+    }
+    const safetyLines = [];
+    if (persona.humanCheckpoints.length > 0) {
+        safetyLines.push("Human checkpoints:");
+        for (const checkpoint of persona.humanCheckpoints) {
+            safetyLines.push(`- STOP before proceeding with ${checkpoint}. Report that this checkpoint is reached to the senior and wait for approval. Do not perform the action before it is approved.`);
+        }
+    }
+    else if (persona.approvalRequired) {
+        safetyLines.push("Human checkpoint:", "- STOP before any external publish action. Report checkpoint external_publish to the senior and wait for approval. Do not perform the action before it is approved.");
+    }
+    if (persona.approvalRequired || persona.humanCheckpoints.length > 0) {
+        safetyLines.push("For an approved external action, include the exact approved checkpoint in the artifact's checkpoint field. Each approval applies to the next matching envelope only.");
+    }
+    if (safetyLines.length > 0)
+        lines.push("");
+    const complete = [...lines, ...safetyLines].join("\n");
+    if (complete.length <= REGISTRY_PERSONA_PROMPT_MAX_CHARS)
+        return complete;
+    const suffix = [
+        "",
+        `[Registry worker section truncated at ${REGISTRY_PERSONA_PROMPT_MAX_CHARS} characters; descriptive material, skill paths, or done criteria may be omitted.]`,
+        ...(safetyLines.length > 0 ? ["", ...safetyLines] : []),
+    ].join("\n");
+    const prefixBudget = REGISTRY_PERSONA_PROMPT_MAX_CHARS - suffix.length;
+    if (prefixBudget < 0) {
+        throw new WorkerResolutionError("registry_worker_invalid", `Registry worker ${JSON.stringify(persona.id)} checkpoint instructions exceed the bounded prompt limit`, { worker: persona.id, max_chars: REGISTRY_PERSONA_PROMPT_MAX_CHARS });
+    }
+    return `${lines.join("\n").slice(0, prefixBudget).trimEnd()}${suffix}`;
+}
+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