@aexol/opencode-wizard 0.3.3 → 0.3.4

package/dist/server.js

@@ -1,2614 +1,7 @@
-import fs from 'node:fs/promises';
-import http from 'node:http';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { URL, fileURLToPath } from 'node:url';
-import { resolveBackendOriginFromValues } from './config.js';
-import { sendOAuthCallbackHtmlResponse } from './oauth-callback-page.js';
-import { deleteFileIfExists, readJsonFile, writePrivateJsonFile } from './storage.js';
-const execFileAsync = promisify(execFile);
-const MODULE_FILE_PATH = fileURLToPath(import.meta.url);
-const PACKAGE_ROOT_PATH = path.resolve(path.dirname(MODULE_FILE_PATH), '..');
-export const PLUGIN_ID = 'opencode-wizard';
-const CACHE_TTL_MS = 30_000;
-const WORKSPACE_MAPPING_LIMIT = 100;
-const ROOT_SKILL_SEED_PATH = '.opencode/skills';
-const GLOBAL_CONFIG_PATH = path.join(os.homedir(), '.config', 'opencode', 'opencode-wizard.json');
-const LEGACY_AUTH_STATE_PATH = 'plugin/opencode-wizard/.generated/auth-state.json';
-const OIDC_ISSUER = 'https://login.microsoftonline.com/86f4caf4-0d6f-4682-9a06-ea57f3e4e76c/v2.0';
-const OIDC_CLIENT_ID = 'da963901-2375-442b-9e99-14e59f43eda2';
-const OIDC_CALLBACK_ORIGIN = 'http://localhost:24953';
-const OIDC_CALLBACK_PATH = '/oauth/callback';
-const OIDC_CALLBACK_URL = `${OIDC_CALLBACK_ORIGIN}${OIDC_CALLBACK_PATH}`;
-const OIDC_SCOPES = ['openid', 'profile', 'email'];
-const LOGIN_TIMEOUT_MS = 5 * 60_000;
-const SYSTEM_NOTE_SKILL_NAME_LIMIT = 10;
-const SYSTEM_NOTE_DETAIL_LIMIT = 3;
-const SYSTEM_NOTE_DETAIL_CHAR_LIMIT = 2_400;
-const SYSTEM_NOTE_SKILL_DESCRIPTION_LIMIT = 140;
-const PRESENCE_EVENT_TIMEOUT_MS = 3_000;
-const PRESENCE_EVENT_MAX_ATTEMPTS = 2;
-const PRESENCE_EVENT_RETRY_DELAY_MS = 250;
-const PRESENCE_SHUTDOWN_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
-const PRESENCE_SIGNAL_EXIT_CODES = {
-  SIGINT: 130,
-  SIGTERM: 143,
-  SIGHUP: 129
-};
-const createIdleLoginBootstrapSnapshot = () => ({
-  status: 'idle',
-  trigger: null,
-  startedAt: null,
-  expiresAt: null,
-  browserUrl: null,
-  browserOpenError: null,
-  email: null,
-  message: null
-});
-const STATUS_PATH_LOGIN_RETRY_COOLDOWN_MS = 60_000;
-const statusPathLoginBootstrap = {
-  promise: null,
-  status: 'idle',
-  message: null,
-  failedAt: null
-};
-const importOpencodePluginModule = new Function('specifier', 'return import(specifier)');
-export const AVAILABLE_PUBLISHED_SKILL_TOOLS = ['opencode_wizard_published_skills_fetch', 'opencode_wizard_published_skill_preference_set', 'opencode_wizard_status'];
-let publishedSkillPreferenceCacheVersion = 0;
-export const NATIVE_SKILLS_URL_COMPATIBILITY = {
-  configKey: 'skills.urls',
-  deliveryMode: 'public_static_registry',
-  wizardPrivateDelivery: 'authenticated_scoped_fetch_tool',
-  authSupport: 'none',
-  guidance: 'OpenCode skills.urls is for public/static registries and complements opencode-wizard; private workspace-scoped skills stay available through the authenticated fetch tool only.'
-};
-const PUBLISHED_SKILLS_CATALOG_QUERY = `
-  query PluginPublishedSkills($input: PublishedSkillsDeliveryInput!) {
-    pluginPublishedSkills(input: $input) {
-      workspace {
-        id
-        slug
-        name
-        repositoryUrl
-        defaultBranch
-        status
-      }
-      directoryPath
-      skills {
-        assignmentSource
-        assignmentType
-        scopePath
-        includeChildren
-        skill {
-          id
-          slug
-          name
-          summary
-          whenToUse
-          status
-          installPolicy
-          tags {
-            id
-            slug
-            label
-            description
-            facet {
-              id
-              slug
-              label
-              description
-            }
-          }
-        }
-        skillVersion {
-          id
-          version
-          title
-          summary
-          status
-        }
-        publishedArtifact {
-          id
-          frontmatterName
-          frontmatterDescription
-          checksum
-          publishedAt
-          fileCount
-        }
-      }
-      catalogSkills {
-        skill {
-          id
-          slug
-          name
-          summary
-          whenToUse
-          status
-          installPolicy
-          tags {
-            id
-            slug
-            label
-            description
-            facet {
-              id
-              slug
-              label
-              description
-            }
-          }
-        }
-        skillVersion {
-          id
-          version
-          title
-          summary
-          status
-        }
-        publishedArtifact {
-          id
-          frontmatterName
-          frontmatterDescription
-          checksum
-          publishedAt
-          fileCount
-        }
-      }
-      userPreferences {
-        scopeKey
-        userKey
-        ignoredSkills {
-          assignmentSource
-          assignmentType
-          scopePath
-          includeChildren
-          skill {
-            id
-            slug
-            name
-            summary
-            whenToUse
-            status
-            installPolicy
-            tags {
-              id
-              slug
-              label
-              description
-              facet {
-                id
-                slug
-                label
-                description
-              }
-            }
-          }
-          skillVersion {
-            id
-            version
-            title
-            summary
-            status
-          }
-          publishedArtifact {
-            id
-            frontmatterName
-            frontmatterDescription
-            checksum
-            publishedAt
-            fileCount
-          }
-        }
-      }
-    }
-  }
-`;
-const SET_PUBLISHED_SKILL_PREFERENCE_MUTATION = `
-  mutation SetPublishedSkillPreference($input: SetPublishedSkillPreferenceInput!) {
-    setPublishedSkillPreference(input: $input) {
-      scopeKey
-      userKey
-      ignoredSkills {
-        assignmentSource
-        assignmentType
-        scopePath
-        includeChildren
-        skill {
-          id
-          slug
-          name
-          summary
-          whenToUse
-          status
-          installPolicy
-          tags {
-            id
-            slug
-            label
-            description
-            facet {
-              id
-              slug
-              label
-              description
-            }
-          }
-        }
-        skillVersion {
-          id
-          version
-          title
-          summary
-          status
-        }
-        publishedArtifact {
-          id
-          frontmatterName
-          frontmatterDescription
-          checksum
-          publishedAt
-          fileCount
-        }
-      }
-    }
-  }
-`;
-const PUBLISHED_SKILL_DETAIL_QUERY = `
-  query PluginPublishedSkillVersionArtifact($input: PublishedSkillArtifactDetailInput!) {
-    pluginPublishedSkillVersionArtifact(input: $input) {
-      id
-      frontmatterName
-      frontmatterDescription
-      markdownBody
-      renderedContent
-      checksum
-      publishedAt
-      fileCount
-      files {
-        id
-        relativePath
-        contentType
-        content
-        checksum
-        size
-        sortOrder
-      }
-    }
-  }
-`;
-const parseDotEnvValue = value => {
-  const trimmedValue = value.trim();
-  if (trimmedValue.startsWith('"') && trimmedValue.endsWith('"') || trimmedValue.startsWith("'") && trimmedValue.endsWith("'")) {
-    return trimmedValue.slice(1, -1);
-  }
-  return trimmedValue;
-};
-const parseDotEnv = raw => {
-  const values = new Map();
-  for (const line of raw.split(/\r?\n/u)) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine || trimmedLine.startsWith('#')) continue;
-    const separatorIndex = trimmedLine.indexOf('=');
-    if (separatorIndex <= 0) continue;
-    const key = trimmedLine.slice(0, separatorIndex).trim();
-    if (!key) continue;
-    const rawValue = trimmedLine.slice(separatorIndex + 1);
-    values.set(key, parseDotEnvValue(rawValue));
-  }
-  return values;
-};
-const findUpwardFile = async (startDirectory, fileName) => {
-  let currentDirectory = normalizeAbsolutePath(startDirectory);
-  while (true) {
-    const candidatePath = path.join(currentDirectory, fileName);
-    try {
-      await fs.access(candidatePath);
-      return candidatePath;
-    } catch {
-      const parentDirectory = path.dirname(currentDirectory);
-      if (parentDirectory === currentDirectory) return null;
-      currentDirectory = parentDirectory;
-    }
-  }
-};
-const readLocalEnvValues = async startDirectory => {
-  const envPath = await findUpwardFile(startDirectory, '.env');
-  if (!envPath) return new Map();
-  try {
-    const raw = await fs.readFile(envPath, 'utf8');
-    return parseDotEnv(raw);
-  } catch {
-    return new Map();
-  }
-};
-const resolveBackendOrigin = async worktree => {
-  const envValues = await readLocalEnvValues(worktree);
-  return resolveBackendOriginFromValues({
-    environmentBackendOrigin: process.env.OPENCODE_WIZARD_BACKEND_ORIGIN,
-    localBackendOrigin: envValues.get('OPENCODE_WIZARD_BACKEND_ORIGIN')
-  });
-};
-const readConfiguredWorkspaceSlug = () => {
-  const configuredWorkspaceSlug = process.env.OPENCODE_WIZARD_SKILLS_WORKSPACE_SLUG?.trim();
-  if (!configuredWorkspaceSlug) return null;
-  return toWorkspaceSlug(configuredWorkspaceSlug);
-};
-const toWorkspaceSlug = value => {
-  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9-]+/gu, '-').replace(/^-+|-+$/gu, '');
-  if (normalized) return normalized;
-  return 'workspace';
-};
-const resolveFallbackWorkspaceSlug = worktree => {
-  const configuredWorkspaceSlug = readConfiguredWorkspaceSlug();
-  if (configuredWorkspaceSlug) return configuredWorkspaceSlug;
-  return toWorkspaceSlug(path.basename(path.resolve(worktree)));
-};
-export const resolveConfig = async worktree => {
-  const backendOrigin = await resolveBackendOrigin(worktree);
-  return {
-    backendOrigin,
-    graphqlUrl: `${backendOrigin}/graphql`,
-    authSessionUrl: `${backendOrigin}/api/opencode-plugin/oauth/session`,
-    presenceUrl: `${backendOrigin}/api/opencode-plugin/presence`,
-    actionsUrl: `${backendOrigin}/api/opencode-plugin/actions`,
-    configuredWorkspaceSlug: readConfiguredWorkspaceSlug(),
-    fallbackWorkspaceSlug: resolveFallbackWorkspaceSlug(worktree),
-    rootSkillSeedPath: ROOT_SKILL_SEED_PATH,
-    authStatePath: GLOBAL_CONFIG_PATH
-  };
-};
-const normalizeAbsolutePath = value => path.resolve(value);
-const normalizeRepositoryPath = (worktree, directory) => {
-  const absoluteWorktree = normalizeAbsolutePath(worktree);
-  const absoluteDirectory = normalizeAbsolutePath(directory);
-  const relativePath = path.relative(absoluteWorktree, absoluteDirectory);
-  if (!relativePath || relativePath === '') return '.';
-  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) return '.';
-  return relativePath.split(path.sep).join('/');
-};
-const tryExecGit = async args => {
-  try {
-    const {
-      stdout
-    } = await execFileAsync('git', args, {
-      encoding: 'utf8'
-    });
-    const normalizedOutput = stdout.trim();
-    if (normalizedOutput) return normalizedOutput;
-    return null;
-  } catch {
-    return null;
-  }
-};
-const resolveGitRoot = async directory => {
-  const gitRoot = await tryExecGit(['-C', directory, 'rev-parse', '--show-toplevel']);
-  if (!gitRoot) return null;
-  return normalizeAbsolutePath(gitRoot);
-};
-const normalizeGitRemoteUrl = remoteUrl => {
-  if (!remoteUrl) return null;
-  const trimmedRemoteUrl = remoteUrl.trim();
-  if (!trimmedRemoteUrl) return null;
-  const scpLikeMatch = /^git@([^:]+):(.+)$/u.exec(trimmedRemoteUrl);
-  if (scpLikeMatch) {
-    return `ssh://git@${scpLikeMatch[1]}/${scpLikeMatch[2].replace(/^\/+/, '')}`;
-  }
-  try {
-    const parsedUrl = new URL(trimmedRemoteUrl);
-    return parsedUrl.toString().replace(/\/+$/u, '');
-  } catch {
-    return null;
-  }
-};
-const resolveGitRemoteOriginUrl = async repositoryRoot => {
-  const remoteUrl = await tryExecGit(['-C', repositoryRoot, 'remote', 'get-url', 'origin']);
-  return normalizeGitRemoteUrl(remoteUrl);
-};
-const resolveWorkspace = async ({
-  config,
-  directory
-}) => {
-  const requestedDirectory = normalizeAbsolutePath(directory);
-  const gitRoot = await resolveGitRoot(requestedDirectory);
-  const repositoryRoot = gitRoot ?? requestedDirectory;
-  const repositoryUrl = gitRoot ? await resolveGitRemoteOriginUrl(gitRoot) : null;
-  const learnedWorkspaceMapping = await findWorkspaceSlugMapping({
-    configFile: config.authStatePath,
-    repositoryUrl,
-    repositoryRoot
-  });
-  const fallbackWorkspaceSlug = config.fallbackWorkspaceSlug;
-  const directoryPath = normalizeRepositoryPath(repositoryRoot, requestedDirectory);
-  const workspaceSlug = config.configuredWorkspaceSlug ?? learnedWorkspaceMapping?.workspaceSlug ?? fallbackWorkspaceSlug ?? null;
-  const workspaceSlugSource = config.configuredWorkspaceSlug ? 'configured' : learnedWorkspaceMapping?.workspaceSlug ? 'learned' : fallbackWorkspaceSlug ? 'fallback' : repositoryUrl ? 'repositoryUrl' : 'placeholder';
-  const workspaceIdentity = workspaceSlug ? `workspaceSlug:${workspaceSlug}` : repositoryUrl ? `repository:${repositoryUrl}` : 'workspace:placeholder';
-  return {
-    requestedDirectory,
-    repositoryRoot,
-    repositoryUrl,
-    workspaceSlug,
-    workspaceSlugSource,
-    fallbackWorkspaceSlug,
-    directoryPath,
-    cacheKey: JSON.stringify([workspaceIdentity, directoryPath])
-  };
-};
-const toDeliveryInput = resolution => {
-  if (resolution.workspaceSlug) {
-    return {
-      workspaceSlug: resolution.workspaceSlug,
-      directoryPath: resolution.directoryPath
-    };
-  }
-  if (resolution.repositoryUrl) {
-    return {
-      repositoryUrl: resolution.repositoryUrl,
-      directoryPath: resolution.directoryPath
-    };
-  }
-  return {
-    workspaceSlug: 'workspace',
-    directoryPath: resolution.directoryPath
-  };
-};
-const formatSkillLabel = item => {
-  const artifactName = item.publishedArtifact.frontmatterName.trim();
-  if (artifactName.length > 0) return artifactName;
-  return item.skill.name;
-};
-const toFrontmatterString = value => JSON.stringify(value);
-const isRecord = value => {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-};
-const isValidIsoDateString = value => {
-  return typeof value === 'string' && Number.isFinite(Date.parse(value));
-};
-const isAuthState = value => {
-  if (!isRecord(value)) return false;
-  return value.pluginId === PLUGIN_ID && typeof value.sessionToken === 'string' && isValidIsoDateString(value.expiresAt) && isValidIsoDateString(value.authenticatedAt) && typeof value.userId === 'string' && typeof value.email === 'string';
-};
-const readGlobalConfig = async configFile => {
-  const storedConfig = await readJsonFile(configFile);
-  if (isRecord(storedConfig)) return storedConfig;
-  return {};
-};
-const writeGlobalConfig = async (configFile, config) => {
-  await writePrivateJsonFile(configFile, config);
-};
-const withoutLegacyPublishedSkillPreferences = config => {
-  const {
-    publishedSkillPreferences,
-    ignoredPublishedSkills,
-    ...safeConfig
-  } = config;
-  void publishedSkillPreferences;
-  void ignoredPublishedSkills;
-  return safeConfig;
-};
-const hasLegacyPublishedSkillPreferences = config => {
-  return Object.prototype.hasOwnProperty.call(config, 'publishedSkillPreferences') || Object.prototype.hasOwnProperty.call(config, 'ignoredPublishedSkills');
-};
-const isStoredWorkspaceSlugMapping = value => {
-  if (!isRecord(value)) return false;
-  const {
-    repositoryUrl,
-    repositoryRoot,
-    workspaceSlug,
-    updatedAt
-  } = value;
-  const hasValidRepositoryUrl = repositoryUrl === null || typeof repositoryUrl === 'string';
-  const hasValidRepositoryRoot = repositoryRoot === null || typeof repositoryRoot === 'string';
-  return hasValidRepositoryUrl && hasValidRepositoryRoot && typeof workspaceSlug === 'string' && workspaceSlug.trim().length > 0 && isValidIsoDateString(updatedAt);
-};
-const readWorkspaceSlugMappings = async configFile => {
-  const storedConfig = await readGlobalConfig(configFile);
-  const mappings = storedConfig.workspaceSlugMappings;
-  if (!Array.isArray(mappings)) return [];
-  return mappings.filter(isStoredWorkspaceSlugMapping).slice(0, WORKSPACE_MAPPING_LIMIT);
-};
-const writeWorkspaceSlugMappings = async (configFile, nextMappings) => {
-  const storedConfig = await readGlobalConfig(configFile);
-  await writeGlobalConfig(configFile, {
-    ...withoutLegacyPublishedSkillPreferences(storedConfig),
-    workspaceSlugMappings: nextMappings.slice(0, WORKSPACE_MAPPING_LIMIT)
-  });
-};
-const normalizeStoredRepositoryRoot = value => {
-  if (!value) return null;
-  return normalizeAbsolutePath(value);
-};
-const upsertWorkspaceSlugMapping = async ({
-  configFile,
-  repositoryUrl,
-  repositoryRoot,
-  workspaceSlug
-}) => {
-  const normalizedWorkspaceSlug = toWorkspaceSlug(workspaceSlug);
-  if (!normalizedWorkspaceSlug) return;
-  const normalizedRepositoryRoot = normalizeStoredRepositoryRoot(repositoryRoot);
-  const existingMappings = await readWorkspaceSlugMappings(configFile);
-  const filteredMappings = existingMappings.filter(mapping => {
-    if (repositoryUrl && mapping.repositoryUrl === repositoryUrl) return false;
-    if (normalizedRepositoryRoot && normalizeStoredRepositoryRoot(mapping.repositoryRoot) === normalizedRepositoryRoot) {
-      return false;
-    }
-    return true;
-  });
-  await writeWorkspaceSlugMappings(configFile, [{
-    repositoryUrl,
-    repositoryRoot: normalizedRepositoryRoot,
-    workspaceSlug: normalizedWorkspaceSlug,
-    updatedAt: new Date().toISOString()
-  }, ...filteredMappings]);
-};
-const findWorkspaceSlugMapping = async ({
-  configFile,
-  repositoryUrl,
-  repositoryRoot
-}) => {
-  const normalizedRepositoryRoot = normalizeStoredRepositoryRoot(repositoryRoot);
-  const mappings = await readWorkspaceSlugMappings(configFile);
-  if (repositoryUrl) {
-    const repositoryMatch = mappings.find(mapping => mapping.repositoryUrl === repositoryUrl);
-    if (repositoryMatch) return repositoryMatch;
-  }
-  if (normalizedRepositoryRoot) {
-    const rootMatch = mappings.find(mapping => normalizeStoredRepositoryRoot(mapping.repositoryRoot) === normalizedRepositoryRoot);
-    if (rootMatch) return rootMatch;
-  }
-  return null;
-};
-const readGlobalAuthState = async configFile => {
-  const storedConfig = await readGlobalConfig(configFile);
-  const storedAuthState = storedConfig.auth;
-  if (storedAuthState === undefined || storedAuthState === null) return null;
-  if (isAuthState(storedAuthState)) {
-    if (hasLegacyPublishedSkillPreferences(storedConfig)) {
-      await writeGlobalConfig(configFile, withoutLegacyPublishedSkillPreferences(storedConfig));
-    }
-    return storedAuthState;
-  }
-  await writeGlobalConfig(configFile, {
-    ...withoutLegacyPublishedSkillPreferences(storedConfig),
-    auth: null
-  });
-  return null;
-};
-const readLegacyAuthState = async authStateFile => {
-  const storedAuthState = await readJsonFile(authStateFile);
-  if (storedAuthState === null) return null;
-  if (isAuthState(storedAuthState)) return storedAuthState;
-  await deleteFileIfExists(authStateFile);
-  return null;
-};
-const writeAuthState = async (configFile, authState) => {
-  const storedConfig = await readGlobalConfig(configFile);
-  await writeGlobalConfig(configFile, {
-    ...withoutLegacyPublishedSkillPreferences(storedConfig),
-    auth: authState
-  });
-};
-const clearAuthState = async configFile => {
-  const storedConfig = await readGlobalConfig(configFile);
-  await writeGlobalConfig(configFile, {
-    ...withoutLegacyPublishedSkillPreferences(storedConfig),
-    auth: null
-  });
-};
-const toIgnoredSkillSlug = value => {
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) return null;
-  return normalized;
-};
-const toPublishedSkillPreferenceAction = value => {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === 'install' || normalized === 'uninstall' || normalized === 'ignore' || normalized === 'unignore') {
-    return normalized;
-  }
-  throw new Error('Published skill preference action must be one of: install, uninstall, ignore, unignore.');
-};
-const toPublishedSkillPreferenceScope = (value, defaultScope) => {
-  if (!value) return defaultScope;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === 'global' || normalized === 'project') return normalized;
-  throw new Error('Published skill preferenceScope must be either global or project.');
-};
-const getPublishedSkillIgnoreScopeKey = (resolution, payload) => {
-  const workspaceSlug = payload?.workspace?.slug ?? resolution.workspaceSlug ?? resolution.fallbackWorkspaceSlug;
-  if (workspaceSlug) return `workspace:${toWorkspaceSlug(workspaceSlug)}`;
-  if (resolution.repositoryUrl) return `repository:${resolution.repositoryUrl}`;
-  return `path:${toWorkspaceSlug(path.basename(resolution.repositoryRoot))}`;
-};
-const toStoredUserKey = authState => {
-  if (authState?.userId) return authState.userId;
-  if (authState?.email) return authState.email.toLowerCase();
-  return 'anonymous';
-};
-const resolvePublishedSkillPreferenceCacheContext = async config => {
-  const authState = await readGlobalAuthState(config.authStatePath);
-  return {
-    userKey: toStoredUserKey(authState),
-    preferenceVersion: publishedSkillPreferenceCacheVersion
-  };
-};
-const getCatalogCacheKey = (workspaceResolution, preferenceContext) => {
-  return JSON.stringify([workspaceResolution.cacheKey, preferenceContext.userKey, preferenceContext.preferenceVersion]);
-};
-const toAuthState = session => ({
-  pluginId: PLUGIN_ID,
-  sessionToken: session.jwtToken,
-  expiresAt: session.expiresAt,
-  authenticatedAt: new Date().toISOString(),
-  userId: session.user.id,
-  email: session.user.email
-});
-const resolveStoredAuthState = async (worktree, config) => {
-  const authState = await readGlobalAuthState(config.authStatePath);
-  if (authState && Date.parse(authState.expiresAt) > Date.now()) {
-    return authState;
-  }
-  if (authState) {
-    await clearAuthState(config.authStatePath);
-    return null;
-  }
-  const legacyAuthStateFile = path.resolve(worktree, LEGACY_AUTH_STATE_PATH);
-  const legacyAuthState = await readLegacyAuthState(legacyAuthStateFile);
-  if (!legacyAuthState) return null;
-  if (Date.parse(legacyAuthState.expiresAt) <= Date.now()) {
-    await deleteFileIfExists(legacyAuthStateFile);
-    return null;
-  }
-  await writeAuthState(config.authStatePath, legacyAuthState);
-  await deleteFileIfExists(legacyAuthStateFile);
-  return legacyAuthState;
-};
-export const buildSkillMarkdown = item => {
-  const artifactBody = item.publishedArtifact.markdownBody.trim();
-  const fallbackBody = item.publishedArtifact.renderedContent.trim();
-  const body = artifactBody || fallbackBody;
-  if (body.startsWith('---')) {
-    return body.endsWith('\n') ? body : `${body}\n`;
-  }
-  const name = formatSkillLabel(item);
-  const description = item.publishedArtifact.frontmatterDescription.trim() || item.skill.summary?.trim() || '';
-  const frontmatter = ['---', `name: ${toFrontmatterString(name)}`, `description: ${toFrontmatterString(description)}`, '---'].join('\n');
-  if (!body) {
-    return `${frontmatter}\n`;
-  }
-  return `${frontmatter}\n\n${body.endsWith('\n') ? body : `${body}\n`}`;
-};
-const getSkillIdentifiers = item => {
-  const candidates = [item.skill.slug, item.publishedArtifact.frontmatterName, item.skill.name];
-  const seen = new Set();
-  return candidates.reduce((all, candidate) => {
-    const normalized = candidate.trim();
-    if (!normalized) return all;
-    const cacheKey = normalized.toLowerCase();
-    if (seen.has(cacheKey)) return all;
-    seen.add(cacheKey);
-    all.push(normalized);
-    return all;
-  }, []);
-};
-const toPublishedSkillFacetSummary = facet => ({
-  slug: facet.slug,
-  label: facet.label,
-  description: facet.description ?? null
-});
-const toPublishedSkillTagSummary = tag => ({
-  slug: tag.slug,
-  label: tag.label,
-  description: tag.description ?? null,
-  facet: tag.facet ? toPublishedSkillFacetSummary(tag.facet) : null
-});
-const getPublishedSkillFacets = items => {
-  const facetsBySlug = new Map();
-  for (const item of items) {
-    for (const tag of item.skill.tags) {
-      if (!tag.facet) continue;
-      if (facetsBySlug.has(tag.facet.slug)) continue;
-      facetsBySlug.set(tag.facet.slug, toPublishedSkillFacetSummary(tag.facet));
-    }
-  }
-  return [...facetsBySlug.values()].sort((left, right) => left.slug.localeCompare(right.slug));
-};
-const isUserPublishedSkillAssignment = assignmentSource => assignmentSource === 'USER' || assignmentSource === 'USER_GLOBAL' || assignmentSource === 'USER_WORKSPACE';
-const getPublishedSkillAssignmentLabel = assignmentSource => {
-  if (assignmentSource === 'GLOBAL') return 'GLOBAL SCOPE assignment';
-  if (assignmentSource === 'WORKSPACE') return 'PROJECT SCOPE assignment';
-  if (assignmentSource === 'USER_GLOBAL') return 'USER SCOPE preference (global target)';
-  if (assignmentSource === 'USER_WORKSPACE') return 'USER SCOPE preference (project target)';
-  if (assignmentSource === 'USER') return 'USER SCOPE assignment';
-  return `${assignmentSource.toUpperCase().replace(/_/gu, ' ')} assignment`;
-};
-const getPublishedSkillAssignmentCounts = items => items.reduce((counts, item) => {
-  if (isUserPublishedSkillAssignment(item.assignmentSource)) {
-    return {
-      ...counts,
-      user: counts.user + 1
-    };
-  }
-  if (item.assignmentSource === 'GLOBAL') {
-    return {
-      ...counts,
-      global: counts.global + 1
-    };
-  }
-  if (item.assignmentSource === 'WORKSPACE') {
-    return {
-      ...counts,
-      project: counts.project + 1
-    };
-  }
-  return {
-    ...counts,
-    other: counts.other + 1
-  };
-}, {
-  global: 0,
-  project: 0,
-  user: 0,
-  other: 0
-});
-const getSkillContextKind = item => {
-  if (item.assignmentSource === 'GLOBAL' || item.assignmentSource === 'USER_GLOBAL') return 'global';
-  return 'project';
-};
-const getSkillPolicyLabel = (policy, contextKind, assignmentSource) => {
-  if (isUserPublishedSkillAssignment(assignmentSource) && policy === 'GLOBAL_CONTEXT') {
-    return 'GLOBAL_CONTEXT · active USER SCOPE context';
-  }
-  if (isUserPublishedSkillAssignment(assignmentSource)) return 'PROJECT_INSTALLABLE · active USER SCOPE preference';
-  if (policy === 'GLOBAL_CONTEXT') return 'GLOBAL_CONTEXT · active context only, not project-installable';
-  if (contextKind === 'installable') return 'PROJECT_INSTALLABLE · available to install';
-  if (contextKind === 'global') return 'PROJECT_INSTALLABLE · active GLOBAL SCOPE assignment';
-  return 'PROJECT_INSTALLABLE · active PROJECT SCOPE assignment';
-};
-const toPublishedSkillSummary = item => {
-  const contextKind = getSkillContextKind(item);
-  return {
-    skillSlug: item.skill.slug,
-    skillName: item.skill.name,
-    artifactName: item.publishedArtifact.frontmatterName,
-    artifactDescription: item.publishedArtifact.frontmatterDescription,
-    whenToUse: item.skill.whenToUse ?? null,
-    version: item.skillVersion.version,
-    assignmentSource: item.assignmentSource,
-    assignmentType: item.assignmentType,
-    scopePath: item.scopePath,
-    includeChildren: item.includeChildren ?? null,
-    checksum: item.publishedArtifact.checksum,
-    publishedAt: item.publishedArtifact.publishedAt,
-    fileCount: item.publishedArtifact.fileCount,
-    identifiers: getSkillIdentifiers(item),
-    tags: item.skill.tags.map(toPublishedSkillTagSummary),
-    contextKind,
-    installPolicy: item.skill.installPolicy,
-    assignmentLabel: getPublishedSkillAssignmentLabel(item.assignmentSource),
-    policyLabel: getSkillPolicyLabel(item.skill.installPolicy, contextKind, item.assignmentSource)
-  };
-};
-export const toPublishedSkillDetail = item => ({
-  ...toPublishedSkillSummary(item),
-  skillId: item.skill.id,
-  skillVersionId: item.skillVersion.id,
-  artifactId: item.publishedArtifact.id,
-  markdownDocument: buildSkillMarkdown(item),
-  markdownBody: item.publishedArtifact.markdownBody,
-  renderedContent: item.publishedArtifact.renderedContent,
-  files: item.publishedArtifact.files,
-  resources: item.publishedArtifact.files.filter(file => file.relativePath !== 'SKILL.md')
-});
-const toInstallableSkillSummary = item => ({
-  skillSlug: item.skill.slug,
-  skillName: item.skill.name,
-  artifactName: item.publishedArtifact.frontmatterName,
-  artifactDescription: item.publishedArtifact.frontmatterDescription,
-  whenToUse: item.skill.whenToUse ?? null,
-  version: item.skillVersion.version,
-  assignmentSource: 'CATALOG',
-  assignmentType: 'PATH',
-  scopePath: '',
-  includeChildren: true,
-  checksum: item.publishedArtifact.checksum,
-  publishedAt: item.publishedArtifact.publishedAt,
-  fileCount: item.publishedArtifact.fileCount,
-  identifiers: getSkillIdentifiers({
-    ...item,
-    assignmentSource: 'CATALOG',
-    assignmentType: 'PATH',
-    scopePath: '',
-    includeChildren: true
-  }),
-  tags: item.skill.tags.map(toPublishedSkillTagSummary),
-  contextKind: 'installable',
-  installPolicy: item.skill.installPolicy,
-  assignmentLabel: 'catalog skill',
-  policyLabel: getSkillPolicyLabel(item.skill.installPolicy, 'installable', 'CATALOG')
-});
-export const toPublishedSkillCatalog = payload => ({
-  pluginId: PLUGIN_ID,
-  runtimeMode: 'tool_fetch_only',
-  deliveryModel: 'backend_published_installed_effective_skills',
-  workspace: payload.workspace,
-  directoryPath: payload.directoryPath,
-  rootSkillSeedPath: ROOT_SKILL_SEED_PATH,
-  availableTools: AVAILABLE_PUBLISHED_SKILL_TOOLS,
-  publishedSkillCount: payload.skills.length,
-  assignmentCounts: getPublishedSkillAssignmentCounts(payload.skills),
-  facets: getPublishedSkillFacets(payload.skills),
-  skills: payload.skills.map(toPublishedSkillSummary)
-});
-const filterIgnoredPublishedSkills = async (config, result) => {
-  const authState = await readGlobalAuthState(config.authStatePath);
-  const userKey = toStoredUserKey(authState);
-  if (!result.fetchResult.ok) {
-    return {
-      ...result,
-      ignoreState: {
-        scopeKey: getPublishedSkillIgnoreScopeKey(result.workspaceResolution),
-        userKey,
-        ignoredSkillSlugs: [],
-        installedGlobalSkillSlugs: [],
-        installedWorkspaceSkillSlugs: []
-      },
-      ignoredSkills: []
-    };
-  }
-  const ignoredSkills = result.fetchResult.payload.userPreferences.ignoredSkills.map(toPublishedSkillSummary);
-  const ignoredSkillSlugs = ignoredSkills.map(skill => skill.skillSlug);
-  return {
-    ...result,
-    ignoreState: {
-      scopeKey: result.fetchResult.payload.userPreferences.scopeKey,
-      userKey: result.fetchResult.payload.userPreferences.userKey || userKey,
-      ignoredSkillSlugs,
-      installedGlobalSkillSlugs: [],
-      installedWorkspaceSkillSlugs: []
-    },
-    ignoredSkills
-  };
-};
-const getWorkspaceUnavailableMessage = payload => {
-  if (payload.workspace) return null;
-  return 'Workspace-specific skills are unavailable because the workspace was not found; global skills are still loaded.';
-};
-const normalizeSkillIdentifier = value => value.trim().toLowerCase();
-const parseSkillIdentifiers = value => {
-  const seen = new Set();
-  return value.split(/[\n,]/).map(item => item.trim()).filter(item => item.length > 0).filter(item => {
-    const normalized = normalizeSkillIdentifier(item);
-    if (seen.has(normalized)) return false;
-    seen.add(normalized);
-    return true;
-  });
-};
-const mergeSkillIdentifiers = values => {
-  const seen = new Set();
-  return values.filter(value => {
-    const normalized = normalizeSkillIdentifier(value);
-    if (!normalized || seen.has(normalized)) return false;
-    seen.add(normalized);
-    return true;
-  });
-};
-export const parseRequestedSkillArgs = args => {
-  const requestedSkills = [];
-  if (typeof args.skill === 'string') {
-    requestedSkills.push(...parseSkillIdentifiers(args.skill));
-  }
-  if (typeof args.skills === 'string') {
-    requestedSkills.push(...parseSkillIdentifiers(args.skills));
-  }
-  return mergeSkillIdentifiers(requestedSkills);
-};
-export const selectPublishedSkills = (payload, identifiers) => {
-  const itemsByIdentifier = new Map();
-  for (const item of payload.skills) {
-    for (const identifier of getSkillIdentifiers(item)) {
-      itemsByIdentifier.set(normalizeSkillIdentifier(identifier), item);
-    }
-  }
-  const selectedItems = [];
-  const selectedKeys = new Set();
-  const missingIdentifiers = [];
-  for (const identifier of identifiers) {
-    const matched = itemsByIdentifier.get(normalizeSkillIdentifier(identifier));
-    if (!matched) {
-      missingIdentifiers.push(identifier);
-      continue;
-    }
-    if (selectedKeys.has(matched.publishedArtifact.id)) {
-      continue;
-    }
-    selectedKeys.add(matched.publishedArtifact.id);
-    selectedItems.push(matched);
-  }
-  return {
-    selectedItems,
-    missingIdentifiers
-  };
-};
-const truncateText = (value, maxLength) => {
-  const normalized = value.replace(/\s+/gu, ' ').trim();
-  if (normalized.length <= maxLength) return normalized;
-  return `${normalized.slice(0, Math.max(maxLength - 1, 0)).trimEnd()}…`;
-};
-const buildSkillCatalogLine = skill => {
-  const description = truncateText(skill.whenToUse || skill.artifactDescription || skill.skillName || skill.skillSlug, SYSTEM_NOTE_SKILL_DESCRIPTION_LIMIT);
-  const scopeLabel = isUserPublishedSkillAssignment(skill.assignmentSource) ? 'USER SCOPE' : skill.contextKind === 'global' ? 'GLOBAL SCOPE' : 'PROJECT SCOPE';
-  const assignmentLabel = skill.assignmentSource.toLowerCase().replace(/_/gu, ' ');
-  return `- ${skill.artifactName || skill.skillName} (${skill.skillSlug}, ${assignmentLabel} assignment) [${scopeLabel}]: ${description}`;
-};
-const buildSkillDetailSnippetLine = detail => {
-  const body = detail.markdownBody || detail.renderedContent || detail.markdownDocument;
-  return `- ${detail.artifactName || detail.skillName}: ${truncateText(body, 700)}`;
-};
-export const buildSystemNote = (result, config, details) => {
-  if (!result.fetchResult.ok) return null;
-  const catalog = toPublishedSkillCatalog(result.fetchResult.payload);
-  const skillNames = catalog.skills.map(skill => skill.artifactName || skill.skillName || skill.skillSlug);
-  const renderedSkillNames = skillNames.length > 0 ? skillNames.slice(0, SYSTEM_NOTE_SKILL_NAME_LIMIT).join(', ') : 'none';
-  const remainingCount = Math.max(skillNames.length - SYSTEM_NOTE_SKILL_NAME_LIMIT, 0);
-  const renderedCountSuffix = remainingCount > 0 ? ` (+${remainingCount} more)` : '';
-  const globalSkills = catalog.skills.filter(skill => skill.contextKind === 'global' && !isUserPublishedSkillAssignment(skill.assignmentSource)).slice(0, 8).map(buildSkillCatalogLine);
-  const projectSkills = catalog.skills.filter(skill => skill.contextKind === 'project' && !isUserPublishedSkillAssignment(skill.assignmentSource)).slice(0, 5).map(buildSkillCatalogLine);
-  const userSkills = catalog.skills.filter(skill => isUserPublishedSkillAssignment(skill.assignmentSource)).slice(0, 5).map(buildSkillCatalogLine);
-  const detailLines = details.slice(0, SYSTEM_NOTE_DETAIL_LIMIT).map(buildSkillDetailSnippetLine);
-  const detailBlock = detailLines.length > 0 ? `Loaded body snippets (capped):\n${truncateText(detailLines.join('\n'), SYSTEM_NOTE_DETAIL_CHAR_LIMIT)}` : '';
-  return [result.fetchResult.payload.workspace ? `Workspace: ${result.fetchResult.payload.workspace.slug}.` : 'Workspace not found; workspace-scoped wizard skills are unavailable.', `Current directory: ${result.directoryPath}.`, `Active wizard skills: ${renderedSkillNames}${renderedCountSuffix}.`, `Counts: ${catalog.assignmentCounts.global} global, ${catalog.assignmentCounts.project} project, ${catalog.assignmentCounts.user} user, ${catalog.assignmentCounts.other} other.`, 'Wizard-listed skills are backend-published, not native OpenCode skills.', 'Use native skill tooling only for names in native available_skills.', 'When a wizard skill matches by whenToUse, fetch its current body with opencode_wizard_published_skills_fetch before using it.', 'Use `skills` for multiple wizard skill identifiers; use `skill` for one.', 'If native skill loading cannot find a wizard-listed skill, fetch it as a wizard skill instead.', 'Fetched wizard bodies are authoritative over local seed/native sources.', globalSkills.length > 0 ? `Global skills:\n${globalSkills.join('\n')}` : 'Global skills: none.', projectSkills.length > 0 ? `Project skills:\n${projectSkills.join('\n')}` : 'Project skills: none.', userSkills.length > 0 ? `User skills:\n${userSkills.join('\n')}` : 'User skills: none.', detailBlock].filter(Boolean).join(' ');
-};
-const toWorkspaceResolutionOutput = resolution => ({
-  requestedDirectory: resolution.requestedDirectory,
-  repositoryRoot: resolution.repositoryRoot,
-  repositoryUrl: resolution.repositoryUrl,
-  workspaceSlug: resolution.workspaceSlug,
-  workspaceSlugSource: resolution.workspaceSlugSource,
-  fallbackWorkspaceSlug: resolution.fallbackWorkspaceSlug,
-  directoryPath: resolution.directoryPath
-});
-const toWorkspaceResolutionMetadata = resolution => ({
-  directoryPath: resolution.directoryPath,
-  repositoryRoot: resolution.repositoryRoot,
-  repositoryUrl: resolution.repositoryUrl ?? '',
-  workspaceSlug: resolution.workspaceSlug ?? '',
-  workspaceSlugSource: resolution.workspaceSlugSource ?? 'placeholder',
-  fallbackWorkspaceSlug: resolution.fallbackWorkspaceSlug ?? ''
-});
-const formatStatusOutput = async (worktree, config, publishedSkillsResult, loginBootstrapSnapshot) => {
-  const authState = await resolveStoredAuthState(worktree, config);
-  const filteredResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
-  const base = {
-    pluginId: PLUGIN_ID,
-    runtimeMode: 'tool_fetch_only',
-    nativeSkillsUrlCompatibility: NATIVE_SKILLS_URL_COMPATIBILITY,
-    backendOrigin: config.backendOrigin,
-    graphqlUrl: config.graphqlUrl,
-    fallbackWorkspaceSlug: config.fallbackWorkspaceSlug,
-    workspaceResolution: toWorkspaceResolutionOutput(publishedSkillsResult.workspaceResolution),
-    rootSkillSeedPath: config.rootSkillSeedPath,
-    authStatePath: config.authStatePath,
-    requestedDirectoryPath: publishedSkillsResult.directoryPath,
-    authMode: publishedSkillsResult.fetchResult.authMode,
-    authState: authState === null ? null : {
-      email: authState.email,
-      userId: authState.userId,
-      authenticatedAt: authState.authenticatedAt,
-      expiresAt: authState.expiresAt
-    },
-    loginBootstrap: loginBootstrapSnapshot.status === 'idle' ? null : {
-      status: loginBootstrapSnapshot.status,
-      trigger: loginBootstrapSnapshot.trigger,
-      startedAt: loginBootstrapSnapshot.startedAt,
-      expiresAt: loginBootstrapSnapshot.expiresAt,
-      browserUrl: loginBootstrapSnapshot.browserUrl,
-      browserOpenError: loginBootstrapSnapshot.browserOpenError,
-      email: loginBootstrapSnapshot.email,
-      message: loginBootstrapSnapshot.message
-    },
-    status: filteredResult.fetchResult.status,
-    fetchedAt: filteredResult.fetchResult.fetchedAt,
-    source: filteredResult.fetchResult.source,
-    availableTools: AVAILABLE_PUBLISHED_SKILL_TOOLS,
-    ignoredPublishedSkills: {
-      scopeKey: filteredResult.ignoreState.scopeKey,
-      userKey: filteredResult.ignoreState.userKey,
-      count: filteredResult.ignoreState.ignoredSkillSlugs.length
-    }
-  };
-  if (!filteredResult.fetchResult.ok) {
-    return JSON.stringify({
-      ...base,
-      message: filteredResult.fetchResult.message
-    }, null, 2);
-  }
-  return JSON.stringify({
-    ...base,
-    ...toPublishedSkillCatalog(filteredResult.fetchResult.payload),
-    message: getWorkspaceUnavailableMessage(filteredResult.fetchResult.payload)
-  }, null, 2);
-};
-export const toPluginAuthStateSummary = authState => {
-  if (!authState) {
-    return {
-      status: 'missing',
-      email: null,
-      userId: null,
-      authenticatedAt: null,
-      expiresAt: null
-    };
-  }
-  return {
-    status: 'authenticated',
-    email: authState.email,
-    userId: authState.userId,
-    authenticatedAt: authState.authenticatedAt,
-    expiresAt: authState.expiresAt
-  };
-};
-export const resolvePluginStatusSnapshot = async ({
-  worktree,
-  directory,
-  signal
-}) => {
-  const config = await resolveConfig(worktree);
-  const workspaceResolution = await resolveWorkspace({
-    config,
-    directory
-  });
-  const fetchResult = await fetchPublishedSkillsCatalog(worktree, config, workspaceResolution, signal);
-  const filteredResult = await filterIgnoredPublishedSkills(config, {
-    directoryPath: workspaceResolution.directoryPath,
-    workspaceResolution,
-    fetchResult
-  });
-  const authState = await resolveStoredAuthState(worktree, config);
-  return {
-    pluginId: PLUGIN_ID,
-    runtimeMode: 'tool_fetch_only',
-    nativeSkillsUrlCompatibility: NATIVE_SKILLS_URL_COMPATIBILITY,
-    backendOrigin: config.backendOrigin,
-    graphqlUrl: config.graphqlUrl,
-    fallbackWorkspaceSlug: config.fallbackWorkspaceSlug,
-    workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
-    rootSkillSeedPath: config.rootSkillSeedPath,
-    authStatePath: config.authStatePath,
-    authState: toPluginAuthStateSummary(authState),
-    status: filteredResult.fetchResult.status,
-    authMode: filteredResult.fetchResult.authMode,
-    fetchedAt: filteredResult.fetchResult.fetchedAt,
-    source: filteredResult.fetchResult.source,
-    availableTools: AVAILABLE_PUBLISHED_SKILL_TOOLS,
-    message: filteredResult.fetchResult.ok ? getWorkspaceUnavailableMessage(filteredResult.fetchResult.payload) : filteredResult.fetchResult.message,
-    catalog: filteredResult.fetchResult.ok ? toPublishedSkillCatalog(filteredResult.fetchResult.payload) : null,
-    installableCatalog: filteredResult.fetchResult.ok ? {
-      count: filteredResult.fetchResult.payload.catalogSkills.length,
-      skills: filteredResult.fetchResult.payload.catalogSkills.map(toInstallableSkillSummary)
-    } : null,
-    ignoredPublishedSkills: {
-      scopeKey: filteredResult.ignoreState.scopeKey,
-      userKey: filteredResult.ignoreState.userKey,
-      count: filteredResult.ignoreState.ignoredSkillSlugs.length,
-      skills: filteredResult.ignoredSkills
-    }
-  };
-};
-const withStatusMessage = (snapshot, message) => ({
-  ...snapshot,
-  message
-});
-const toAiFacingPluginStatusSnapshot = snapshot => {
-  const {
-    ignoredPublishedSkills,
-    installableCatalog: _installableCatalog,
-    ...safeSnapshot
-  } = snapshot;
-  return {
-    ...safeSnapshot,
-    ignoredPublishedSkills: {
-      scopeKey: ignoredPublishedSkills.scopeKey,
-      count: ignoredPublishedSkills.count
-    }
-  };
-};
-const startStatusPathLoginBootstrap = (worktree, config) => {
-  if (statusPathLoginBootstrap.promise) return;
-  if (statusPathLoginBootstrap.status === 'failed' && statusPathLoginBootstrap.failedAt && Date.now() - statusPathLoginBootstrap.failedAt < STATUS_PATH_LOGIN_RETRY_COOLDOWN_MS) {
-    return;
-  }
-  statusPathLoginBootstrap.status = 'pending';
-  statusPathLoginBootstrap.message = 'Browser login started automatically from the TUI/status path.';
-  statusPathLoginBootstrap.failedAt = null;
-  statusPathLoginBootstrap.promise = (async () => {
-    const loginSignal = AbortSignal.timeout(LOGIN_TIMEOUT_MS);
-    const loginStart = await startLoginFlow(loginSignal);
-    const browserOpenError = await openBrowser(loginStart.browserUrl);
-    if (browserOpenError) {
-      statusPathLoginBootstrap.message = `Automatic browser open failed. Open ${loginStart.browserUrl} manually.`;
-    }
-    try {
-      const callbackPayload = await loginStart.callbackPromise;
-      if (callbackPayload.status === 'error') {
-        throw new Error(callbackPayload.message);
-      }
-      if (callbackPayload.state !== loginStart.expectedState) {
-        throw new Error('OAuth callback state did not match the original login request.');
-      }
-      const pluginSession = await createPluginSession({
-        code: callbackPayload.code,
-        codeVerifier: loginStart.codeVerifier,
-        redirectUri: OIDC_CALLBACK_URL,
-        config,
-        signal: loginSignal
-      });
-      const authState = toAuthState(pluginSession);
-      await writeAuthState(config.authStatePath, authState);
-      statusPathLoginBootstrap.status = 'authenticated';
-      statusPathLoginBootstrap.message = `Browser login completed successfully for ${authState.email}.`;
-      return authState;
-    } finally {
-      await loginStart.closeCallbackServer().catch(() => undefined);
-    }
-  })().catch(error => {
-    statusPathLoginBootstrap.status = 'failed';
-    statusPathLoginBootstrap.failedAt = Date.now();
-    statusPathLoginBootstrap.message = error instanceof Error ? error.message : 'Browser login failed.';
-    throw error;
-  }).finally(() => {
-    statusPathLoginBootstrap.promise = null;
-  });
-  statusPathLoginBootstrap.promise.catch(() => undefined);
-};
-export const resolvePluginStatusSnapshotWithAuthBootstrap = async ({
-  worktree,
-  directory,
-  signal
-}) => {
-  const snapshot = await resolvePluginStatusSnapshot({
-    worktree,
-    directory,
-    signal
-  });
-  if (snapshot.status !== 'missing_auth') return snapshot;
-  const config = await resolveConfig(worktree);
-  startStatusPathLoginBootstrap(worktree, config);
-  if (statusPathLoginBootstrap.message) {
-    return withStatusMessage(snapshot, statusPathLoginBootstrap.message);
-  }
-  return withStatusMessage(snapshot, 'Browser login is pending from the TUI/status path.');
-};
-const toBackendPreferenceScope = preferenceScope => {
-  if (preferenceScope === 'global') return 'GLOBAL';
-  return 'WORKSPACE';
-};
-const setPublishedSkillPreference = async ({
-  worktree,
-  directory,
-  config,
-  skillSlug,
-  preferenceScope,
-  installed,
-  ignored
-}) => {
-  const workspaceResolution = await resolveWorkspace({
-    config,
-    directory
-  });
-  const response = await fetchPublishedSkillsGraphQl({
-    worktree,
-    config,
-    query: SET_PUBLISHED_SKILL_PREFERENCE_MUTATION,
-    variables: {
-      input: {
-        ...toDeliveryInput(workspaceResolution),
-        skillSlug,
-        preferenceScope: toBackendPreferenceScope(preferenceScope),
-        installed,
-        ignored
-      }
-    },
-    signal: AbortSignal.timeout(PRESENCE_EVENT_TIMEOUT_MS)
-  });
-  if (!response.ok) {
-    throw new Error(response.result.message);
-  }
-  const preferences = response.data.setPublishedSkillPreference;
-  publishedSkillPreferenceCacheVersion += 1;
-  return {
-    scopeKey: preferences.scopeKey,
-    userKey: preferences.userKey,
-    ignoredSkillSlugs: preferences.ignoredSkills.map(item => item.skill.slug),
-    installedGlobalSkillSlugs: [],
-    installedWorkspaceSkillSlugs: []
-  };
-};
-export const setPublishedSkillIgnored = async ({
-  worktree,
-  directory,
-  skillSlug,
-  ignored,
-  preferenceScope
-}) => {
-  const config = await resolveConfig(worktree);
-  const normalizedSkillSlug = toIgnoredSkillSlug(skillSlug);
-  if (!normalizedSkillSlug) {
-    throw new Error('Cannot toggle an empty published skill slug.');
-  }
-  return setPublishedSkillPreference({
-    worktree,
-    directory,
-    config,
-    skillSlug: normalizedSkillSlug,
-    preferenceScope: preferenceScope ?? 'project',
-    ignored
-  });
-};
-export const setPublishedSkillInstalled = async ({
-  worktree,
-  directory,
-  skillSlug,
-  installed,
-  preferenceScope
-}) => {
-  const config = await resolveConfig(worktree);
-  const normalizedSkillSlug = toIgnoredSkillSlug(skillSlug);
-  if (!normalizedSkillSlug) {
-    throw new Error('Cannot toggle an empty published skill slug.');
-  }
-  return setPublishedSkillPreference({
-    worktree,
-    directory,
-    config,
-    skillSlug: normalizedSkillSlug,
-    preferenceScope,
-    installed
-  });
-};
-const toPluginStatusMetadata = snapshot => ({
-  backendOrigin: snapshot.backendOrigin,
-  graphqlUrl: snapshot.graphqlUrl,
-  pluginStatus: snapshot.status,
-  authStatus: snapshot.authState.status,
-  authEmail: snapshot.authState.email ?? '',
-  authUserId: snapshot.authState.userId ?? '',
-  directoryPath: snapshot.workspaceResolution.directoryPath,
-  repositoryUrl: snapshot.workspaceResolution.repositoryUrl ?? '',
-  source: snapshot.source,
-  workspaceSlug: snapshot.workspaceResolution.workspaceSlug ?? '',
-  workspaceSlugSource: snapshot.workspaceResolution.workspaceSlugSource ?? 'placeholder'
-});
-const isUnauthorizedGraphQlMessage = message => {
-  const normalizedMessage = message.toLowerCase();
-  return normalizedMessage.includes('not authorized') || normalizedMessage.includes('unauthorized');
-};
-const createRandomBase64Url = bytes => {
-  return crypto.randomBytes(bytes).toString('base64url');
-};
-const createCodeChallenge = codeVerifier => {
-  return crypto.createHash('sha256').update(codeVerifier).digest('base64url');
-};
-const getMessageFromUnknownPayload = value => {
-  if (!value || typeof value !== 'object') return null;
-  const candidate = 'message' in value ? value.message : null;
-  return typeof candidate === 'string' ? candidate : null;
-};
-const wait = async milliseconds => {
-  await new Promise(resolve => {
-    setTimeout(resolve, milliseconds);
-  });
-};
-const shouldRetryPresenceEvent = status => {
-  return status === 408 || status === 429 || status >= 500;
-};
-const fetchOidcDiscoveryDocument = async signal => {
-  const discoveryUrl = `${OIDC_ISSUER.replace(/\/+$/, '')}/.well-known/openid-configuration`;
-  const response = await fetch(discoveryUrl, {
-    method: 'GET',
-    signal
-  });
-  if (!response.ok) {
-    throw new Error(`OIDC discovery failed with HTTP ${response.status}.`);
-  }
-  return await response.json();
-};
-const isCallbackPortInUseError = error => {
-  if (!error || typeof error !== 'object') return false;
-  if (!('code' in error)) return false;
-  return error.code === 'EADDRINUSE';
-};
-const toCallbackServerStartError = error => {
-  if (!isCallbackPortInUseError(error)) {
-    return error instanceof Error ? error : new Error('Failed to start local OAuth callback server.');
-  }
-  return new Error('OAuth login cannot start because localhost:24953 is already in use. Another OpenCode login is likely in progress; finish it or close the other instance, then retry.');
-};
-const startLocalCallbackServer = async ({
-  expectedState,
-  signal
-}) => {
-  let settled = false;
-  let resolvePayload = () => undefined;
-  let rejectPayload = () => undefined;
-  const callbackPromise = new Promise((resolve, reject) => {
-    resolvePayload = resolve;
-    rejectPayload = reject;
-  });
-  const finalize = payload => {
-    if (settled) return;
-    settled = true;
-    resolvePayload(payload);
-  };
-  const fail = reason => {
-    if (settled) return;
-    settled = true;
-    rejectPayload(reason);
-  };
-  const server = http.createServer((request, response) => {
-    const requestUrl = new URL(request.url ?? '/', OIDC_CALLBACK_ORIGIN);
-    if (requestUrl.pathname !== OIDC_CALLBACK_PATH) {
-      sendOAuthCallbackHtmlResponse(response, 404, 'opencode-wizard plugin login', 'Unknown callback path.');
-      return;
-    }
-    const error = requestUrl.searchParams.get('error');
-    const errorDescription = requestUrl.searchParams.get('error_description');
-    if (error) {
-      const message = errorDescription ?? error;
-      sendOAuthCallbackHtmlResponse(response, 400, 'opencode-wizard plugin login failed', message);
-      finalize({
-        status: 'error',
-        message
-      });
-      return;
-    }
-    const state = requestUrl.searchParams.get('state');
-    const code = requestUrl.searchParams.get('code');
-    if (!state || state !== expectedState) {
-      sendOAuthCallbackHtmlResponse(response, 400, 'opencode-wizard plugin login failed', 'OAuth state did not match the login request.');
-      finalize({
-        status: 'error',
-        message: 'OAuth state did not match the login request.'
-      });
-      return;
-    }
-    if (!code) {
-      sendOAuthCallbackHtmlResponse(response, 400, 'opencode-wizard plugin login failed', 'OAuth callback did not include an authorization code.');
-      finalize({
-        status: 'error',
-        message: 'OAuth callback did not include an authorization code.'
-      });
-      return;
-    }
-    sendOAuthCallbackHtmlResponse(response, 200, 'opencode-wizard plugin callback received', 'Callback received. OpenCode is finalizing the backend session now.');
-    finalize({
-      status: 'success',
-      code,
-      state
-    });
-  });
-  const close = async () => {
-    await new Promise((resolve, reject) => {
-      server.close(error => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-    });
-  };
-  await new Promise((resolve, reject) => {
-    const rejectStart = error => {
-      reject(toCallbackServerStartError(error));
-    };
-    server.once('error', rejectStart);
-    server.listen(24953, 'localhost', () => {
-      server.off('error', rejectStart);
-      server.on('error', error => {
-        fail(error instanceof Error ? error : new Error('Local OAuth callback server failed.'));
-      });
-      resolve();
-    });
-  });
-  signal.addEventListener('abort', () => {
-    fail(signal.reason instanceof Error ? signal.reason : new Error('OAuth login aborted.'));
-    void close().catch(() => undefined);
-  }, {
-    once: true
-  });
-  return {
-    callbackPromise,
-    close
-  };
-};
-const fetchPublishedSkillsGraphQl = async ({
-  worktree,
-  config,
-  query,
-  variables,
-  signal,
-  onAuthStateChanged
-}) => {
-  const authState = await resolveStoredAuthState(worktree, config);
-  const fetchedAt = new Date().toISOString();
-  if (!authState) {
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'missing_auth',
-        authMode: 'missing',
-        message: 'No plugin session is stored. Interactive opencode_wizard_published_skills_fetch can bootstrap browser login automatically when needed. Configured backend and GraphQL URLs are shown for visibility, but no GraphQL request was made because auth is missing.',
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  let response;
-  try {
-    response = await fetch(config.graphqlUrl, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        authorization: `Bearer ${authState.sessionToken}`
-      },
-      body: JSON.stringify({
-        query,
-        variables
-      }),
-      signal
-    });
-  } catch (error) {
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'request_failed',
-        authMode: 'session',
-        message: error instanceof Error ? error.message : 'Unknown fetch error',
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  if (response.status === 401 || response.status === 403) {
-    await clearAuthState(config.authStatePath);
-    onAuthStateChanged?.();
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'missing_auth',
-        authMode: 'session',
-        message: 'Stored plugin session was rejected by the backend. Retry opencode_wizard_published_skills_fetch to bootstrap a fresh browser login automatically.',
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  if (!response.ok) {
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'request_failed',
-        authMode: 'session',
-        message: `GraphQL request failed with HTTP ${response.status}.`,
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  let body;
-  try {
-    body = await response.json();
-  } catch (error) {
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'request_failed',
-        authMode: 'session',
-        message: `GraphQL response was not valid JSON: ${error instanceof Error ? error.message : 'Unknown parse error'}`,
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  if (body.errors?.length) {
-    const message = body.errors.map(error => error.message).join('; ');
-    if (body.errors.some(error => isUnauthorizedGraphQlMessage(error.message))) {
-      await clearAuthState(config.authStatePath);
-      onAuthStateChanged?.();
-      return {
-        ok: false,
-        result: {
-          ok: false,
-          status: 'missing_auth',
-          authMode: 'session',
-          message: 'Stored plugin session is no longer valid. Retry opencode_wizard_published_skills_fetch to bootstrap a fresh browser login automatically.',
-          fetchedAt,
-          source: 'network'
-        }
-      };
-    }
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'request_failed',
-        authMode: 'session',
-        message,
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  if (!body.data) {
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'request_failed',
-        authMode: 'session',
-        message: 'GraphQL response did not include data.',
-        fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  return {
-    ok: true,
-    data: body.data,
-    fetchedAt
-  };
-};
-const fetchPublishedSkillsCatalog = async (worktree, config, resolution, signal, onAuthStateChanged) => {
-  const response = await fetchPublishedSkillsGraphQl({
-    worktree,
-    config,
-    query: PUBLISHED_SKILLS_CATALOG_QUERY,
-    variables: {
-      input: toDeliveryInput(resolution)
-    },
-    signal,
-    onAuthStateChanged
-  });
-  if (!response.ok) {
-    return response.result;
-  }
-  const payload = response.data.pluginPublishedSkills;
-  if (!payload) {
-    return {
-      ok: false,
-      status: 'request_failed',
-      authMode: 'session',
-      message: 'GraphQL response did not include pluginPublishedSkills.',
-      fetchedAt: response.fetchedAt,
-      source: 'network'
-    };
-  }
-  return {
-    ok: true,
-    status: 'ready',
-    authMode: 'session',
-    payload,
-    fetchedAt: response.fetchedAt,
-    source: 'network'
-  };
-};
-const maybePersistWorkspaceSlugFromCatalog = async ({
-  config,
-  resolution,
-  fetchResult
-}) => {
-  if (!fetchResult.ok) return;
-  const backendWorkspaceSlug = fetchResult.payload.workspace?.slug?.trim();
-  if (!backendWorkspaceSlug) return;
-  const normalizedWorkspaceSlug = toWorkspaceSlug(backendWorkspaceSlug);
-  if (!normalizedWorkspaceSlug) return;
-  if (resolution.workspaceSlug === normalizedWorkspaceSlug && resolution.workspaceSlugSource !== 'fallback') return;
-  await upsertWorkspaceSlugMapping({
-    configFile: config.authStatePath,
-    repositoryUrl: resolution.repositoryUrl,
-    repositoryRoot: resolution.repositoryRoot,
-    workspaceSlug: normalizedWorkspaceSlug
-  });
-};
-const fetchPublishedSkillDetail = async ({
-  worktree,
-  config,
-  resolution,
-  skillVersionId,
-  signal,
-  onAuthStateChanged,
-  purpose
-}) => {
-  const response = await fetchPublishedSkillsGraphQl({
-    worktree,
-    config,
-    query: PUBLISHED_SKILL_DETAIL_QUERY,
-    variables: {
-      input: {
-        ...toDeliveryInput(resolution),
-        skillVersionId,
-        purpose
-      }
-    },
-    signal,
-    onAuthStateChanged
-  });
-  if (!response.ok) {
-    return response;
-  }
-  const artifact = response.data.pluginPublishedSkillVersionArtifact;
-  if (!artifact) {
-    return {
-      ok: false,
-      result: {
-        ok: false,
-        status: 'not_found',
-        authMode: 'session',
-        message: 'Published skill detail is not effective for the current scope.',
-        fetchedAt: response.fetchedAt,
-        source: 'network'
-      }
-    };
-  }
-  return {
-    ok: true,
-    artifact
-  };
-};
-const toFetchFailureOutput = async ({
-  worktree,
-  config,
-  publishedSkillsResult,
-  loginBootstrapSnapshot
-}) => ({
-  output: await formatStatusOutput(worktree, config, publishedSkillsResult, loginBootstrapSnapshot),
-  metadata: {
-    status: publishedSkillsResult.fetchResult.status,
-    ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
-    source: publishedSkillsResult.fetchResult.source
-  }
-});
-const startLoginFlow = async signal => {
-  const discovery = await fetchOidcDiscoveryDocument(signal);
-  const codeVerifier = createRandomBase64Url(64);
-  const expectedState = createRandomBase64Url(32);
-  const codeChallenge = createCodeChallenge(codeVerifier);
-  const expiresAt = new Date(Date.now() + LOGIN_TIMEOUT_MS).toISOString();
-  const {
-    callbackPromise,
-    close
-  } = await startLocalCallbackServer({
-    expectedState,
-    signal
-  });
-  const browserUrl = new URL(discovery.authorization_endpoint);
-  browserUrl.searchParams.set('client_id', OIDC_CLIENT_ID);
-  browserUrl.searchParams.set('response_type', 'code');
-  browserUrl.searchParams.set('redirect_uri', OIDC_CALLBACK_URL);
-  browserUrl.searchParams.set('response_mode', 'query');
-  browserUrl.searchParams.set('scope', OIDC_SCOPES.join(' '));
-  browserUrl.searchParams.set('code_challenge', codeChallenge);
-  browserUrl.searchParams.set('code_challenge_method', 'S256');
-  browserUrl.searchParams.set('state', expectedState);
-  return {
-    browserUrl: browserUrl.toString(),
-    expiresAt,
-    codeVerifier,
-    expectedState,
-    callbackPromise,
-    closeCallbackServer: close
-  };
-};
-const createPluginSession = async ({
-  code,
-  codeVerifier,
-  redirectUri,
-  config,
-  signal
-}) => {
-  const response = await fetch(config.authSessionUrl, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json'
-    },
-    body: JSON.stringify({
-      code,
-      codeVerifier,
-      redirectUri
-    }),
-    signal
-  });
-  const payload = await response.json().catch(() => null);
-  if (!response.ok) {
-    throw new Error(getMessageFromUnknownPayload(payload) ?? `Plugin session exchange failed with HTTP ${response.status}.`);
-  }
-  if (!payload || !('success' in payload) || payload.success !== true) {
-    throw new Error('Plugin session exchange returned an unexpected payload.');
-  }
-  return payload.session;
-};
-const emitPresenceEvent = async ({
-  config,
-  authState,
-  event,
-  workspacePath
-}) => {
-  for (let attempt = 1; attempt <= PRESENCE_EVENT_MAX_ATTEMPTS; attempt += 1) {
-    try {
-      const response = await fetch(config.presenceUrl, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          authorization: `Bearer ${authState.sessionToken}`
-        },
-        body: JSON.stringify({
-          event,
-          occurredAt: new Date().toISOString(),
-          workspacePath
-        }),
-        keepalive: event === 'STOP',
-        signal: AbortSignal.timeout(PRESENCE_EVENT_TIMEOUT_MS)
-      });
-      if (response.ok) return;
-      if (!shouldRetryPresenceEvent(response.status) || attempt === PRESENCE_EVENT_MAX_ATTEMPTS) return;
-    } catch {
-      if (attempt === PRESENCE_EVENT_MAX_ATTEMPTS) return;
-    }
-    await wait(PRESENCE_EVENT_RETRY_DELAY_MS * attempt);
-  }
-};
-const emitPluginActionEvent = async ({
-  config,
-  authState,
-  event,
-  workspacePath,
-  directoryPath
-}) => {
-  if (!authState) return;
-  try {
-    await fetch(config.actionsUrl, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        authorization: `Bearer ${authState.sessionToken}`
-      },
-      body: JSON.stringify({
-        event,
-        occurredAt: new Date().toISOString(),
-        workspacePath,
-        directoryPath
-      }),
-      keepalive: event === 'STOP',
-      signal: AbortSignal.timeout(PRESENCE_EVENT_TIMEOUT_MS)
-    });
-  } catch {
-    return;
-  }
-};
-const openBrowser = async url => {
-  try {
-    if (process.platform === 'darwin') {
-      await execFileAsync('open', [url]);
-      return null;
-    }
-    if (process.platform === 'win32') {
-      await execFileAsync('cmd', ['/c', 'start', '', url]);
-      return null;
-    }
-    await execFileAsync('xdg-open', [url]);
-    return null;
-  } catch (error) {
-    return error instanceof Error ? error.message : 'Failed to open browser automatically';
-  }
-};
-const normalizeDirectoryArg = (contextDirectory, directory) => {
-  return normalizeAbsolutePath(directory ? path.resolve(contextDirectory, directory) : contextDirectory);
-};
-const getDetailCacheKey = (catalogCacheKey, skillVersionId) => {
-  return JSON.stringify([catalogCacheKey, skillVersionId]);
-};
-const getDetailInflightKey = (catalogCacheKey, skillVersionId, purpose) => {
-  return JSON.stringify([catalogCacheKey, skillVersionId, purpose]);
-};
-const OpencodeWizardSkillsPlugin = async input => {
-  const {
-    tool
-  } = await importOpencodePluginModule('@opencode-ai/plugin');
-  const config = await resolveConfig(input.worktree);
-  const workspacePath = normalizeAbsolutePath(input.worktree);
-  const cache = new Map();
-  const catalogInflight = new Map();
-  const detailCache = new Map();
-  const detailInflight = new Map();
-  const initialAuthState = await resolveStoredAuthState(input.worktree, config);
-  const loginBootstrap = {
-    promise: null,
-    snapshot: createIdleLoginBootstrapSnapshot()
-  };
-  let lastAuthenticatedAuthState = initialAuthState;
-  let didEmitStart = false;
-  let didScheduleStop = false;
-  let presenceStartPromise = null;
-  let presenceStopPromise = null;
-  let lastInteractiveDirectoryPath = null;
-  const resolveActionAuthState = async () => {
-    const storedAuthState = await resolveStoredAuthState(input.worktree, config);
-    if (storedAuthState) return storedAuthState;
-    return lastAuthenticatedAuthState;
-  };
-  const emitActionEventForCurrentSession = async ({
-    event,
-    authState,
-    directoryPath
-  }) => {
-    await emitPluginActionEvent({
-      config,
-      authState: authState ?? (await resolveActionAuthState()),
-      event,
-      workspacePath,
-      directoryPath
-    });
-  };
-  const schedulePresenceStart = authState => {
-    lastAuthenticatedAuthState = authState;
-    if (didEmitStart) {
-      return presenceStartPromise ?? Promise.resolve();
-    }
-    didEmitStart = true;
-    presenceStartPromise = Promise.all([emitPresenceEvent({
-      config,
-      authState,
-      event: 'START',
-      workspacePath
-    }), emitActionEventForCurrentSession({
-      event: 'START',
-      authState,
-      directoryPath: lastInteractiveDirectoryPath ?? undefined
-    })]).then(() => undefined);
-    return presenceStartPromise;
-  };
-  const schedulePresenceStop = () => {
-    if (didScheduleStop) {
-      return presenceStopPromise ?? Promise.resolve();
-    }
-    didScheduleStop = true;
-    if (!didEmitStart || !lastAuthenticatedAuthState) {
-      presenceStopPromise = Promise.resolve();
-      return presenceStopPromise;
-    }
-    presenceStopPromise = (async () => {
-      await presenceStartPromise?.catch(() => undefined);
-      await Promise.all([emitPresenceEvent({
-        config,
-        authState: lastAuthenticatedAuthState,
-        event: 'STOP',
-        workspacePath
-      }), emitActionEventForCurrentSession({
-        event: 'STOP',
-        authState: lastAuthenticatedAuthState,
-        directoryPath: lastInteractiveDirectoryPath ?? undefined
-      })]);
-    })();
-    return presenceStopPromise;
-  };
-  const scheduleInteractivePresenceStart = async () => {
-    const authState = await resolveStoredAuthState(input.worktree, config);
-    if (!authState) return;
-    await schedulePresenceStart(authState);
-  };
-  process.once('beforeExit', () => {
-    void schedulePresenceStop();
-  });
-  for (const shutdownSignal of PRESENCE_SHUTDOWN_SIGNALS) {
-    try {
-      process.once(shutdownSignal, () => {
-        void schedulePresenceStop().finally(() => {
-          process.exit(PRESENCE_SIGNAL_EXIT_CODES[shutdownSignal]);
-        });
-      });
-    } catch {
-      continue;
-    }
-  }
-  const clearPublishedSkillState = () => {
-    cache.clear();
-    catalogInflight.clear();
-    detailCache.clear();
-    detailInflight.clear();
-  };
-  const persistAuthState = async session => {
-    const authState = toAuthState(session);
-    await writeAuthState(config.authStatePath, authState);
-    clearPublishedSkillState();
-    return authState;
-  };
-  const startLoginCompletion = trigger => {
-    if (loginBootstrap.promise) {
-      return loginBootstrap.promise;
-    }
-    const startedAt = new Date().toISOString();
-    loginBootstrap.snapshot = {
-      status: 'starting',
-      trigger,
-      startedAt,
-      expiresAt: null,
-      browserUrl: null,
-      browserOpenError: null,
-      email: null,
-      message: null
-    };
-    const loginPromise = (async () => {
-      const loginSignal = AbortSignal.timeout(LOGIN_TIMEOUT_MS);
-      let loginStart = null;
-      try {
-        loginStart = await startLoginFlow(loginSignal);
-        const browserOpenError = await openBrowser(loginStart.browserUrl);
-        loginBootstrap.snapshot = {
-          status: 'pending',
-          trigger,
-          startedAt,
-          expiresAt: loginStart.expiresAt,
-          browserUrl: loginStart.browserUrl,
-          browserOpenError,
-          email: null,
-          message: browserOpenError ? `Automatic browser open failed. Open ${loginStart.browserUrl} manually.` : `Browser login started for published skill ${trigger}.`
-        };
-        const callbackPayload = await loginStart.callbackPromise;
-        if (callbackPayload.status === 'error') {
-          throw new Error(callbackPayload.message);
-        }
-        if (callbackPayload.state !== loginStart.expectedState) {
-          throw new Error('OAuth callback state did not match the original login request.');
-        }
-        loginBootstrap.snapshot = {
-          status: 'pending',
-          trigger,
-          startedAt,
-          expiresAt: loginStart.expiresAt,
-          browserUrl: loginStart.browserUrl,
-          browserOpenError,
-          email: null,
-          message: 'OAuth callback received. Finalizing backend session exchange.'
-        };
-        const pluginSession = await createPluginSession({
-          code: callbackPayload.code,
-          codeVerifier: loginStart.codeVerifier,
-          redirectUri: OIDC_CALLBACK_URL,
-          config,
-          signal: loginSignal
-        });
-        const authState = await persistAuthState(pluginSession);
-        await emitActionEventForCurrentSession({
-          event: 'LOGIN_SUCCESS',
-          authState,
-          directoryPath: lastInteractiveDirectoryPath ?? undefined
-        });
-        loginBootstrap.snapshot = {
-          status: 'authenticated',
-          trigger,
-          startedAt,
-          expiresAt: authState.expiresAt,
-          browserUrl: loginStart.browserUrl,
-          browserOpenError,
-          email: authState.email,
-          message: `Browser login completed successfully for published skill ${trigger}.`
-        };
-        return authState;
-      } catch (error) {
-        await emitActionEventForCurrentSession({
-          event: 'LOGIN_FAILED',
-          directoryPath: lastInteractiveDirectoryPath ?? undefined
-        });
-        loginBootstrap.snapshot = {
-          status: 'failed',
-          trigger,
-          startedAt,
-          expiresAt: loginBootstrap.snapshot.expiresAt,
-          browserUrl: loginBootstrap.snapshot.browserUrl,
-          browserOpenError: loginBootstrap.snapshot.browserOpenError,
-          email: null,
-          message: error instanceof Error ? error.message : 'Browser login failed.'
-        };
-        throw error;
-      } finally {
-        await loginStart?.closeCallbackServer().catch(() => undefined);
-        loginBootstrap.promise = null;
-      }
-    })();
-    loginBootstrap.promise = loginPromise;
-    return loginPromise;
-  };
-  const loadPublishedSkillCatalog = async ({
-    directory,
-    useCache,
-    signal
-  }) => {
-    const workspaceResolution = await resolveWorkspace({
-      config,
-      directory
-    });
-    const directoryPath = workspaceResolution.directoryPath;
-    const preferenceContext = await resolvePublishedSkillPreferenceCacheContext(config);
-    const cacheKey = getCatalogCacheKey(workspaceResolution, preferenceContext);
-    const cached = cache.get(cacheKey);
-    if (useCache && cached && cached.expiresAt > Date.now()) {
-      return {
-        directoryPath,
-        workspaceResolution,
-        fetchResult: {
-          ...cached.result,
-          source: 'cache'
-        }
-      };
-    }
-    const inflight = catalogInflight.get(cacheKey);
-    if (inflight) {
-      return inflight;
-    }
-    const requestPromise = (async () => {
-      const fetchResult = await fetchPublishedSkillsCatalog(input.worktree, config, workspaceResolution, signal, clearPublishedSkillState);
-      await maybePersistWorkspaceSlugFromCatalog({
-        config,
-        resolution: workspaceResolution,
-        fetchResult
-      });
-      cache.set(cacheKey, {
-        result: fetchResult,
-        expiresAt: Date.now() + CACHE_TTL_MS
-      });
-      return {
-        directoryPath,
-        workspaceResolution,
-        fetchResult
-      };
-    })();
-    catalogInflight.set(cacheKey, requestPromise);
-    try {
-      return await requestPromise;
-    } finally {
-      catalogInflight.delete(cacheKey);
-    }
-  };
-  const loadPublishedSkillDetail = async ({
-    workspaceResolution,
-    item,
-    signal,
-    useCache,
-    purpose
-  }) => {
-    const directoryPath = workspaceResolution.directoryPath;
-    const preferenceContext = await resolvePublishedSkillPreferenceCacheContext(config);
-    const catalogCacheKey = getCatalogCacheKey(workspaceResolution, preferenceContext);
-    const cacheKey = getDetailCacheKey(catalogCacheKey, item.skillVersion.id);
-    const inflightKey = getDetailInflightKey(catalogCacheKey, item.skillVersion.id, purpose);
-    const cached = detailCache.get(cacheKey);
-    if (useCache && cached && cached.expiresAt > Date.now()) {
-      return {
-        ok: true,
-        detail: toPublishedSkillDetail({
-          ...item,
-          publishedArtifact: cached.artifact
-        })
-      };
-    }
-    const inflight = detailInflight.get(inflightKey);
-    if (inflight) {
-      return inflight;
-    }
-    const requestPromise = (async () => {
-      const detailResult = await fetchPublishedSkillDetail({
-        worktree: input.worktree,
-        config,
-        resolution: workspaceResolution,
-        skillVersionId: item.skillVersion.id,
-        signal,
-        onAuthStateChanged: clearPublishedSkillState,
-        purpose
-      });
-      if (!detailResult.ok) {
-        return {
-          ok: false,
-          status: detailResult.result.status,
-          output: JSON.stringify({
-            pluginId: PLUGIN_ID,
-            runtimeMode: 'tool_fetch_only',
-            status: detailResult.result.status,
-            requestedDirectoryPath: directoryPath,
-            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
-            requestedSkillVersionId: item.skillVersion.id,
-            message: detailResult.result.message,
-            fetchedAt: detailResult.result.fetchedAt,
-            source: detailResult.result.source
-          }, null, 2),
-          metadata: {
-            status: detailResult.result.status,
-            ...toWorkspaceResolutionMetadata(workspaceResolution),
-            source: detailResult.result.source
-          }
-        };
-      }
-      detailCache.set(cacheKey, {
-        artifact: detailResult.artifact,
-        expiresAt: Date.now() + CACHE_TTL_MS
-      });
-      return {
-        ok: true,
-        detail: toPublishedSkillDetail({
-          ...item,
-          publishedArtifact: detailResult.artifact
-        })
-      };
-    })();
-    detailInflight.set(inflightKey, requestPromise);
-    try {
-      return await requestPromise;
-    } finally {
-      detailInflight.delete(inflightKey);
-    }
-  };
-  const loadSystemNoteDetails = async ({
-    publishedSkillsResult,
-    signal
-  }) => {
-    if (!publishedSkillsResult.fetchResult.ok) return [];
-    const prioritizedItems = [...publishedSkillsResult.fetchResult.payload.skills].sort((left, right) => {
-      const leftSummary = toPublishedSkillSummary(left);
-      const rightSummary = toPublishedSkillSummary(right);
-      if (leftSummary.contextKind === rightSummary.contextKind) return formatSkillLabel(left).localeCompare(formatSkillLabel(right));
-      if (leftSummary.contextKind === 'global') return -1;
-      if (rightSummary.contextKind === 'global') return 1;
-      return 0;
-    });
-    const detailResults = await Promise.all(prioritizedItems.slice(0, SYSTEM_NOTE_DETAIL_LIMIT).map(item => loadPublishedSkillDetail({
-      workspaceResolution: publishedSkillsResult.workspaceResolution,
-      item,
-      signal,
-      useCache: true,
-      purpose: 'SYSTEM_CONTEXT'
-    })));
-    return detailResults.reduce((details, result) => {
-      if (!result.ok) return details;
-      details.push(result.detail);
-      return details;
-    }, []);
-  };
-  const executePublishedSkillsFetchTool = async ({
-    args,
-    context
-  }) => {
-    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
-    const requestedSkills = parseRequestedSkillArgs(args);
-    const fetchActionDirectoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
-    lastInteractiveDirectoryPath = fetchActionDirectoryPath;
-    const emitFetchOutcome = async event => {
-      await emitActionEventForCurrentSession({
-        event,
-        directoryPath: fetchActionDirectoryPath
-      });
-    };
-    let publishedSkillsResult = await loadPublishedSkillCatalog({
-      directory: requestedDirectory,
-      useCache: !args.refresh,
-      signal: context.abort
-    });
-    if (publishedSkillsResult.fetchResult.ok) {
-      await scheduleInteractivePresenceStart();
-    }
-    if (!publishedSkillsResult.fetchResult.ok && publishedSkillsResult.fetchResult.status === 'missing_auth') {
-      try {
-        await startLoginCompletion('fetch').then(async authState => {
-          await schedulePresenceStart(authState);
-        });
-        publishedSkillsResult = await loadPublishedSkillCatalog({
-          directory: requestedDirectory,
-          useCache: false,
-          signal: context.abort
-        });
-        if (publishedSkillsResult.fetchResult.ok) {
-          await scheduleInteractivePresenceStart();
-        }
-      } catch {
-        // Return the original fetch failure with the latest login bootstrap snapshot attached.
-      }
-    }
-    if (!publishedSkillsResult.fetchResult.ok) {
-      await emitFetchOutcome('FETCH_FAILED');
-      return toFetchFailureOutput({
-        worktree: input.worktree,
-        config,
-        publishedSkillsResult,
-        loginBootstrapSnapshot: loginBootstrap.snapshot
-      });
-    }
-    const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
-    if (!filteredPublishedSkillsResult.fetchResult.ok) {
-      await emitFetchOutcome('FETCH_FAILED');
-      return toFetchFailureOutput({
-        worktree: input.worktree,
-        config,
-        publishedSkillsResult: filteredPublishedSkillsResult,
-        loginBootstrapSnapshot: loginBootstrap.snapshot
-      });
-    }
-    const selection = selectPublishedSkills(filteredPublishedSkillsResult.fetchResult.payload, requestedSkills);
-    const isSingleRequest = requestedSkills.length === 1;
-    if (requestedSkills.length === 0) {
-      const catalog = toPublishedSkillCatalog(filteredPublishedSkillsResult.fetchResult.payload);
-      context.metadata({
-        title: `opencode-wizard published skills catalog: ${catalog.publishedSkillCount} active`,
-        metadata: {
-          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
-          status: 'ready',
-          publishedSkillCount: catalog.publishedSkillCount.toString(),
-          globalAssignmentCount: catalog.assignmentCounts.global.toString(),
-          projectAssignmentCount: catalog.assignmentCounts.project.toString(),
-          userAssignmentCount: catalog.assignmentCounts.user.toString(),
-          ignoredSkillCount: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length.toString()
-        }
-      });
-      await emitFetchOutcome('FETCH_SUCCESS');
-      return {
-        output: JSON.stringify({
-          ...catalog,
-          status: 'ready',
-          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
-          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
-          ignoredPublishedSkills: {
-            scopeKey: filteredPublishedSkillsResult.ignoreState.scopeKey,
-            count: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length
-          },
-          fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
-          source: filteredPublishedSkillsResult.fetchResult.source,
-          cacheTtlMs: CACHE_TTL_MS,
-          message: args.refresh ? 'Catalog discovery refreshed from the backend. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.' : 'Catalog discovery only. Cached results expire automatically after 30 seconds, or pass `refresh: true` to force a backend refresh immediately. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.'
-        }, null, 2),
-        metadata: {
-          status: 'ready',
-          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
-          source: filteredPublishedSkillsResult.fetchResult.source,
-          publishedSkillCount: catalog.publishedSkillCount.toString(),
-          globalAssignmentCount: catalog.assignmentCounts.global.toString(),
-          projectAssignmentCount: catalog.assignmentCounts.project.toString(),
-          userAssignmentCount: catalog.assignmentCounts.user.toString(),
-          ignoredSkillCount: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length.toString()
-        }
-      };
-    }
-    if (selection.selectedItems.length === 0 && isSingleRequest) {
-      await emitFetchOutcome('FETCH_FAILED');
-      return {
-        output: JSON.stringify({
-          pluginId: PLUGIN_ID,
-          runtimeMode: 'tool_fetch_only',
-          status: 'not_found',
-          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
-          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
-          requestedSkill: requestedSkills[0],
-          availableSkills: filteredPublishedSkillsResult.fetchResult.payload.skills.map(toPublishedSkillSummary),
-          ignoredPublishedSkills: {
-            scopeKey: filteredPublishedSkillsResult.ignoreState.scopeKey,
-            count: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length
-          }
-        }, null, 2),
-        metadata: {
-          status: 'not_found',
-          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution)
-        }
-      };
-    }
-    let skillDetailResults = await Promise.all(selection.selectedItems.map(item => loadPublishedSkillDetail({
-      workspaceResolution: filteredPublishedSkillsResult.workspaceResolution,
-      item,
-      signal: context.abort,
-      useCache: !args.refresh,
-      purpose: 'TOOL_FETCH'
-    })));
-    if (skillDetailResults.some(result => !result.ok && result.status === 'missing_auth')) {
-      try {
-        await startLoginCompletion('fetch').then(async authState => {
-          await schedulePresenceStart(authState);
-        });
-        skillDetailResults = await Promise.all(selection.selectedItems.map(item => loadPublishedSkillDetail({
-          workspaceResolution: filteredPublishedSkillsResult.workspaceResolution,
-          item,
-          signal: context.abort,
-          useCache: false,
-          purpose: 'TOOL_FETCH'
-        })));
-      } catch {
-        // Return the original detail failure after the login bootstrap attempt updates snapshot state.
-      }
-    }
-    const failedSkillDetail = skillDetailResults.find(result => !result.ok);
-    if (failedSkillDetail && !failedSkillDetail.ok) {
-      await emitFetchOutcome('FETCH_FAILED');
-      return failedSkillDetail;
-    }
-    const skillDetails = skillDetailResults.map(result => {
-      if (!result.ok) {
-        throw new Error('Published skill detail result unexpectedly missing after success guard.');
-      }
-      return result.detail;
-    });
-    if (isSingleRequest && skillDetails[0]) {
-      const detail = skillDetails[0];
-      context.metadata({
-        title: `opencode-wizard published skill: ${detail.artifactName || detail.skillName}`,
-        metadata: {
-          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
-          skillSlug: detail.skillSlug,
-          version: detail.version
-        }
-      });
-      await emitFetchOutcome('FETCH_SUCCESS');
-      return {
-        output: JSON.stringify({
-          pluginId: PLUGIN_ID,
-          runtimeMode: 'tool_fetch_only',
-          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
-          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
-          workspace: filteredPublishedSkillsResult.fetchResult.payload.workspace,
-          fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
-          source: filteredPublishedSkillsResult.fetchResult.source,
-          skill: detail
-        }, null, 2),
-        metadata: {
-          status: 'ready',
-          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
-          source: filteredPublishedSkillsResult.fetchResult.source,
-          skillSlug: detail.skillSlug
-        }
-      };
-    }
-    context.metadata({
-      title: `opencode-wizard published skills fetch: ${skillDetails.length}`,
-      metadata: {
-        ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
-        requestedCount: requestedSkills.length.toString(),
-        matchedCount: skillDetails.length.toString()
-      }
-    });
-    await emitFetchOutcome('FETCH_SUCCESS');
-    return {
-      output: JSON.stringify({
-        pluginId: PLUGIN_ID,
-        runtimeMode: 'tool_fetch_only',
-        requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
-        workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
-        workspace: filteredPublishedSkillsResult.fetchResult.payload.workspace,
-        fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
-        source: filteredPublishedSkillsResult.fetchResult.source,
-        requestedSkills,
-        missingSkills: selection.missingIdentifiers,
-        skills: skillDetails
-      }, null, 2),
-      metadata: {
-        status: selection.missingIdentifiers.length > 0 ? 'partial' : 'ready',
-        ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
-        source: filteredPublishedSkillsResult.fetchResult.source,
-        matchedCount: skillDetails.length.toString()
-      }
-    };
-  };
-  const executeStatusTool = async ({
-    args,
-    context
-  }) => {
-    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
-    let snapshot = await resolvePluginStatusSnapshot({
-      worktree: input.worktree,
-      directory: requestedDirectory,
-      signal: context.abort
-    });
-    if (snapshot.status === 'missing_auth') {
-      try {
-        await startLoginCompletion('status').then(async authState => {
-          await schedulePresenceStart(authState);
-        });
-        snapshot = await resolvePluginStatusSnapshot({
-          worktree: input.worktree,
-          directory: requestedDirectory,
-          signal: context.abort
-        });
-      } catch {
-        // Keep returning the safe missing-auth snapshot when interactive login is cancelled or fails.
-      }
-    }
-    if (snapshot.status === 'ready') {
-      await scheduleInteractivePresenceStart();
-    }
-    const metadata = toPluginStatusMetadata(snapshot);
-    context.metadata({
-      title: `opencode-wizard status: ${snapshot.status} / auth ${snapshot.authState.status}`,
-      metadata
-    });
-    return {
-      output: JSON.stringify(toAiFacingPluginStatusSnapshot(snapshot), null, 2),
-      metadata
-    };
-  };
-  const executePublishedSkillPreferenceTool = async ({
-    args,
-    context
-  }) => {
-    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
-    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
-    lastInteractiveDirectoryPath = directoryPath;
-    const requestedSkill = typeof args.skill === 'string' ? args.skill.trim() : '';
-    const emitPreferenceOutcome = async event => {
-      await emitActionEventForCurrentSession({
-        event,
-        directoryPath
-      });
-    };
-    try {
-      if (!requestedSkill) {
-        throw new Error('Published skill preference tool requires a non-empty skill slug, artifact name, or skill name.');
-      }
-      if (typeof args.action !== 'string') {
-        throw new Error('Published skill preference tool requires an action: install, uninstall, ignore, or unignore.');
-      }
-      const action = toPublishedSkillPreferenceAction(args.action);
-      const catalogResult = await loadPublishedSkillCatalog({
-        directory: requestedDirectory,
-        useCache: true,
-        signal: context.abort
-      });
-      if (!catalogResult.fetchResult.ok) {
-        throw new Error(`Cannot resolve published skill preference target: ${catalogResult.fetchResult.message}`);
-      }
-      const selectableCatalogSkills = catalogResult.fetchResult.payload.catalogSkills.map(item => ({
-        ...item,
-        assignmentSource: 'CATALOG',
-        assignmentType: 'PATH',
-        scopePath: '',
-        includeChildren: true
-      }));
-      const preferenceSelection = selectPublishedSkills({
-        ...catalogResult.fetchResult.payload,
-        skills: [...catalogResult.fetchResult.payload.skills, ...selectableCatalogSkills, ...catalogResult.fetchResult.payload.userPreferences.ignoredSkills]
-      }, [requestedSkill]);
-      const matchedSkill = preferenceSelection.selectedItems[0];
-      if (!matchedSkill) {
-        throw new Error(`Published skill preference target was not found for identifier: ${requestedSkill}.`);
-      }
-      const skillSlug = matchedSkill.skill.slug;
-      const preferenceState = action === 'ignore' || action === 'unignore' ? await setPublishedSkillIgnored({
-        worktree: input.worktree,
-        directory: requestedDirectory,
-        skillSlug,
-        ignored: action === 'ignore',
-        preferenceScope: toPublishedSkillPreferenceScope(args.preferenceScope, 'project')
-      }) : await setPublishedSkillInstalled({
-        worktree: input.worktree,
-        directory: requestedDirectory,
-        skillSlug,
-        installed: action === 'install',
-        preferenceScope: toPublishedSkillPreferenceScope(args.preferenceScope, 'project')
-      });
-      await scheduleInteractivePresenceStart();
-      await emitPreferenceOutcome('PREFERENCE_SUCCESS');
-      const metadata = {
-        status: 'updated',
-        skillSlug,
-        action,
-        directoryPath,
-        ignoredSkillCount: preferenceState.ignoredSkillSlugs.length.toString()
-      };
-      context.metadata({
-        title: `opencode-wizard published skill preference: ${action} ${skillSlug}`,
-        metadata
-      });
-      return {
-        output: JSON.stringify({
-          pluginId: PLUGIN_ID,
-          status: 'updated',
-          requestedIdentifier: requestedSkill,
-          skillSlug,
-          action,
-          requestedDirectoryPath: directoryPath,
-          preferenceState,
-          message: 'Published skill preference updated through the shared server-backed API; TUI views will reflect this after refresh.'
-        }, null, 2),
-        metadata
-      };
-    } catch (error) {
-      await emitPreferenceOutcome('PREFERENCE_FAILED');
-      throw error;
-    }
-  };
-  return {
-    tool: {
-      opencode_wizard_published_skills_fetch: tool({
-        description: 'Fetch one or multiple wizard-published skill bodies/details for the current scope. Use this for wizard-listed/private/scoped/backend-published skill slugs instead of the native OpenCode skill tool, and after native errors like `Skill "..." not found`; prefer `skills` for multiple identifiers and call with no args to discover the catalog and bootstrap auth when needed',
-        args: {
-          skill: tool.schema.string().optional().describe('Single skill slug, artifact name, or skill name; backward-compatible with comma/newline-delimited lists'),
-          skills: tool.schema.string().optional().describe('One or more comma-separated or newline-separated skill slugs, artifact names, or skill names'),
-          directory: tool.schema.string().optional().describe('Optional absolute or relative directory override'),
-          refresh: tool.schema.boolean().optional().describe('Bypass the local plugin cache for this request')
-        },
-        async execute(args, context) {
-          return executePublishedSkillsFetchTool({
-            args,
-            context
-          });
-        }
-      }),
-      opencode_wizard_published_skill_preference_set: tool({
-        description: 'Install, uninstall, ignore, or unignore a backend-published wizard skill for non-TUI workflows using the same shared server-backed preference API as the TUI overlay',
-        args: {
-          skill: tool.schema.string().describe('Published skill slug, artifact name, or skill name to update'),
-          action: tool.schema.string().describe('Preference action: install, uninstall, ignore, or unignore'),
-          preferenceScope: tool.schema.string().optional().describe('Preference scope for the action: project or global; defaults to project'),
-          directory: tool.schema.string().optional().describe('Optional absolute or relative directory override')
-        },
-        async execute(args, context) {
-          return executePublishedSkillPreferenceTool({
-            args,
-            context
-          });
-        }
-      }),
-      opencode_wizard_status: tool({
-        description: 'Report opencode-wizard plugin status, bootstrap auth when missing, and return a safe auth summary without exposing tokens',
-        args: {
-          directory: tool.schema.string().optional().describe('Optional absolute or relative directory override')
-        },
-        async execute(args, context) {
-          return executeStatusTool({
-            args,
-            context
-          });
-        }
-      })
-    },
-    'experimental.chat.system.transform': async (_hookInput, output) => {
-      let publishedSkillsResult = await loadPublishedSkillCatalog({
-        directory: input.directory,
-        useCache: true,
-        signal: AbortSignal.timeout(5_000)
-      });
-      if (!publishedSkillsResult.fetchResult.ok && publishedSkillsResult.fetchResult.status === 'missing_auth') {
-        try {
-          await startLoginCompletion('status').then(async authState => {
-            await schedulePresenceStart(authState);
-          });
-          publishedSkillsResult = await loadPublishedSkillCatalog({
-            directory: input.directory,
-            useCache: false,
-            signal: AbortSignal.timeout(5_000)
-          });
-        } catch {
-          const loginMessage = loginBootstrap.snapshot.message ? ` Last login status: ${loginBootstrap.snapshot.message}` : '';
-          output.system.push(`opencode-wizard plugin stored auth is missing, expired, or rejected. Startup browser login was started but did not complete successfully.${loginMessage} Use opencode_wizard_status or opencode_wizard_published_skills_fetch to retry authentication when published skills are needed. No tokens are exposed.`);
-          return;
-        }
-        if (!publishedSkillsResult.fetchResult.ok) {
-          output.system.push(`opencode-wizard plugin startup login completed, but published skills are still unavailable: ${publishedSkillsResult.fetchResult.message} No tokens are exposed.`);
-          return;
-        }
-      }
-      if (publishedSkillsResult.fetchResult.ok) {
-        await scheduleInteractivePresenceStart();
-      }
-      const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
-      const details = await loadSystemNoteDetails({
-        publishedSkillsResult: filteredPublishedSkillsResult,
-        signal: AbortSignal.timeout(5_000)
-      });
-      const systemNote = buildSystemNote(filteredPublishedSkillsResult, config, details);
-      if (!systemNote) return;
-      output.system.push(systemNote);
-    }
-  };
-};
+export { AVAILABLE_PUBLISHED_SKILL_TOOLS, resolveAvailableTools } from './plugin-tools.js';
+export { buildSkillMarkdown, parseRequestedSkillArgs, selectPublishedSkills, toPublishedSkillDetail } from './published-skills-transform.js';
+export { PLUGIN_ID, NATIVE_SKILLS_URL_COMPATIBILITY, buildSystemNote, resolveConfig, resolvePluginStatusSnapshot, resolvePluginStatusSnapshotWithAuthBootstrap, setPublishedSkillIgnored, setPublishedSkillInstalled, toPluginAuthStateSummary, toPublishedSkillCatalog } from './server/runtime.js';
+import { PLUGIN_ID, OpencodeWizardSkillsPlugin } from './server/runtime.js';
 export default {
   id: PLUGIN_ID,
   server: OpencodeWizardSkillsPlugin