threadId: thread.threadId,

...(turnId ? { turnId } : {}),

});

embeddedAgentLog.debug("codex app-server raw notification received", correlation);

embeddedAgentLog.trace("codex app-server raw notification received", correlation);

if (notification.method === "turn/completed" && correlation.matchesActiveTurn === false) {

if (correlation.matchesActiveThread) {

embeddedAgentLog.warn(

skillsLogger.debug(message, meta);

}

function traceSkillCommandOnce(

messageKey: string,

message: string,

meta?: Record<string, unknown>,

) {

if (skillCommandDebugOnce.has(messageKey)) {

return;

}

skillCommandDebugOnce.add(messageKey);

skillsLogger.trace(message, meta);

}

function sanitizeSkillCommandName(raw: string): string {

const normalized = normalizeLowercaseStringOrEmpty(raw)

.replace(/[^a-z0-9_]+/g, "_")

const rawName = entry.skill.name;

const base = sanitizeSkillCommandName(rawName);

if (base !== rawName) {

debugSkillCommandOnce(

traceSkillCommandOnce(

`sanitize:${rawName}:${base}`,

`Sanitized skill command name "${rawName}" to "/${base}".`,

{ rawName, sanitized: `/${base}` },

);

}

const unique = resolveUniqueSkillCommandName(base, used);

if (unique !== base) {

debugSkillCommandOnce(

traceSkillCommandOnce(

`dedupe:${rawName}:${unique}`,

`De-duplicated skill command name for "${rawName}" to "/${unique}".`,

{ rawName, deduped: `/${unique}` },

writeSpy.mockRestore();

});

it("caches unchanged session stores from persisted JSON shape", async () => {

const key = "agent:main:no-op-cache";

const { storePath } = await makeTmpStore({

[key]: { sessionId: "s-noop-cache", updatedAt: Date.now() },

});

await updateSessionStore(

storePath,

async (store) => {

(store[key] as Record<string, unknown>).ephemeral = undefined;

},

{ skipMaintenance: true },

);

expect(loadSessionStore(storePath)[key]).not.toHaveProperty("ephemeral");

});

it("keeps session store writes atomic while skipping durable fsync inside the writer lock", async () => {

const key = "agent:main:no-fsync";

const { storePath } = await makeTmpStore({

takeOwnership?: boolean;

}): void {

const store =

params.takeOwnership === true ? params.store : cloneSessionStoreRecord(params.store);

params.takeOwnership === true

? params.store

: cloneSessionStoreRecord(params.store, params.serialized);

if (params.takeOwnership === true) {

internSessionStoreLargeStrings(store);

}

String.raw`\bbot(\d{6,}:[A-Za-z0-9_-]{20,})\b`,

String.raw`\b(\d{6,}:[A-Za-z0-9_-]{20,})\b`,

];

let defaultResolvedPatterns: RegExp[] | undefined;

export type RedactOptions = {

mode?: RedactSensitiveMode;

}

function resolvePatterns(value?: RedactPattern[]): RegExp[] {

const source = value?.length ? value : DEFAULT_REDACT_PATTERNS;

return source.map(parsePattern).filter((re): re is RegExp => Boolean(re));

if (!value?.length) {

defaultResolvedPatterns ??= DEFAULT_REDACT_PATTERNS.map(parsePattern).filter(

(re): re is RegExp => Boolean(re),

);

return defaultResolvedPatterns;

}

return value.map(parsePattern).filter((re): re is RegExp => Boolean(re));

}

function maskToken(token: string): string {