@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/telemetry/skills/claude/observations.js

@@ -0,0 +1,366 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { claudeAvailableSkillNames, claudeSkillCapabilityId, normalizedClaudeSkillName, } from "./catalog.js";
+const MAX_SKILL_PATH_CHARS = 16 * 1024;
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+const BUDGET_REMINDER_PREFIX = "\n\n<system-reminder>\nUSD budget: ";
+const BUDGET_REMINDER_SUFFIX = "\n</system-reminder>";
+export function claudeSkillObservations(request, limit) {
+    return request.requestPurpose === "tool_continuation"
+        ? confirmedSkillObservations(request, limit)
+        : request.requestPurpose === undefined
+            ? directSkillObservations(request, limit)
+            : [];
+}
+function directSkillObservations(request, limit) {
+    const message = latestUserMessage(request);
+    if (message === undefined)
+        return [];
+    const availableSkills = claudeAvailableSkillNames(request);
+    return directSkillNames(message, availableSkills)
+        .slice(0, limit)
+        .map((name) => observation(name, null, "skill_command_expansion"));
+}
+function confirmedSkillObservations(request, limit) {
+    const confirmedGroups = [];
+    let confirmedCount = 0;
+    const skillCallsByResultIndex = callsByResultIndex(request);
+    const availableSkills = claudeAvailableSkillNames(request);
+    let index = request.items.length - 1;
+    while (index >= 0) {
+        while (index >= 0 && isBudgetStatusMessage(request.items[index]))
+            index -= 1;
+        if (index < 0)
+            break;
+        const expansionEvidence = skillExpansionEvidence(request.items[index]);
+        let resultStart = expansionEvidence === undefined ? index + 1 : index;
+        while (resultStart > 0) {
+            const item = request.items[resultStart - 1];
+            if (item.type !== "tool_result")
+                break;
+            resultStart -= 1;
+        }
+        const resultEnd = expansionEvidence === undefined ? index + 1 : index;
+        if (resultStart === resultEnd)
+            break;
+        const remaining = limit - confirmedCount;
+        const group = [];
+        let inlineCount = 0;
+        let forkedCount = 0;
+        for (let resultIndex = resultStart; resultIndex < resultEnd; resultIndex += 1) {
+            const item = request.items[resultIndex];
+            if (item.type !== "tool_result")
+                break;
+            const call = skillCallsByResultIndex.get(resultIndex);
+            const output = toolResultText(item);
+            if (call === undefined || item.isError === true || output === undefined)
+                continue;
+            if (isInlineSkillResult(output, call.name)) {
+                if (expansionEvidence !== undefined) {
+                    const evidence = expansionEvidence[inlineCount];
+                    if (evidence?.name !== undefined && evidence.name !== call.name) {
+                        return orderedGroups(confirmedGroups);
+                    }
+                    const redundantDirectInvocation = evidence?.name !== undefined
+                        && latestUserBeforeCallIncludesDirectSkill(request, call.callIndex, call.name, availableSkills);
+                    if (!redundantDirectInvocation && group.length < remaining) {
+                        group.push(observation(call.name, item.callId, "skill_tool_activation"));
+                    }
+                }
+                inlineCount += 1;
+                continue;
+            }
+            if (isForkedSkillResult(output, call.name)) {
+                forkedCount += 1;
+                if (group.length < remaining) {
+                    group.push(observation(call.name, item.callId, "skill_tool_activation"));
+                }
+            }
+        }
+        if (expansionEvidence === undefined) {
+            if (forkedCount === 0)
+                break;
+        }
+        else if (inlineCount !== expansionEvidence.length) {
+            break;
+        }
+        confirmedGroups.push(group);
+        confirmedCount += group.length;
+        if (confirmedCount === limit)
+            break;
+        index = resultStart - 1;
+    }
+    return orderedGroups(confirmedGroups);
+}
+function isBudgetStatusMessage(item) {
+    if (item.type !== "message"
+        || (item.role !== "system" && item.role !== "developer")
+        || item.content.length !== 1
+        || item.content[0].type !== "text") {
+        return false;
+    }
+    const lines = item.content[0].text.split("\n\n");
+    return lines.length > 0 && lines.every((line) => {
+        if (!line.startsWith("USD budget: "))
+            return false;
+        const value = line.slice("USD budget: ".length);
+        return value.length > 0 && value.length <= 256 && !/[\n<>]/u.test(value);
+    });
+}
+function orderedGroups(groups) {
+    groups.reverse();
+    return groups.flat();
+}
+function skillCallName(item) {
+    const input = item.input;
+    if (item.kind !== "function"
+        || item.namespace !== undefined
+        || item.name !== "Skill"
+        || !isRecord(input)) {
+        return undefined;
+    }
+    const inputKeys = Object.keys(input);
+    if (inputKeys.some((key) => key !== "skill" && key !== "args")
+        || (input.args !== undefined && typeof input.args !== "string")) {
+        return undefined;
+    }
+    return normalizedClaudeSkillName(input.skill);
+}
+function callsByResultIndex(request) {
+    const latestCalls = new Map();
+    const resultCalls = new Map();
+    for (let index = 0; index < request.items.length; index += 1) {
+        const item = request.items[index];
+        if (item.type === "tool_call") {
+            const name = skillCallName(item);
+            latestCalls.set(item.callId, name === undefined ? null : { name, callIndex: index });
+            continue;
+        }
+        if (item.type !== "tool_result")
+            continue;
+        const call = latestCalls.get(item.callId);
+        if (call !== undefined && call !== null)
+            resultCalls.set(index, call);
+    }
+    return resultCalls;
+}
+function skillExpansionEvidence(item) {
+    if (item.type !== "message" || item.role !== "user" || item.content.length === 0) {
+        return undefined;
+    }
+    const evidence = [];
+    for (const part of item.content) {
+        if (part.type !== "text")
+            return undefined;
+        if (isSkillExpansion(part.text)) {
+            evidence.push({});
+            continue;
+        }
+        const name = alreadyLoadedSkillName(part.text);
+        if (name === undefined)
+            return undefined;
+        evidence.push({ name });
+    }
+    return evidence;
+}
+function isForkedSkillResult(output, name) {
+    const normalized = withoutBudgetReminders(output);
+    if (normalized === undefined)
+        return false;
+    const launched = `Skill "${name}" launched (forked execution, running in the background).`;
+    if (normalized === launched
+        || normalized === `${launched}\n\nRunning in the background as @${name}`) {
+        return true;
+    }
+    const completed = `Skill "${name}" completed (forked execution).\n\nResult:\n`;
+    return normalized.startsWith(completed)
+        && normalized.slice(completed.length).trim().length > 0;
+}
+function isInlineSkillResult(output, name) {
+    return withoutBudgetReminders(output) === `Launching skill: ${name}`;
+}
+function withoutBudgetReminders(output) {
+    const firstReminder = output.indexOf(BUDGET_REMINDER_PREFIX);
+    if (firstReminder < 0)
+        return output;
+    let cursor = firstReminder;
+    while (cursor < output.length) {
+        if (!output.startsWith(BUDGET_REMINDER_PREFIX, cursor))
+            return undefined;
+        const valueStart = cursor + BUDGET_REMINDER_PREFIX.length;
+        const valueEnd = output.indexOf(BUDGET_REMINDER_SUFFIX, valueStart);
+        if (valueEnd < 0)
+            return undefined;
+        const value = output.slice(valueStart, valueEnd);
+        if (value.length === 0 || value.length > 256 || /[\n<>]/u.test(value)) {
+            return undefined;
+        }
+        cursor = valueEnd + BUDGET_REMINDER_SUFFIX.length;
+    }
+    return output.slice(0, firstReminder);
+}
+function latestUserBeforeCallIncludesDirectSkill(request, callIndex, name, availableSkills) {
+    for (let index = callIndex - 1; index >= 0; index -= 1) {
+        const item = request.items[index];
+        if (item.type !== "message" || item.role !== "user")
+            continue;
+        return directSkillNames(item, availableSkills).includes(name);
+    }
+    return false;
+}
+function alreadyLoadedSkillName(text) {
+    const prefix = "Skill /";
+    const marker = " is already loaded above; instructions unchanged.";
+    if (!text.startsWith(prefix))
+        return undefined;
+    const markerIndex = text.indexOf(marker, prefix.length);
+    if (markerIndex < 0)
+        return undefined;
+    const suffix = text.slice(markerIndex + marker.length);
+    if (suffix !== "" && !suffix.startsWith(" Arguments:"))
+        return undefined;
+    return normalizedClaudeSkillName(text.slice(prefix.length, markerIndex));
+}
+function directSkillNames(message, availableSkills) {
+    const names = [];
+    for (let index = 0; index < message.content.length; index += 1) {
+        const command = message.content[index];
+        const expansion = message.content[index + 1];
+        if (command.type === "text" && expansion?.type === "text") {
+            const name = commandName(command.text);
+            if (name !== undefined
+                && (isSkillExpansion(expansion.text)
+                    || (availableSkills.has(name) && isLegacyCommandBody(expansion.text)))) {
+                names.push(name);
+                index += 1;
+                continue;
+            }
+        }
+        const backgroundName = directBackgroundSkillName(message, index);
+        if (backgroundName !== undefined)
+            names.push(backgroundName);
+    }
+    return names;
+}
+function isLegacyCommandBody(text) {
+    const trimmed = text.trim();
+    return trimmed.length > 0
+        && !trimmed.startsWith("<system-reminder>")
+        && !trimmed.startsWith("<local-command-")
+        && !trimmed.startsWith("<command-");
+}
+function directBackgroundSkillName(message, index) {
+    const current = message.content[index];
+    const previous = message.content[index - 1];
+    if (current?.type !== "text" || previous?.type !== "text")
+        return undefined;
+    const lines = current.text.trimEnd().split("\n");
+    if (lines.length !== 2)
+        return undefined;
+    const stdoutPrefix = "<local-command-stdout>Running in the background as @";
+    const stdoutSuffix = "</local-command-stdout>";
+    if (!lines[0]?.startsWith(stdoutPrefix) || !lines[0].endsWith(stdoutSuffix)) {
+        return undefined;
+    }
+    const stdoutName = normalizedClaudeSkillName(lines[0].slice(stdoutPrefix.length, -stdoutSuffix.length));
+    const launchPrefix = "<forked-skill-launch>";
+    const launchSuffix = "</forked-skill-launch>";
+    const launchLine = lines[1];
+    if (!launchLine?.startsWith(launchPrefix) || !launchLine.endsWith(launchSuffix)) {
+        return undefined;
+    }
+    let launch;
+    try {
+        launch = JSON.parse(launchLine.slice(launchPrefix.length, -launchSuffix.length));
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(launch) || Object.keys(launch).some((key) => key !== "agentId" && key !== "skillName" && key !== "description")) {
+        return undefined;
+    }
+    const name = normalizedClaudeSkillName(launch.skillName);
+    if (name === undefined
+        || stdoutName !== name
+        || typeof launch.agentId !== "string"
+        || !/^[a-f0-9]{16,64}$/u.test(launch.agentId)
+        || typeof launch.description !== "string"
+        || (launch.description !== `/${name}` && !launch.description.startsWith(`/${name} `))) {
+        return undefined;
+    }
+    const command = previous.text.trimEnd();
+    return command === `/${name}` || command.startsWith(`/${name} `)
+        ? name
+        : undefined;
+}
+function toolResultText(result) {
+    if (typeof result.output === "string")
+        return result.output;
+    if (Array.isArray(result.output)
+        && result.output.length === 1
+        && result.output[0].type === "text") {
+        return result.output[0].text;
+    }
+    return undefined;
+}
+function latestUserMessage(request) {
+    for (let index = request.items.length - 1; index >= 0; index -= 1) {
+        const item = request.items[index];
+        if (item.type === "message" && (item.role === "system" || item.role === "developer")) {
+            continue;
+        }
+        return item.type === "message" && item.role === "user" ? item : undefined;
+    }
+    return undefined;
+}
+function commandName(text) {
+    const firstBreak = text.indexOf("\n");
+    const secondBreak = firstBreak < 0 ? -1 : text.indexOf("\n", firstBreak + 1);
+    if (firstBreak < 0 || secondBreak < 0)
+        return undefined;
+    const firstLine = text.slice(0, firstBreak);
+    const secondLine = text.slice(firstBreak + 1, secondBreak);
+    const rest = text.slice(secondBreak + 1);
+    const name = exactTagValue(firstLine, "command-message");
+    const hasExactArguments = rest.startsWith("<command-args>")
+        && (rest.endsWith("</command-args>") || rest.endsWith("</command-args>\n"));
+    if (name === undefined
+        || secondLine !== `<command-name>/${name}</command-name>`
+        || (rest !== "" && !hasExactArguments)) {
+        return undefined;
+    }
+    return normalizedClaudeSkillName(name);
+}
+function isSkillExpansion(text) {
+    const prefix = "Base directory for this skill: ";
+    if (!text.startsWith(prefix))
+        return false;
+    const pathEnd = text.indexOf("\n", prefix.length);
+    if (pathEnd < 0 || !text.slice(pathEnd).startsWith("\n\n"))
+        return false;
+    const path = normalizedSkillPath(text.slice(prefix.length, pathEnd));
+    return path !== undefined && text.slice(pathEnd + 2).trim().length > 0;
+}
+function exactTagValue(line, tag) {
+    const prefix = `<${tag}>`;
+    const suffix = `</${tag}>`;
+    return line.startsWith(prefix) && line.endsWith(suffix)
+        ? line.slice(prefix.length, -suffix.length)
+        : undefined;
+}
+function observation(name, toolCallId, evidenceSource) {
+    return {
+        eventType: "skill_use",
+        toolCallId,
+        capabilityId: claudeSkillCapabilityId(name),
+        observedName: name,
+        evidenceSource,
+    };
+}
+function normalizedSkillPath(value) {
+    const normalized = value.normalize("NFC");
+    return normalized.length > 0
+        && normalized.length <= MAX_SKILL_PATH_CHARS
+        && !UNSAFE_DISPLAY_CHARACTERS.test(normalized)
+        ? normalized
+        : undefined;
+}

package/dist/telemetry/skills/codex/catalog.d.ts

@@ -0,0 +1,11 @@
+import type { InteractionRequest } from "../../../interaction/types.js";
+import { type NormalizedSkillPath, type PathPlatform } from "../paths.js";
+export type CatalogSkill = {
+    name: string;
+    path: NormalizedSkillPath;
+};
+export type CodexSkillCatalog = {
+    platform: PathPlatform;
+    byPath: ReadonlyMap<string, CatalogSkill>;
+};
+export declare function codexFileSkillCatalog(request: InteractionRequest): CodexSkillCatalog | undefined;

package/dist/telemetry/skills/codex/catalog.js

@@ -0,0 +1,138 @@
+import { normalizedCodexSkillName } from "./identity.js";
+import { joinedSkillPath, normalizedAbsoluteSkillPath, skillPathBasename, } from "../paths.js";
+const MAX_CATALOG_ENTRIES = 2_000;
+const SKILLS_OPEN = "<skills_instructions>";
+const SKILLS_CLOSE = "</skills_instructions>";
+const SKILL_ROOTS = "### Skill roots\n";
+const SKILLS_LIST = "### Available skills\n";
+const FILE_LOCATOR = " (file: ";
+const SKILL_ROOT = /^- `(?<alias>r[0-9]+)` = `(?<path>[^`\n]+)`$/u;
+export function codexFileSkillCatalog(request) {
+    const instructionTexts = request.items.flatMap((item) => {
+        if (item.type !== "message"
+            || (item.role !== "developer" && item.role !== "system"))
+            return [];
+        return item.content.flatMap((part) => part.type === "text" ? [part.text] : []);
+    });
+    if (request.instructions !== undefined)
+        instructionTexts.push(request.instructions);
+    let latestCatalog;
+    for (const instructionText of instructionTexts) {
+        const blocks = skillInstructionBlocks(normalizedLineEndings(instructionText));
+        if (blocks === undefined) {
+            latestCatalog = undefined;
+            continue;
+        }
+        for (const block of blocks) {
+            const listStart = block.indexOf(SKILLS_LIST);
+            const roots = listStart < 0
+                ? undefined
+                : catalogRoots(block.slice(0, listStart));
+            latestCatalog = listStart < 0 || roots === undefined
+                ? undefined
+                : catalogEntries(block.slice(listStart + SKILLS_LIST.length).split("\n"), roots);
+        }
+    }
+    return latestCatalog;
+}
+function catalogRoots(blockPrefix) {
+    const roots = new Map();
+    const rootsStart = blockPrefix.indexOf(SKILL_ROOTS);
+    if (rootsStart < 0)
+        return roots;
+    let platform;
+    for (const line of blockPrefix.slice(rootsStart + SKILL_ROOTS.length).split("\n")) {
+        if (line.startsWith("### "))
+            break;
+        const match = line.match(SKILL_ROOT);
+        if (match?.groups === undefined)
+            continue;
+        const path = normalizedAbsoluteSkillPath(match.groups.path);
+        if (path === undefined
+            || roots.has(match.groups.alias)
+            || (platform !== undefined && path.platform !== platform))
+            return undefined;
+        platform = path.platform;
+        roots.set(match.groups.alias, path);
+        if (roots.size > MAX_CATALOG_ENTRIES)
+            return undefined;
+    }
+    return roots;
+}
+function catalogEntries(lines, roots) {
+    const catalog = new Map();
+    const ambiguousPaths = new Set();
+    let entryCount = 0;
+    let platform;
+    for (const line of lines) {
+        if (line.startsWith("### "))
+            break;
+        const skill = catalogSkill(line, roots);
+        if (skill === undefined)
+            continue;
+        entryCount += 1;
+        if (entryCount > MAX_CATALOG_ENTRIES
+            || (platform !== undefined && skill.path.platform !== platform))
+            return undefined;
+        platform = skill.path.platform;
+        if (ambiguousPaths.has(skill.path.key))
+            continue;
+        const previous = catalog.get(skill.path.key);
+        if (previous !== undefined && previous.name !== skill.name) {
+            catalog.delete(skill.path.key);
+            ambiguousPaths.add(skill.path.key);
+        }
+        else {
+            catalog.set(skill.path.key, skill);
+        }
+    }
+    return platform === undefined || catalog.size === 0
+        ? undefined
+        : { platform, byPath: catalog };
+}
+function catalogSkill(line, roots) {
+    if (!line.startsWith("- ") || !line.endsWith(")"))
+        return undefined;
+    const nameEnd = line.indexOf(": ", 2);
+    const locatorStart = line.lastIndexOf(FILE_LOCATOR);
+    if (nameEnd < 0 || locatorStart <= nameEnd)
+        return undefined;
+    const name = normalizedCodexSkillName(line.slice(2, nameEnd));
+    const path = catalogPath(line.slice(locatorStart + FILE_LOCATOR.length, -1), roots);
+    return name === undefined
+        || path === undefined
+        || skillPathBasename(path).toLowerCase() !== "skill.md"
+        ? undefined
+        : { name, path };
+}
+function catalogPath(locator, roots) {
+    const absolute = normalizedAbsoluteSkillPath(locator);
+    if (absolute !== undefined)
+        return absolute;
+    const separator = locator.indexOf("/");
+    if (separator <= 0)
+        return undefined;
+    const root = roots.get(locator.slice(0, separator));
+    return root === undefined
+        ? undefined
+        : joinedSkillPath(root, locator.slice(separator + 1));
+}
+function normalizedLineEndings(value) {
+    return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+function skillInstructionBlocks(text) {
+    const blocks = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const start = text.indexOf(SKILLS_OPEN, cursor);
+        if (start < 0)
+            break;
+        const bodyStart = start + SKILLS_OPEN.length;
+        const end = text.indexOf(SKILLS_CLOSE, bodyStart);
+        if (end < 0)
+            return undefined;
+        blocks.push(text.slice(bodyStart, end));
+        cursor = end + SKILLS_CLOSE.length;
+    }
+    return blocks;
+}

package/dist/telemetry/skills/codex/exec_file_reads.d.ts

@@ -0,0 +1,9 @@
+import type { InteractionOutput } from "../../../interaction/types.js";
+import type { CatalogSkill, CodexSkillCatalog } from "./catalog.js";
+export type CodexExecCommand = {
+    callId: string;
+    command: string;
+    workdir?: string;
+};
+export declare function codexExecCommand(item: InteractionOutput["items"][number]): CodexExecCommand | undefined;
+export declare function readSkillsFromCodexCommand(input: CodexExecCommand, catalog: CodexSkillCatalog): CatalogSkill[];

package/dist/telemetry/skills/codex/exec_file_reads.js

@@ -0,0 +1,36 @@
+import { interactionToolInput } from "../../tools/input.js";
+import { readPathsFromShellCommand } from "../shell_file_reads.js";
+const MAX_COMMAND_CHARS = 64 * 1024;
+const MAX_SKILL_PATH_CHARS = 16 * 1024;
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+const UNSAFE_COMMAND_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+export function codexExecCommand(item) {
+    if (item.type !== "tool_call"
+        || item.kind !== "function"
+        || item.namespace !== undefined
+        || item.name !== "exec_command")
+        return undefined;
+    const input = interactionToolInput(item);
+    if (input === undefined)
+        return undefined;
+    const command = input.cmd;
+    const workdir = input.workdir;
+    if (typeof command !== "string"
+        || command.length === 0
+        || command.length > MAX_COMMAND_CHARS
+        || UNSAFE_COMMAND_CHARACTERS.test(command)
+        || (workdir !== undefined && (typeof workdir !== "string"
+            || workdir.length === 0
+            || workdir.length > MAX_SKILL_PATH_CHARS
+            || UNSAFE_DISPLAY_CHARACTERS.test(workdir))))
+        return undefined;
+    return workdir === undefined
+        ? { callId: item.callId, command }
+        : { callId: item.callId, command, workdir };
+}
+export function readSkillsFromCodexCommand(input, catalog) {
+    return readPathsFromShellCommand(input, catalog.platform).flatMap((path) => {
+        const skill = catalog.byPath.get(path.key);
+        return skill === undefined ? [] : [skill];
+    });
+}

package/dist/telemetry/skills/codex/explicit.d.ts

@@ -0,0 +1,3 @@
+import type { InteractionRequest } from "../../../interaction/types.js";
+import type { SkillObservation } from "../observations.js";
+export declare function codexExplicitSkillObservations(request: InteractionRequest, currentTurnId: string, limit: number): SkillObservation[];

package/dist/telemetry/skills/codex/explicit.js

@@ -0,0 +1,90 @@
+import { codexSkillCapabilityId, normalizedCodexSkillName, } from "./identity.js";
+const MAX_SKILL_PATH_CHARS = 16 * 1024;
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+const SKILL_MENTION = /\$([A-Za-z0-9][A-Za-z0-9_:-]*)/gu;
+export function codexExplicitSkillObservations(request, currentTurnId, limit) {
+    let currentUserStart = request.items.length;
+    while (currentUserStart > 0) {
+        const item = request.items[currentUserStart - 1];
+        if (item.type !== "message" || item.role !== "user")
+            break;
+        currentUserStart -= 1;
+    }
+    const parsed = [];
+    for (let index = currentUserStart; index < request.items.length; index += 1) {
+        const message = request.items[index];
+        if (message.type !== "message" || message.role !== "user")
+            continue;
+        parsed.push({ message, skill: parseCodexSkillMessage(message) });
+    }
+    const mentionedNames = new Set();
+    const observed = [];
+    const observedInjections = new Set();
+    for (const { message, skill } of parsed) {
+        if (skill !== undefined) {
+            const injection = skillInjectionKey(skill);
+            if ((message.clientTurnId?.toLowerCase() === currentTurnId.toLowerCase()
+                || (message.clientTurnId === undefined
+                    && mentionedNames.has(skill.name)))
+                && !observedInjections.has(injection)) {
+                observedInjections.add(injection);
+                observed.push(observation(skill.name));
+                if (observed.length === limit)
+                    break;
+            }
+            continue;
+        }
+        for (const match of textParts(message).join("").matchAll(SKILL_MENTION)) {
+            if (match[1] !== undefined)
+                mentionedNames.add(match[1]);
+        }
+    }
+    return observed;
+}
+function observation(name) {
+    return {
+        eventType: "skill_use",
+        toolCallId: null,
+        capabilityId: codexSkillCapabilityId(name),
+        observedName: name,
+        evidenceSource: "skill_content_injection",
+    };
+}
+function parseCodexSkillMessage(message) {
+    if (message.content.length !== 1 || message.content[0].type !== "text") {
+        return undefined;
+    }
+    const text = message.content[0].text;
+    const prefix = "<skill>\n<name>";
+    if (!text.startsWith(prefix) || !text.endsWith("\n</skill>"))
+        return undefined;
+    const nameEnd = text.indexOf("</name>\n<path>", prefix.length);
+    if (nameEnd < 0)
+        return undefined;
+    const pathStart = nameEnd + "</name>\n<path>".length;
+    const pathEnd = text.indexOf("</path>\n", pathStart);
+    if (pathEnd < 0)
+        return undefined;
+    const bodyStart = pathEnd + "</path>\n".length;
+    const bodyEnd = text.length - "\n</skill>".length;
+    if (bodyEnd <= bodyStart || text.slice(bodyStart, bodyEnd).trim().length === 0) {
+        return undefined;
+    }
+    const name = normalizedCodexSkillName(text.slice(prefix.length, nameEnd));
+    const path = normalizedSkillPath(text.slice(pathStart, pathEnd));
+    return name === undefined || path === undefined ? undefined : { name, path };
+}
+function skillInjectionKey(skill) {
+    return `${skill.name}\u0000${skill.path}`;
+}
+function normalizedSkillPath(value) {
+    const normalized = value.normalize("NFC");
+    return normalized.length > 0
+        && normalized.length <= MAX_SKILL_PATH_CHARS
+        && !UNSAFE_DISPLAY_CHARACTERS.test(normalized)
+        ? normalized
+        : undefined;
+}
+function textParts(message) {
+    return message.content.flatMap((part) => part.type === "text" ? [part.text] : []);
+}

package/dist/telemetry/skills/codex/file_reads.d.ts

@@ -0,0 +1,4 @@
+import type { InteractionOutput, InteractionRequest } from "../../../interaction/types.js";
+import type { SkillObservation } from "../observations.js";
+/** Match model-emitted Codex file reads to the exact current skill catalog. */
+export declare function codexAutomaticSkillObservations(request: InteractionRequest, output: InteractionOutput, limit: number): SkillObservation[];