var test = require("node:test");
var assert = require("node:assert/strict");
var fs = require("node:fs");
var path = require("node:path");
var attachHomeClayEntry = require("../lib/server-home-clay-entry").attachHomeClayEntry;
var attachHomeClaySessionLinks = require("../lib/server-home-clay-session-links").attachHomeClaySessionLinks;
var transformEvent = require("../lib/server-home-chat-events").transformEvent;
var createSDKBridge = require("../lib/sdk-bridge").createSDKBridge;

function fixture(modelError) {
  var sessions = new Map();
  var nextId = 1;
  var calls = { starts: [], histories: [], taps: [], lists: 0, errors: [], contextual: [] };
  var manager = {
    sessions: sessions,
    createSession: function (options) {
      var session = { sessionOriginId: 'origin-' + nextId, localId: nextId++, ownerId: options.ownerId, vendor: options.vendor, model: options.model, history: [], isProcessing: false };
      sessions.set(session.localId, session);
      return session;
    },
    sendAndRecord: function (session, event) { session.history.push(event); },
    saveSessionFile: function () {},
  };
  var found = { mate: { id: "clay-id", builtinKey: "clay" }, ctx: { getSessionManager: function () { return manager; }, sdk: { startQuery: function (session, text) { calls.starts.push({ session: session, text: text }); } } } };
  manager.createSessionRaw = function (options) { return manager.createSession(options); };
  var entry = attachHomeClayEntry({
    findMateProject: function (userId, mateId) { assert.equal(mateId, null); return found; },
    ownsSession: function (session, userId) { return session.ownerId === userId; },
    sessionReference: function (session) { return session.cliSessionId || "local:" + session.localId; },
    setupSearchTap: function (ws, selected, localId, requestId) { calls.taps.push({ localId: localId, requestId: requestId }); },
    sendHistory: function (ws, selected, session, requestId) { calls.histories.push({ session: session, requestId: requestId, processing: session.isProcessing }); },
    sendSessionList: function () { calls.lists++; },
    sendMessage: function (ws, message) { calls.contextual.push(message); },
    isActorLive: function () { return calls.live !== false; },
    sendError: function () { calls.errors.push(Array.prototype.slice.call(arguments)); },
    sendModelError: function (ws, selected, msg, error, sessionId) { calls.errors.push({ error: error.message, sessionId: sessionId }); },
    homeModels: { resolveMateModel: function () { if (calls.modelWait) return calls.modelWait; if (modelError) return Promise.reject(new Error("Choose a model")); return Promise.resolve({ vendor: "codex", model: "gpt-5.6-sol" }); } },
  });
  return { entry: entry, manager: manager, calls: calls, found: found };
}

test("global Ask Clay creates one exact owned session and records the visible user query before execution", async function () {
  var value = fixture(false);
  var ws = { readyState: 1 };
  await value.entry.start(ws, "user-1", { requestId: "request-1", text: "Find my conversation about fruit", mateId: "forged" });
  assert.equal(value.manager.sessions.size, 1);
  var session = Array.from(value.manager.sessions.values())[0];
  assert.equal(session.ownerId, "user-1");
  assert.equal(session.vendor, "codex");
  assert.equal(session.model, "gpt-5.6-sol");
  assert.equal(session.homeClayEntryMode, "search");
  assert.equal(session.homeClayEntryRequestId, "request-1");
  assert.deepEqual(session.history, [{ type: "user_message", text: "Find my conversation about fruit" }]);
  assert.equal(value.calls.histories[0].processing, true);
  assert.equal(value.calls.starts[0].session, session);
  assert.match(value.calls.starts[0].text, /global search[\s\S]*Search by meaning[\s\S]*User request:\nFind my conversation about fruit/);
  assert.match(value.calls.starts[0].text, /use search_workspace_history before any other investigation/);
  assert.match(value.calls.starts[0].text, /search_project_logs before answering/);
  assert.match(value.calls.starts[0].text, /Do not force a workspace or Logs search when the request is a general question or task/);
  assert.match(value.calls.starts[0].text, /at most three focused search passes/);
  assert.match(value.calls.starts[0].text, /Do not use Bash, filesystem scans, or generic agents/);
});

test("global Ask Clay is idempotent per owner and request while new requests create distinct chats", async function () {
  var value = fixture(false);
  var msg = { requestId: "request-1", text: "Find apples" };
  await value.entry.start({ readyState: 1 }, "user-1", msg);
  await value.entry.start({ readyState: 1 }, "user-1", msg);
  assert.equal(value.manager.sessions.size, 1);
  assert.equal(value.calls.starts.length, 1);
  await value.entry.start({ readyState: 1 }, "user-2", msg);
  assert.equal(value.manager.sessions.size, 2);
  assert.equal(value.calls.starts.length, 2);
  await value.entry.start({ readyState: 1 }, "user-1", { requestId: "request-2", text: "Find pears" });
  assert.equal(value.manager.sessions.size, 3);
  assert.equal(value.calls.starts.length, 3);
});

test("model failure does not strand an empty Ask Clay session", async function () {
  var value = fixture(true);
  await value.entry.start({ readyState: 1 }, "user-1", { requestId: "request-1", text: "Find fruit" });
  assert.equal(value.manager.sessions.size, 0);
  assert.equal(value.calls.starts.length, 0);
  assert.match(value.calls.errors[0].error, /Choose a model/);
});

test('contextual Ask creates one fresh exact session without a search tap, user message or execution', async function () {
  var value = fixture(false), message = { requestId: 'floating-1', text: 'A new question', presentation: 'contextual' };
  await Promise.all([value.entry.start({}, 'user-1', message), value.entry.start({}, 'user-1', message)]);
  assert.equal(value.manager.sessions.size, 1);
  assert.equal(value.calls.starts.length, 0); assert.equal(value.calls.taps.length, 0); assert.equal(value.calls.histories.length, 0);
  var session = Array.from(value.manager.sessions.values())[0];
  assert.deepEqual(session.history, []);
  assert.equal(session.homeClayEntryMode, 'contextual');
  assert.equal(value.calls.contextual.length, 2);
  assert.equal(value.calls.contextual[0].sessionId, session.localId);
  assert.deepEqual(value.calls.contextual[0], value.calls.contextual[1]);
  session.taskStopRequested = true;
  await value.entry.start({}, 'user-1', message);
  assert.equal(value.calls.starts.length, 0, 'Retry never replays execution after Stop');
  await value.entry.start({}, 'user-1', Object.assign({}, message, { requestId: 'floating-2' }));
  assert.equal(value.manager.sessions.size, 2);
  await value.entry.start({}, 'user-1', Object.assign({}, message, { text: 'Changed query' }));
  assert.equal(value.manager.sessions.size, 2); assert.equal(value.calls.errors.length, 1);
});

test('contextual Ask revalidates actor and exact live Mate across model resolution', async function () {
  for (var change of ['actor', 'identity', 'archived']) {
    var value = fixture(false), release;
    value.calls.modelWait = new Promise(function (resolve) { release = resolve; });
    var pending = value.entry.start({}, 'user-1', { requestId: 'late-' + change, text: 'A question', presentation: 'contextual' });
    if (change === 'actor') value.calls.live = false;
    else value.found.mate = Object.assign({}, value.found.mate, change === 'archived' ? { archived: true } : { id: 'replacement' });
    release({ vendor: 'codex', model: 'gpt-5.6-sol' }); await pending;
    assert.equal(value.manager.sessions.size, 0, change); assert.equal(value.calls.contextual.length, 0, change);
  }
});

test('contextual Ask retries reject replaced or deleted durable session identities', async function () {
  var value = fixture(false), msg = { requestId: 'origin-check', text: 'Retain exact session', presentation: 'contextual' };
  await value.entry.start({}, 'user-1', msg);
  var created = value.calls.contextual[0];
  await value.entry.start({}, 'user-1', Object.assign({}, msg, { sessionOriginId: 'foreign-origin' }));
  assert.equal(value.calls.contextual.length, 1);
  value.manager.sessions.delete(created.sessionId);
  await value.entry.start({}, 'user-1', Object.assign({}, msg, { sessionOriginId: created.sessionOriginId }));
  assert.equal(value.manager.sessions.size, 0, 'Deleted acknowledged sessions are not recreated by retry');
  assert.equal(value.calls.errors.length, 2);
});

test("rendered session links resolve through exact search and ordinary Home Mate sources", function () {
  var searchSource = { localId: 7, ownerId: "user-1" };
  var homeSource = { localId: 8, ownerId: "user-1" };
  var projects = new Map([
    ["mate-clay", { getSessionManager: function () { return { sessions: new Map([[7, searchSource]]) }; } }],
    ["mate-research", { getSessionManager: function () { return { sessions: new Map([[8, homeSource]]) }; } }],
  ]);
  var sent = [];
  var bindings = [];
  var links = attachHomeClaySessionLinks({
    projects: projects,
    workspaceQueryService: {
      bindProjectSession: function (binding) {
        bindings.push(binding);
        return { resolveSessionNavigation: function (args) { assert.equal(args.sessionRef, "session:AAAAAAAAAAAAAAAAAAAAAAAA"); var target = { projectSlug: "owned", sessionId: 11, isMate: false }; if (args.entryIndex !== undefined) target.entryIndex = args.entryIndex; return target; } };
      },
    },
    sendMessage: function (ws, payload) { sent.push(payload); },
  });
  var ws = { _searchClayTap: { mateSlug: "mate-clay", sessionId: 7 }, _clayUser: { id: "user-1" } };
  links.resolve(ws, { surface: "search", requestId: "link-1", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA" });
  assert.equal(sent[0].status, "ready");
  assert.deepEqual(sent[0].target, { projectSlug: "owned", sessionId: 11, isMate: false });
  links.resolve(ws, { surface: "search", requestId: "link-anchored", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA", entryIndex: 16466 });
  assert.equal(sent[1].target.entryIndex, 16466);
  var homeWs = { _homeChatTap: { mateSlug: "mate-research", sessionId: 8 }, _clayUser: { id: "user-1" } };
  links.resolve(homeWs, { surface: "home", requestId: "link-2", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA" });
  assert.equal(sent[2].status, "ready");
  assert.deepEqual(bindings, [
    { projectSlug: "mate-clay", session: searchSource, viewerId: "user-1" },
    { projectSlug: "mate-clay", session: searchSource, viewerId: "user-1" },
    { projectSlug: "mate-research", session: homeSource, viewerId: "user-1" },
  ]);
  links.resolve({}, { surface: "home", requestId: "link-3", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA" });
  assert.equal(sent[3].status, "error");
  assert.match(sent[3].error, /source conversation/);
});

test("ordinary project transcript references resolve through the routed authorized project session", function () {
  var sourceSession = { localId: 19, ownerId: "user-1" };
  var project = { getSessionManager: function () { return { sessions: new Map([[19, sourceSession]]) }; } };
  var sent = [];
  var binding = null;
  var links = attachHomeClaySessionLinks({
    projects: new Map([["ordinary", project]]),
    workspaceQueryService: {
      bindProjectSession: function (value) {
        binding = value;
        if (value.viewerId && value.viewerId !== value.session.ownerId) return null;
        return { resolveSessionNavigation: function (args) { return { projectSlug: "ordinary", sessionId: 19, entryIndex: args.entryIndex }; } };
      },
    },
    sendMessage: function (ws, payload) { sent.push(payload); },
  });
  links.resolve({ _clayActiveSession: 19, _clayUser: { id: "user-1" } }, { surface: "home", requestId: "ordinary-link", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA", entryIndex: 16466 }, "ordinary");
  assert.deepEqual(binding, { projectSlug: "ordinary", session: sourceSession, viewerId: "user-1" });
  assert.equal(sent[0].status, "ready");
  assert.equal(sent[0].target.entryIndex, 16466);
  links.resolve({ _clayActiveSession: 19, _clayUser: { id: "user-2" } }, { surface: "home", requestId: "ordinary-denied", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA", entryIndex: 16466 }, "ordinary");
  assert.equal(sent[1].status, "error");
});

test("authenticated links return a correlated error when the source session was deleted", function () {
  var sent = [];
  var bindingCalls = 0;
  var links = attachHomeClaySessionLinks({
    projects: new Map([["ordinary", { getSessionManager: function () { return { sessions: new Map() }; } }]]),
    workspaceQueryService: {
      bindProjectSession: function () { bindingCalls++; return null; },
    },
    sendMessage: function (ws, payload) { sent.push(payload); },
  });
  links.resolve({ _clayActiveSession: 19, _clayUser: { id: "user-1" } }, { surface: "home", requestId: "deleted-source", sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA" }, "ordinary");
  assert.equal(bindingCalls, 0);
  assert.deepEqual(sent[0], {
    type: "home_clay_session_target",
    requestId: "deleted-source",
    sessionRef: "session:AAAAAAAAAAAAAAAAAAAAAAAA",
    status: "error",
    error: "The source conversation is no longer available.",
  });
});

test("rendered Project Log links resolve through the exact authoritative Clay source", function () {
  var sourceSession = { localId: 7, ownerId: "user-1" };
  var sourceStatus = { slug: "mate-clay", projectOwnerId: "user-1", isMate: true, mateId: "clay-id" };
  var sourceProject = {
    getStatus: function () { return sourceStatus; },
    getSessionManager: function () { return { sessions: new Map([[7, sourceSession]]) }; },
  };
  var sent = [];
  var binding = null;
  var links = attachHomeClaySessionLinks({
    projects: new Map([["mate-clay", sourceProject]]),
    projectLogsService: {
      bindMate: function (value) {
        binding = value;
        return { resolveLogNavigation: function (args) {
          assert.deepEqual(args, { ref: "log:AAAAAAAAAAAAAAAAAAAAAAAA" });
          return { projectSlug: "owned", ref: args.ref };
        } };
      },
    },
    sendMessage: function (ws, payload) { sent.push(payload); },
  });
  var ws = { _searchClayTap: { mateSlug: "mate-clay", mateId: "clay-id", sessionId: 7 } };
  links.resolveLog(ws, { surface: "search", requestId: "log-link-1", ref: "log:AAAAAAAAAAAAAAAAAAAAAAAA" });
  assert.deepEqual(binding, {
    projectSlug: "mate-clay", projectOwnerId: "user-1", isMate: true, mateId: "clay-id", session: sourceSession,
  });
  assert.equal(sent[0].status, "ready");
  assert.deepEqual(sent[0].target, { projectSlug: "owned", ref: "log:AAAAAAAAAAAAAAAAAAAAAAAA" });

  links.resolveLog({}, { surface: "home", requestId: "log-link-2", ref: "log:AAAAAAAAAAAAAAAAAAAAAAAA" });
  assert.equal(sent[1].status, "error");
  assert.match(sent[1].error, /source conversation/);
});

test("Project Log reference parsing accepts exact refs and rejects lookalikes", function () {
  var sourceText = fs.readFileSync(path.join(__dirname, "../lib/public/modules/clay-log-links.js"), "utf8");
  var start = sourceText.indexOf("export function parseClayLogReferences(text)");
  var end = sourceText.indexOf("\n\nexport function isExactClayLogReference", start);
  var parseClayLogReferences = Function(sourceText.slice(start, end).replace("export ", "") + "\nreturn parseClayLogReferences;")();
  var explicit = parseClayLogReferences("See [clayos/log:AAAAAAAAAAAAAAAAAAAAAAAA — Release decision].");
  assert.deepEqual(explicit.map(function (item) { return { ref: item.ref, label: item.label }; }), [
    { ref: "log:AAAAAAAAAAAAAAAAAAAAAAAA", label: "Release decision" },
  ]);
  var bare = parseClayLogReferences("Open log:BBBBBBBBBBBBBBBBBBBBBBBB now.");
  assert.equal(bare.length, 1);
  assert.equal(bare[0].ref, "log:BBBBBBBBBBBBBBBBBBBBBBBB");
  assert.equal(parseClayLogReferences("log:CCCCCCCCCCCCCCCCCCCCCCCCC").length, 0, "a 25-character lookalike is rejected");
  assert.equal(parseClayLogReferences("prefixlog:DDDDDDDDDDDDDDDDDDDDDDDD").length, 0, "an embedded identifier is rejected");
  assert.equal(parseClayLogReferences("https://example.test/log:EEEEEEEEEEEEEEEEEEEEEEEE").length, 0, "a URL path is not converted");

  var exactStart = sourceText.indexOf("export function isExactClayLogReference(text)");
  var exactEnd = sourceText.indexOf("\n\nfunction createLogLink", exactStart);
  var isExactClayLogReference = Function(sourceText.slice(exactStart, exactEnd).replace("export ", "") + "\nreturn isExactClayLogReference;")();
  assert.equal(isExactClayLogReference("log:FFFFFFFFFFFFFFFFFFFFFFFF"), true);
  assert.equal(isExactClayLogReference("prefix log:FFFFFFFFFFFFFFFFFFFFFFFF"), false);
});

test("session reference anchors accept exact entry indexes and reject lookalikes", function () {
  var source = fs.readFileSync(path.join(__dirname, "../lib/public/modules/clay-log-links.js"), "utf8");
  var start = source.indexOf("export function parseClaySessionReference(text)");
  var end = source.indexOf("\n\nexport function parseClayLogReferences", start);
  var parseClaySessionReference = Function(source.slice(start, end).replace(/export /g, "") + "\nreturn parseClaySessionReference;")();
  assert.deepEqual(parseClaySessionReference("session:AAAAAAAAAAAAAAAAAAAAAAAA#entry-16466"), { ref: "session:AAAAAAAAAAAAAAAAAAAAAAAA", entryIndex: 16466 });
  assert.deepEqual(parseClaySessionReference("session:AAAAAAAAAAAAAAAAAAAAAAAA"), { ref: "session:AAAAAAAAAAAAAAAAAAAAAAAA", entryIndex: null });
  assert.equal(parseClaySessionReference("session:AAAAAAAAAAAAAAAAAAAAAAAA#entry-1.5"), null);
  assert.equal(parseClaySessionReference("session:AAAAAAAAAAAAAAAAAAAAAAAA#entry-16466x"), null);
  assert.equal(parseClaySessionReference("session:AAAAAAAAAAAAAAAAAAAAAAA#entry-16466"), null);
});

test("Ask Clay projects changing sanitized search stages without leaking tool details", function () {
  var session = { homeClayEntryMode: "search", model: "gpt-5.6-sol", vendor: "codex" };
  var thinking = transformEvent({ type: "thinking_start" }, "clay-id", session, "request-1", "session-1");
  var thought = transformEvent({ type: "thinking_stop", duration: 1.25 }, "clay-id", session, "request-1", "session-1");
  var searching = transformEvent({ type: "tool_start", name: "search_workspace_history" }, "clay-id", session, "request-1", "session-1");
  var specific = transformEvent({ type: "tool_executing", name: "search_workspace_history", input: { query: "fruit\u0000 notes" } }, "clay-id", session, "request-1", "session-1");
  var reviewing = transformEvent({ type: "tool_result", content: "private transcript" }, "clay-id", session, "request-1", "session-1");
  transformEvent({ type: "tool_start", name: "search_project_logs" }, "clay-id", session, "request-1", "session-1");
  var logSearch = transformEvent({ type: "tool_executing", name: "search_project_logs", input: { query: "release status" } }, "clay-id", session, "request-1", "session-1");
  assert.deepEqual([thinking.phase, searching.phase, reviewing.phase], ["thinking", "searching", "reviewing"]);
  assert.deepEqual([thinking.status, thought.status, searching.status, reviewing.status], ["active", "done", "active", "done"]);
  assert.equal(thought.label, "Thought through the request in 1.3s");
  assert.equal(specific.label, "Searching conversations for \u201cfruit notes\u201d");
  assert.equal(logSearch.label, "Searching project logs for \u201crelease status\u201d");
  assert.equal(specific.activityId, searching.activityId);
  assert.equal(searching.step, 1);
  assert.equal(reviewing.step, 1);
  assert.equal(Object.prototype.hasOwnProperty.call(searching, "name"), false);
  assert.equal(Object.prototype.hasOwnProperty.call(searching, "input"), false);
  assert.equal(Object.prototype.hasOwnProperty.call(reviewing, "content"), false);
  assert.equal(transformEvent({ type: "result" }, "clay-id", session, "request-1", "session-1").type, "home_mate_done");
  assert.equal(transformEvent({ type: "done" }, "clay-id", session, "request-1", "session-1"), null);
});

test("Ask Clay uses the canonical exact read-only allowlist without admitting mutations", function () {
  var bridge = createSDKBridge({ cwd: process.cwd(), sessionManager: {}, adapter: { vendor: "claude" }, send: function () {} });
  assert.equal(bridge.checkToolWhitelist("Read", { file_path: "/repo/a.js" }).behavior, "allow");
  assert.equal(bridge.checkToolWhitelist("Grep", { pattern: "needle" }).behavior, "allow");
  assert.equal(bridge.checkToolWhitelist("mcp__clay-workspace__read_project_session", {}).behavior, "allow");
  assert.equal(bridge.checkToolWhitelist("Edit", { file_path: "/repo/a.js" }), null);
  assert.equal(bridge.checkToolWhitelist("Bash", { command: "rm a.js" }), null);
});

test("global search is deterministic first and exposes an explicit branded Clay chat handoff", function () {
  var root = path.join(__dirname, "..");
  var palette = fs.readFileSync(path.join(root, "lib/public/modules/command-palette.js"), "utf8");
  var widget = fs.readFileSync(path.join(root, "lib/public/modules/search-clay-chat.js"), "utf8");
  var styles = fs.readFileSync(path.join(root, "lib/public/css/command-palette.css"), "utf8");
  var styleImports = fs.readFileSync(path.join(root, "lib/public/style.css"), "utf8");
  var markup = fs.readFileSync(path.join(root, "lib/public/index.html"), "utf8");
  var project = fs.readFileSync(path.join(root, "lib/project.js"), "utf8");
  var schema = fs.readFileSync(path.join(root, "lib/ws-schema.js"), "utf8");
  var markdown = fs.readFileSync(path.join(root, "lib/public/modules/markdown.js"), "utf8");
  var logLinks = fs.readFileSync(path.join(root, "lib/public/modules/clay-log-links.js"), "utf8");
  var projectLogs = fs.readFileSync(path.join(root, "lib/public/modules/project-logs.js"), "utf8");
  var router = fs.readFileSync(path.join(root, "lib/public/modules/app-message-router.js"), "utf8");
  var sessionLinks = fs.readFileSync(path.join(root, "lib/server-home-clay-session-links.js"), "utf8");
  assert.match(widget, /startContextualSearch\(query\)/);
  assert.doesNotMatch(widget, /createElement|Workspace search|home_mate_send/);
  assert.match(palette, /if \(startSearchClayChat\(query\)\) closeCommandPalette\(\)/);
  assert.match(markup, /cmd-palette-searchbar[\s\S]*data-lucide="search"[\s\S]*Search or ask Clay/);
  assert.doesNotMatch(markup, /cmd-palette-searchbar-brand/);
  assert.match(markup, /class="icon-strip-home icon-strip-brand" aria-label="Open Clay" disabled[\s\S]*clay-studio-symbol\.png/);
  assert.doesNotMatch(markup, /id="home-hub"/);
  assert.match(palette, /fetch\("\/api\/palette\/search\?q=" \+ encodeURIComponent\(query\)/);
  assert.match(palette, /type: "ask-clay"/);
  assert.match(palette, /No exact matches\. Clay can search by meaning\./);
  assert.doesNotMatch(palette, /if \(chatMode && attachSearchClayChat/);
  assert.doesNotMatch(palette, /New Mate|group-label">Mates|group-label">Commands|group-label">Users/);
  assert.doesNotMatch(palette, /group-label">Projects|type: "project"/);
  assert.match(fs.readFileSync(path.join(root, "lib/public/modules/chat-bubble-renderer.js"), "utf8"), /renderAssistantBubbleText[\s\S]*enhanceClaySessionLinks\(content\)/);
  assert.match(styles, /\.search-clay-activity-panel\.is-collapsed \.search-clay-activity-list \{ height: 42px; justify-content: flex-start/);
  assert.match(styles, /\.search-clay-activity-item:nth-last-child\(-n \+ 2\)/);
  assert.match(styles, /\.is-collapsed \.search-clay-activity-item > span \{ flex-direction: row/);
  assert.match(styles, /\.search-clay-activity-panel\.is-expanded \.search-clay-activity-list \{ max-height: 220px/);
  assert.match(styles, /\.search-clay-transcript \.search-clay-message-user[\s\S]*align-items: flex-end/);
  assert.match(styles, /body\.wide-view \.search-clay-transcript \.search-clay-message-user \.bubble[\s\S]*background: var\(--user-bubble\)/);
  assert.match(styles, /body\.mate-dm-active \.search-clay-transcript \.search-clay-message-user \.bubble/);
  assert.match(styles, /\.md-content:not\(:empty\) \+ \.search-clay-activity-panel/);
  assert.match(styles, /\.search-clay-transcript[\s\S]*padding: 16px 12px/);
  assert.match(markup, /style\.css\?v=20260913-scheduled-tasks4/);
  assert.match(palette, /class="cmd-palette-brand">Clay Studio/);
  assert.doesNotMatch(palette, /class="cmd-palette-brand"><img/);
  assert.match(styles, /\.cmd-palette\.is-chatting \.cmd-palette-footer-shortcuts \{ display: none; \}/);
  assert.match(styleImports, /@import url\(\"css\/command-palette\.css\?v=[^\"]+\"\);/, 'the palette stylesheet import carries a non-empty cache-busting version');
  assert.match(markup, /app\.js\?v=20260913-scheduled-tasks4/);
  assert.match(markdown, /replace\(\/\\\*\\\*\[ \\t\]\+/);
  assert.match(markdown, /function normalizeAdjacentEmphasis\(text\)/);
  assert.match(markdown, /\\p\{L\}\\p\{N\}/);
  assert.match(markdown, /\$1\$2\$1<wbr>/);
  assert.match(markdown, /```\[\\s\\S\]\*\?```/);
  var normalizeStart = markdown.indexOf("function normalizeAdjacentEmphasis(text)");
  var normalizeEnd = markdown.indexOf("\n\nexport function renderMarkdown", normalizeStart);
  var normalizeAdjacentEmphasis = Function(markdown.slice(normalizeStart, normalizeEnd) + "\nreturn normalizeAdjacentEmphasis;")();
  var markedParser = require("marked").marked;
  var adjacent = '**"내가 맞다고 느낄 때 무엇을 놓치고 있나?"**에 가까워 보여.';
  var renderedAdjacent = markedParser.parse(normalizeAdjacentEmphasis(adjacent));
  assert.match(renderedAdjacent, /<strong>&quot;내가 맞다고 느낄 때 무엇을 놓치고 있나\?&quot;<\/strong><wbr>에/);
  assert.equal(normalizeAdjacentEmphasis('`**code**suffix`'), '`**code**suffix`');
  assert.match(markdown, /function enhanceClaySessionLinks\(root\)/);
  assert.match(markdown, /enhanceSessionCitations\(root\)/);
  assert.match(palette, /request\.type = "home_clay_session_resolve"/);
  assert.match(palette, /function handleClaySessionLinkClick\(event\)/);
  assert.match(palette, /addEventListener\("click", handleClaySessionLinkClick, true\)/);
  assert.match(palette, /navigateToSession\(\{ projectSlug: msg\.target\.projectSlug, sessionId: msg\.target\.sessionId \}, null, msg\.target\.entryIndex\)/);
  assert.match(palette, /if \(alreadyActive\) \{[\s\S]*if \(query\) setTimeout\(function \(\) \{ openSessionSearch\(query\); \}, 400\);/);
  assert.match(router, /handleClaySessionTarget\(msg\)/);
  assert.match(sessionLinks, /var binding = selected\.session \? \{ projectSlug: selected\.tap\.mateSlug, session: selected\.session \} : null/);
  assert.match(sessionLinks, /binding\.viewerId = ws\._clayUser\.id/);
  assert.match(sessionLinks, /bindProjectSession\(binding\)/);
  assert.match(sessionLinks, /resolveSessionNavigation\(\{ sessionRef: msg\.sessionRef, entryIndex: msg\.entryIndex \}\)/);
  assert.match(schema, /"home_clay_session_resolve"[\s\S]*"home_clay_session_target"/);
  assert.match(markdown, /enhanceClayLogLinks\(root\)/);
  assert.match(logLinks, /clayos\\\/\(log:\[A-Za-z0-9_-\]\{24\}\)/);
  assert.match(logLinks, /className = "clayos-log-link"/);
  assert.match(logLinks, /closest\("code, pre, a, button"\)/);
  assert.match(logLinks, /querySelectorAll\("code"\)/);
  assert.match(logLinks, /code\.closest\("pre"\)/);
  assert.match(logLinks, /contentEditable = "false"/);
  assert.match(palette, /request\.type = "home_clay_log_resolve"/);
  assert.match(palette, /msg\.type !== "home_clay_log_target"/);
  assert.match(palette, /openProjectLog\(target\.ref\)/);
  assert.match(projectLogs, /export function openProjectLog\(ref\)/);
  assert.match(sessionLinks, /bindMate\([\s\S]*resolveLogNavigation\(\{ ref: msg\.ref \}\)/);
  assert.match(schema, /"home_clay_log_resolve"[\s\S]*"home_clay_log_target"/);
  assert.match(project, /msg\.type === "home_clay_ask"[\s\S]*opts\.onDmMessage\(ws, msg, slug\)/);
  assert.match(schema, /"home_clay_ask"[\s\S]*direction: "c2s"/);
});