@botlearn-course/daemon 0.0.1

package/dist/run-dispatcher.js

@@ -0,0 +1,294 @@
+import { randomUUID } from "node:crypto";
+import { CourseClientError, isRunTerminal } from "./course-client.js";
+import { reportFileCandidates } from "./file-candidates.js";
+import { log as defaultLog } from "./log.js";
+import { errorInfo, redactSecretString, truncateText } from "./redaction.js";
+import { missingRunCapabilities } from "./runtime-capabilities.js";
+import { RunQueue } from "./run-queue.js";
+import { applyRunRuntimeProfile, cleanupRunRuntimeProfile, RuntimeProfileApplyError, runtimeProfileInstructions, } from "./runtime-profile.js";
+import { TranscriptWriter } from "./transcript.js";
+import { RuntimeExecutionError, } from "./types.js";
+import { ensureRunWorkspace, transcriptPath } from "./workspace.js";
+// 与 runtimes/index.ts 的 DEFAULT_RUNTIME_ID 保持一致（此处不 import registry，避免拉入全部 adapter）。
+const DEFAULT_RUNTIME_ID = "codex";
+const DEFAULT_TIMEOUT_SECONDS = 900;
+const MIN_TIMEOUT_SECONDS = 30;
+const MAX_TIMEOUT_SECONDS = 7200;
+const DEFAULT_MAX_OUTPUT_CHARS = 100_000;
+// wire 上单块文本上限；完整文本在本地 transcript。
+const BLOCK_TEXT_MAX_CHARS = 4000;
+function clampTimeoutSeconds(value) {
+    const n = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_TIMEOUT_SECONDS;
+    return Math.min(MAX_TIMEOUT_SECONDS, Math.max(MIN_TIMEOUT_SECONDS, n));
+}
+/**
+ * Run dispatcher：把 Course Service 下发的 run.start 交给 runtime，
+ * 并把 runtime 输出归一化成 run.block / run.message / run.completed 回报 Course Service。
+ *
+ * - 串行：同一 agent_instance 经 RunQueue 排队。
+ * - 取消：AbortController；runtime 抛错归一化为 run.failed。
+ * - 服务端 409（run 已终态）→ abort 并静默停止后续上报。
+ * - daemon 不推进进度，只汇报事实。
+ */
+export class RunDispatcher {
+    client;
+    runtimes;
+    queue = new RunQueue();
+    inflight = new Map();
+    defaultRuntimeId;
+    log;
+    scanLimits;
+    now;
+    constructor(client, runtimes, opts = {}) {
+        this.client = client;
+        this.runtimes = runtimes;
+        this.defaultRuntimeId = opts.defaultRuntimeId ?? DEFAULT_RUNTIME_ID;
+        this.log = opts.log ?? defaultLog;
+        this.scanLimits = opts.scanLimits;
+        this.now = opts.now ?? Date.now;
+    }
+    /** 排队执行一个 run。返回的 Promise 不 reject（失败已归一化回报为 run.failed）。 */
+    dispatch(payload) {
+        const key = payload.agent_instance_id ?? payload.agent_run_id;
+        return this.queue.enqueue(key, () => this.execute(payload));
+    }
+    cancel(agentRunId) {
+        const controller = this.inflight.get(agentRunId);
+        if (!controller)
+            return false;
+        controller.abort();
+        return true;
+    }
+    cancelAll() {
+        for (const controller of this.inflight.values())
+            controller.abort();
+    }
+    get activeCount() {
+        return this.inflight.size;
+    }
+    /** 等待所有 run（含排队中的）结束；超时返回 false。 */
+    async drain(timeoutMs) {
+        const deadline = this.now() + timeoutMs;
+        while (this.inflight.size > 0 || this.queue.activeKeys.length > 0) {
+            if (this.now() >= deadline)
+                return false;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        return true;
+    }
+    async execute(payload) {
+        const runId = payload.agent_run_id;
+        const controller = new AbortController();
+        this.inflight.set(runId, controller);
+        let seq = 0;
+        // 服务端已把本 run 判为终态（409）：停止一切后续上报。
+        let serverTerminal = false;
+        // 终态事件（completed/failed/cancelled）至多发一个。
+        let terminalSent = false;
+        let timedOut = false;
+        let timer;
+        let profileApplied = false;
+        let toolCalls = 0;
+        let toolLimitExceeded = false;
+        const startedAt = this.now();
+        const usage = () => ({
+            wall_time_ms: Math.max(0, this.now() - startedAt),
+            tool_calls: toolCalls,
+        });
+        const send = async (event) => {
+            if (serverTerminal)
+                return;
+            seq += 1;
+            const outgoing = { ...event, seq, event_id: event.event_id ?? randomUUID() };
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                try {
+                    await this.client.postEvent(runId, outgoing);
+                    return;
+                }
+                catch (err) {
+                    if (isRunTerminal(err)) {
+                        serverTerminal = true;
+                        controller.abort();
+                        return;
+                    }
+                    const retryable = !(err instanceof CourseClientError) || err.status === 429 || err.status >= 500;
+                    if (!retryable || attempt === 2)
+                        throw err;
+                    await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+                }
+            }
+        };
+        const sendTerminal = async (event) => {
+            if (serverTerminal || terminalSent)
+                return;
+            terminalSent = true;
+            try {
+                await send(event);
+            }
+            catch (err) {
+                this.log.error("failed to report terminal run event", {
+                    agentRunId: runId,
+                    eventType: event.type,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        };
+        const runtimeId = payload.runtime.id ?? this.defaultRuntimeId;
+        try {
+            await send({ type: "run.started" });
+            const runtime = this.runtimes.get(runtimeId);
+            if (!runtime) {
+                // 不做静默回退：用户在前端选了的 runtime 不可用必须显式失败。
+                await sendTerminal({
+                    type: "run.failed",
+                    error: `runtime '${runtimeId}' is not available on this daemon`,
+                    payload: { error_type: "runtime_unavailable", runtime: runtimeId, usage: usage() },
+                });
+                return;
+            }
+            if (serverTerminal)
+                return;
+            const expectedProfileHash = payload.context.profileHash;
+            if (typeof expectedProfileHash === "string") {
+                if (!this.client.getRunRuntimeProfile) {
+                    throw new RuntimeProfileApplyError("runtime profile client is unavailable");
+                }
+                const profile = await this.client.getRunRuntimeProfile(runId);
+                const applied = applyRunRuntimeProfile(payload, profile);
+                profileApplied = true;
+                payload.context.instructions = [
+                    ...(Array.isArray(payload.context.instructions)
+                        ? payload.context.instructions.filter((item) => typeof item === "string")
+                        : []),
+                    ...runtimeProfileInstructions(payload, applied),
+                ];
+            }
+            const { workspaceDir } = ensureRunWorkspace(runId);
+            const missingCapabilities = missingRunCapabilities(payload, workspaceDir);
+            if (missingCapabilities.length > 0) {
+                throw new RuntimeExecutionError(`runtime is missing required capabilities: ${missingCapabilities.join(", ")}`, "runtime_unavailable");
+            }
+            const transcript = new TranscriptWriter(transcriptPath(runId));
+            const timeoutSeconds = clampTimeoutSeconds(payload.limits.timeout_seconds);
+            timer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, timeoutSeconds * 1000);
+            let finalText = "";
+            // 上一次真正上了 wire 的块 kind：thinking/status 只在 kind 切换时上报一次，避免刷屏。
+            let lastReportedKind = null;
+            const sink = {
+                block: async (block) => {
+                    transcript.writeBlock(block);
+                    if (block.kind === "tool_call") {
+                        toolCalls += 1;
+                        const configured = payload.limits.max_tool_calls;
+                        const maxToolCalls = typeof configured === "number" && Number.isFinite(configured)
+                            ? Math.max(1, Math.min(1000, Math.floor(configured)))
+                            : 30;
+                        if (toolCalls > maxToolCalls) {
+                            toolLimitExceeded = true;
+                            controller.abort();
+                            return;
+                        }
+                    }
+                    if (serverTerminal)
+                        return;
+                    const perBlock = block.kind === "tool_call" || block.kind === "tool_result" || block.kind === "error";
+                    const onTransition = (block.kind === "thinking" || block.kind === "status") &&
+                        block.kind !== lastReportedKind;
+                    if (!perBlock && !onTransition)
+                        return;
+                    lastReportedKind = block.kind;
+                    await send({
+                        type: "run.block",
+                        text: redactSecretString(truncateText(block.text ?? "", BLOCK_TEXT_MAX_CHARS)),
+                        payload: { kind: block.kind, runtime: runtime.id },
+                    });
+                },
+                message: async (text) => {
+                    finalText = text;
+                },
+                file: async (file) => {
+                    await this.client.postFile(runId, file);
+                },
+            };
+            await runtime.run({ payload, workspaceDir }, sink, controller.signal);
+            clearTimeout(timer);
+            if (serverTerminal)
+                return;
+            if (controller.signal.aborted)
+                throw new Error("aborted");
+            const maxOutputChars = typeof payload.limits.max_output_chars === "number" &&
+                Number.isFinite(payload.limits.max_output_chars) &&
+                payload.limits.max_output_chars > 0
+                ? payload.limits.max_output_chars
+                : DEFAULT_MAX_OUTPUT_CHARS;
+            const output = redactSecretString(truncateText(finalText, maxOutputChars));
+            transcript.writeFinal(output);
+            const fileReport = await reportFileCandidates(this.client, runId, workspaceDir, this.log, this.scanLimits);
+            if (this.client.uploadFileContent && (fileReport.failed > 0 || fileReport.truncated)) {
+                throw new RuntimeExecutionError(fileReport.truncated
+                    ? "workspace file collection was truncated"
+                    : `failed to persist ${fileReport.failed} workspace file(s)`);
+            }
+            await send({ type: "run.message", role: "assistant", text: output });
+            await sendTerminal({
+                type: "run.completed",
+                payload: { runtime: runtimeId, usage: usage() },
+            });
+        }
+        catch (err) {
+            if (!serverTerminal) {
+                if (toolLimitExceeded) {
+                    await sendTerminal({
+                        type: "run.failed",
+                        error: "run exceeded max_tool_calls",
+                        payload: {
+                            error_type: "tool_budget_exceeded",
+                            runtime: runtimeId,
+                            usage: usage(),
+                        },
+                    });
+                }
+                else if (controller.signal.aborted && timedOut) {
+                    const timeoutSeconds = clampTimeoutSeconds(payload.limits.timeout_seconds);
+                    await sendTerminal({
+                        type: "run.failed",
+                        error: `run timed out after ${timeoutSeconds}s`,
+                        payload: { error_type: "timeout", runtime: runtimeId, usage: usage() },
+                    });
+                }
+                else if (controller.signal.aborted) {
+                    await sendTerminal({
+                        type: "run.cancelled",
+                        payload: { runtime: runtimeId, usage: usage() },
+                    });
+                }
+                else {
+                    const info = errorInfo(err);
+                    const errorType = err instanceof RuntimeExecutionError ? err.errorType : "runtime_error";
+                    await sendTerminal({
+                        type: "run.failed",
+                        error: info.error_message,
+                        payload: {
+                            error_type: errorType,
+                            runtime: runtimeId,
+                            usage: usage(),
+                            ...(err instanceof RuntimeProfileApplyError
+                                ? { code: err.code, profile_apply_status: "failed" }
+                                : {}),
+                        },
+                    });
+                }
+            }
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (profileApplied)
+                cleanupRunRuntimeProfile(runId);
+            this.inflight.delete(runId);
+        }
+    }
+}

package/dist/run-queue.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Run queue：第一版单机串行，同一 agent_instance 同时只跑一个 run。
+ *
+ * 不同 agent_instance 可并发；同一 instance 的任务排队执行，避免 workspace 竞争。
+ */
+export declare class RunQueue {
+    private readonly chains;
+    /** 把 task 排到 instanceKey 对应的串行链尾，返回其结果 Promise。 */
+    enqueue<T>(instanceKey: string, task: () => Promise<T>): Promise<T>;
+    get activeKeys(): string[];
+}

package/dist/run-queue.js

@@ -0,0 +1,26 @@
+/**
+ * Run queue：第一版单机串行，同一 agent_instance 同时只跑一个 run。
+ *
+ * 不同 agent_instance 可并发；同一 instance 的任务排队执行，避免 workspace 竞争。
+ */
+export class RunQueue {
+    chains = new Map();
+    /** 把 task 排到 instanceKey 对应的串行链尾，返回其结果 Promise。 */
+    enqueue(instanceKey, task) {
+        const prev = this.chains.get(instanceKey) ?? Promise.resolve();
+        const next = prev.then(task, task);
+        let tail;
+        tail = next
+            .then(() => undefined, () => undefined)
+            .finally(() => {
+            if (this.chains.get(instanceKey) === tail) {
+                this.chains.delete(instanceKey);
+            }
+        });
+        this.chains.set(instanceKey, tail);
+        return next;
+    }
+    get activeKeys() {
+        return [...this.chains.keys()];
+    }
+}

package/dist/runtime-capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { RunStartPayload } from "./types.js";
+export declare function availableRunCapabilities(payload: RunStartPayload, workspaceDir: string): string[];
+export declare function missingRunCapabilities(payload: RunStartPayload, workspaceDir: string): string[];

package/dist/runtime-capabilities.js

@@ -0,0 +1,42 @@
+import { randomUUID } from "node:crypto";
+import { unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const WEB_SEARCH_RUNTIMES = new Set([
+    "claude-code",
+    "deepseek-tui",
+    "gemini",
+    "kimi-cli",
+    "hermes-agent",
+    "fake",
+]);
+export function availableRunCapabilities(payload, workspaceDir) {
+    const capabilities = new Set();
+    const probePath = path.join(workspaceDir, `.botlearn-write-probe-${process.pid}-${randomUUID()}`);
+    try {
+        writeFileSync(probePath, "", { flag: "wx" });
+        unlinkSync(probePath);
+        capabilities.add("workspace.write");
+    }
+    catch {
+        try {
+            unlinkSync(probePath);
+        }
+        catch {
+            // The probe may fail before creating a file.
+        }
+        // An unwritable workspace must never be advertised from static deployment config.
+    }
+    const runtimeId = payload.runtime.id ?? "codex";
+    if (WEB_SEARCH_RUNTIMES.has(runtimeId) ||
+        (runtimeId === "codex" && payload.runtime.web_search === true)) {
+        capabilities.add("web.search");
+    }
+    return Array.from(capabilities).sort();
+}
+export function missingRunCapabilities(payload, workspaceDir) {
+    const required = Array.isArray(payload.context.requiredCapabilities)
+        ? payload.context.requiredCapabilities.filter((item) => typeof item === "string" && item.length > 0)
+        : [];
+    const available = new Set(availableRunCapabilities(payload, workspaceDir));
+    return Array.from(new Set(required.filter((item) => !available.has(item)))).sort();
+}

package/dist/runtime-profile.d.ts

@@ -0,0 +1,8 @@
+import type { AppliedRunRuntimeProfile, RunStartPayload } from "./types.js";
+export declare class RuntimeProfileApplyError extends Error {
+    readonly code = "profile_apply_failed";
+    constructor(message: string);
+}
+export declare function applyRunRuntimeProfile(payload: RunStartPayload, raw: unknown): AppliedRunRuntimeProfile;
+export declare function cleanupRunRuntimeProfile(agentRunId: string): void;
+export declare function runtimeProfileInstructions(payload: RunStartPayload, applied: AppliedRunRuntimeProfile): string[];

package/dist/runtime-profile.js

@@ -0,0 +1,213 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { runtimeProfileDir, runRootDir } from "./workspace.js";
+const SAFE_ASSET_ID = /^[a-z0-9][a-z0-9._-]{0,159}$/;
+const SHA256 = /^sha256:[0-9a-f]{64}$/;
+const MAX_SKILL_PACKAGES = 32;
+const MAX_PACKAGE_FILES = 128;
+const MAX_PACKAGE_BYTES = 2 * 1024 * 1024;
+const MAX_PROMPT_CHARS = 50_000;
+export class RuntimeProfileApplyError extends Error {
+    code = "profile_apply_failed";
+    constructor(message) {
+        super(message);
+        this.name = "RuntimeProfileApplyError";
+    }
+}
+export function applyRunRuntimeProfile(payload, raw) {
+    const profile = validateRuntimeProfile(raw);
+    if (payload.context.profileHash !== profile.profileHash) {
+        throw new RuntimeProfileApplyError("run.start profileHash does not match runtime profile");
+    }
+    const runDir = runRootDir(payload.agent_run_id);
+    const target = runtimeProfileDir(payload.agent_run_id);
+    mkdirSync(runDir, { recursive: true, mode: 0o700 });
+    const staging = mkdtempSync(path.join(runDir, ".runtime-profile-"));
+    try {
+        const skillsRoot = path.join(staging, "skills");
+        mkdirSync(skillsRoot, { recursive: true, mode: 0o700 });
+        const skillRefs = [];
+        const skillIds = new Set();
+        for (const skill of profile.skillPackages) {
+            if (skillIds.has(skill.id)) {
+                throw new RuntimeProfileApplyError(`duplicate runtime Skill id: ${skill.id}`);
+            }
+            skillIds.add(skill.id);
+            installSkillPackage(skillsRoot, skill);
+            skillRefs.push(`${skill.id}@${skill.version}`);
+        }
+        const promptPackPath = path.join(staging, "prompt-pack.md");
+        writeFileSync(promptPackPath, profile.promptPack.systemInstructions, { mode: 0o600 });
+        writeFileSync(path.join(staging, "profile.json"), `${JSON.stringify({
+            schemaVersion: profile.schemaVersion,
+            profileId: profile.profileId,
+            profileHash: profile.profileHash,
+            courseVersionId: profile.courseVersionId,
+            promptPack: {
+                id: profile.promptPack.id,
+                version: profile.promptPack.version,
+                digest: profile.promptPack.digest,
+            },
+            skillRefs,
+            requiredCapabilities: profile.requiredCapabilities,
+        }, null, 2)}\n`, { mode: 0o600 });
+        rmSync(target, { recursive: true, force: true });
+        renameSync(staging, target);
+        return {
+            profileId: profile.profileId,
+            profileHash: profile.profileHash,
+            promptPackPath: path.join(target, "prompt-pack.md"),
+            skillsRoot: path.join(target, "skills"),
+            skillRefs,
+        };
+    }
+    catch (err) {
+        rmSync(staging, { recursive: true, force: true });
+        if (err instanceof RuntimeProfileApplyError)
+            throw err;
+        throw new RuntimeProfileApplyError(err instanceof Error ? err.message : String(err));
+    }
+}
+export function cleanupRunRuntimeProfile(agentRunId) {
+    rmSync(runtimeProfileDir(agentRunId), { recursive: true, force: true });
+}
+export function runtimeProfileInstructions(payload, applied) {
+    const selected = stringValues(payload.context.skillRefs);
+    const available = new Set(applied.skillRefs);
+    const missing = selected.filter((ref) => !available.has(ref));
+    if (missing.length > 0) {
+        throw new RuntimeProfileApplyError(`runtime profile is missing Skills: ${missing.join(", ")}`);
+    }
+    const enabled = selected.length > 0 ? selected : applied.skillRefs;
+    return [
+        `[BotLearn Course Prompt Pack: ${applied.profileId}]`,
+        `Read the trusted prompt pack at ${applied.promptPackPath}.`,
+        ...(enabled.length > 0
+            ? [
+                "The following Skills are enabled only for this AgentRun:",
+                ...enabled.map((ref) => {
+                    const id = ref.split("@", 1)[0];
+                    return `- ${ref}: ${path.join(applied.skillsRoot, id, "SKILL.md")}`;
+                }),
+            ]
+            : []),
+    ];
+}
+function installSkillPackage(skillsRoot, skill) {
+    assertSafeAssetId(skill.id, "Skill id");
+    if (!SHA256.test(skill.digest)) {
+        throw new RuntimeProfileApplyError(`Skill ${skill.id} has an invalid digest`);
+    }
+    const entries = archiveEntries(skill);
+    if (packageDigest(entries) !== skill.digest) {
+        throw new RuntimeProfileApplyError(`Skill ${skill.id}@${skill.version} digest mismatch`);
+    }
+    const skillDir = path.join(skillsRoot, skill.id);
+    mkdirSync(skillDir, { recursive: true, mode: 0o700 });
+    for (const entry of entries) {
+        const destination = path.join(skillDir, entry.path);
+        mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+        writeFileSync(destination, entry.content, { mode: 0o600 });
+    }
+}
+function archiveEntries(skill) {
+    const archive = skill.archiveManifest;
+    if (!archive || typeof archive.skillMd !== "string" || !archive.skillMd.trim()) {
+        throw new RuntimeProfileApplyError(`Skill ${skill.id} has no SKILL.md content`);
+    }
+    if (archive.name !== undefined && archive.name !== skill.id) {
+        throw new RuntimeProfileApplyError(`Skill ${skill.id} archive name does not match its id`);
+    }
+    if ((archive.files?.length ?? 0) + 1 > MAX_PACKAGE_FILES) {
+        throw new RuntimeProfileApplyError(`Skill ${skill.id} archive has too many files`);
+    }
+    const entries = [{ path: "SKILL.md", content: archive.skillMd }];
+    const seen = new Set(["SKILL.md"]);
+    for (const file of archive.files ?? []) {
+        validateArchiveFile(file, skill.id);
+        const relative = safeRelativePath(file.path);
+        if (seen.has(relative)) {
+            throw new RuntimeProfileApplyError(`Skill ${skill.id} has duplicate file ${relative}`);
+        }
+        seen.add(relative);
+        entries.push({ path: relative, content: file.content });
+    }
+    const total = entries.reduce((sum, entry) => sum + Buffer.byteLength(entry.content), 0);
+    if (total > MAX_PACKAGE_BYTES) {
+        throw new RuntimeProfileApplyError(`Skill ${skill.id} archive is too large`);
+    }
+    return entries.sort((a, b) => a.path.localeCompare(b.path));
+}
+function validateArchiveFile(file, skillId) {
+    if (!file || typeof file.path !== "string" || typeof file.content !== "string") {
+        throw new RuntimeProfileApplyError(`Skill ${skillId} contains an invalid archive file`);
+    }
+    const bytes = Buffer.from(file.content, "utf8");
+    if (file.size !== undefined && file.size !== bytes.length) {
+        throw new RuntimeProfileApplyError(`Skill ${skillId} file ${file.path} size mismatch`);
+    }
+    if (file.sha256 !== undefined) {
+        const digest = createHash("sha256").update(bytes).digest("hex");
+        if (file.sha256 !== digest) {
+            throw new RuntimeProfileApplyError(`Skill ${skillId} file ${file.path} digest mismatch`);
+        }
+    }
+}
+function packageDigest(entries) {
+    const digest = createHash("sha256");
+    for (const entry of entries) {
+        digest.update(Buffer.from(entry.path, "utf8"));
+        digest.update(Buffer.from([0]));
+        digest.update(Buffer.from(entry.content, "utf8"));
+        digest.update(Buffer.from([0]));
+    }
+    return `sha256:${digest.digest("hex")}`;
+}
+function validateRuntimeProfile(raw) {
+    if (!raw || typeof raw !== "object") {
+        throw new RuntimeProfileApplyError("runtime profile must be an object");
+    }
+    const profile = raw;
+    if (profile.schemaVersion !== "botlearn-course-runtime-profile/0.1") {
+        throw new RuntimeProfileApplyError("unsupported runtime profile schemaVersion");
+    }
+    assertSafeAssetId(profile.profileId, "Profile id");
+    if (typeof profile.profileHash !== "string" || !SHA256.test(profile.profileHash)) {
+        throw new RuntimeProfileApplyError("runtime profile has an invalid profileHash");
+    }
+    if (!profile.promptPack || typeof profile.promptPack.systemInstructions !== "string") {
+        throw new RuntimeProfileApplyError("runtime profile has an invalid Prompt Pack");
+    }
+    assertSafeAssetId(profile.promptPack.id, "Prompt Pack id");
+    if (!SHA256.test(profile.promptPack.digest) ||
+        !profile.promptPack.systemInstructions.trim() ||
+        profile.promptPack.systemInstructions.length > MAX_PROMPT_CHARS) {
+        throw new RuntimeProfileApplyError("runtime profile Prompt Pack is invalid");
+    }
+    if (!Array.isArray(profile.skillPackages) || !Array.isArray(profile.requiredCapabilities)) {
+        throw new RuntimeProfileApplyError("runtime profile has invalid Skill or capability lists");
+    }
+    if (profile.skillPackages.length > MAX_SKILL_PACKAGES) {
+        throw new RuntimeProfileApplyError("runtime profile has too many Skill packages");
+    }
+    return profile;
+}
+function safeRelativePath(value) {
+    if (!value ||
+        value.includes("\\") ||
+        value.includes("\0") ||
+        path.posix.isAbsolute(value) ||
+        value.split("/").some((part) => part === "" || part === "." || part === "..")) {
+        throw new RuntimeProfileApplyError(`unsafe Skill archive path: ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+function assertSafeAssetId(value, label) {
+    if (typeof value !== "string" || !SAFE_ASSET_ID.test(value)) {
+        throw new RuntimeProfileApplyError(`${label} is unsafe`);
+    }
+}
+function stringValues(raw) {
+    return Array.isArray(raw) ? raw.filter((item) => typeof item === "string") : [];
+}