@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

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

@@ -1,69 +0,0 @@
-/**
- * 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

@@ -1,552 +0,0 @@
-/**
- * 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