@aexol/opencode-wizard 0.3.3 → 0.3.5

package/dist/server/runtime.js

@@ -0,0 +1,1315 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { CREATE_OR_UPDATE_SKILL_FROM_MARKDOWN_MUTATION, SET_WIZARD_ARTIFACT_PREFERENCE_MUTATION } from '../graphql-operations.js';
+import { createPublishedSkillToolDefinitions, resolveAvailableTools } from '../plugin-tools.js';
+import { resolveStoredAuthState, toAuthState, writeAuthState } from './auth-store.js';
+import { resolveConfig } from './config.js';
+export { resolveConfig } from './config.js';
+import { createPluginSession, openBrowser, startLoginFlow } from './auth-flow.js';
+import { fetchPublishedSkillDetail, fetchPublishedSkillsCatalog, fetchPublishedSkillsGraphQl, fetchWizardArtifactDetail, fetchWizardArtifactsCatalog, maybePersistWorkspaceSlugFromCatalog } from './client.js';
+import { normalizeAbsolutePath } from './path-utils.js';
+import { emitPluginActionEvent, emitPresenceEvent } from './presence.js';
+import { normalizeDirectoryArg, normalizeRepositoryPath, resolveWorkspace, toWorkspaceResolutionMetadata, toWorkspaceResolutionOutput } from './workspace.js';
+import { parseRequestedSkillArgs, selectPublishedSkills, toPublishedSkillDetail, toPublishedSkillSummary, toWizardArtifactCatalog, toWizardArtifactDetail, toWizardArtifactSummary } from '../published-skills-transform.js';
+import { CACHE_TTL_MS, LOGIN_TIMEOUT_MS, OIDC_CALLBACK_URL, PLUGIN_ID, PRESENCE_SHUTDOWN_SIGNALS, PRESENCE_SIGNAL_EXIT_CODES } from './constants.js';
+export { PLUGIN_ID, NATIVE_SKILLS_URL_COMPATIBILITY } from './constants.js';
+import { buildSystemNote, filterIgnoredPublishedSkills, resolvePluginStatusSnapshot, toAiFacingPluginStatusSnapshot, toFetchFailureOutput, toPluginStatusMetadata, toPublishedSkillCatalog } from './status.js';
+import { createIdleLoginBootstrapSnapshot } from './auth-bootstrap.js';
+import { getCatalogCacheKey, resolvePublishedSkillPreferenceCacheContext, setPublishedSkillIgnored, setPublishedSkillInstalled, toPublishedSkillPreferenceAction, toPublishedSkillPreferenceScope } from './preferences.js';
+export { buildSystemNote, resolvePluginStatusSnapshot, toPluginAuthStateSummary, toPublishedSkillCatalog } from './status.js';
+const importOpencodePluginModule = new Function('specifier', 'return import(specifier)');
+export { resolvePluginStatusSnapshotWithAuthBootstrap } from './auth-bootstrap.js';
+export { setPublishedSkillIgnored, setPublishedSkillInstalled } from './preferences.js';
+const getDetailCacheKey = (catalogCacheKey, skillVersionId) => {
+  return JSON.stringify([catalogCacheKey, skillVersionId]);
+};
+const getDetailInflightKey = (catalogCacheKey, skillVersionId, purpose) => {
+  return JSON.stringify([catalogCacheKey, skillVersionId, purpose]);
+};
+const SUPPORTED_WIZARD_ARTIFACT_KINDS = ['SKILL', 'DESIGN_DOC'];
+const DESIGN_DOC_UNSUPPORTED_MESSAGE = 'DESIGN_DOC is supported by generic wizard artifact persistence; use catalog/detail tools for assigned or installed documents.';
+const toWizardArtifactKind = value => {
+  if (!value) return 'SKILL';
+  const normalized = value.trim().toUpperCase().replace(/[-\s]+/gu, '_');
+  if (normalized === 'SKILL') return 'SKILL';
+  if (normalized === 'DESIGN_DOC') return 'DESIGN_DOC';
+  return null;
+};
+const buildUnsupportedWizardArtifactOutput = ({
+  artifactKind,
+  directoryPath
+}) => ({
+  output: JSON.stringify({
+    pluginId: PLUGIN_ID,
+    runtimeMode: 'tool_fetch_only',
+    status: artifactKind === 'DESIGN_DOC' ? 'unsupported' : 'bad_artifact_kind',
+    artifactKind,
+    supportedArtifactKinds: SUPPORTED_WIZARD_ARTIFACT_KINDS,
+    requestedDirectoryPath: directoryPath,
+    message: artifactKind === 'DESIGN_DOC' ? DESIGN_DOC_UNSUPPORTED_MESSAGE : 'Unsupported wizard artifact kind. Use SKILL or DESIGN_DOC.'
+  }, null, 2),
+  metadata: {
+    status: artifactKind === 'DESIGN_DOC' ? 'unsupported' : 'bad_artifact_kind',
+    artifactKind,
+    directoryPath
+  }
+});
+const withWizardArtifactEnvelope = (result, artifactKind) => {
+  if (!result || typeof result !== 'object' || !('output' in result)) return result;
+  const outputResult = result;
+  if (typeof outputResult.output !== 'string') return result;
+  try {
+    return {
+      ...outputResult,
+      output: JSON.stringify({
+        ...JSON.parse(outputResult.output),
+        artifactKind,
+        supportedArtifactKinds: SUPPORTED_WIZARD_ARTIFACT_KINDS,
+        compatibilityAliases: ['opencode_wizard_published_skills_fetch', 'opencode_wizard_published_skill_preference_set']
+      }, null, 2),
+      metadata: {
+        ...(outputResult.metadata ?? {}),
+        artifactKind
+      }
+    };
+  } catch {
+    return result;
+  }
+};
+const matchesWizardArtifactIdentifier = (item, identifier) => {
+  const normalizedIdentifier = identifier.trim().toLowerCase();
+  if (!normalizedIdentifier) return false;
+  if (item.artifact.slug.toLowerCase() === normalizedIdentifier) return true;
+  if (item.artifact.name.toLowerCase() === normalizedIdentifier) return true;
+  if (item.artifactVersion.frontmatterName.toLowerCase() === normalizedIdentifier) return true;
+  return item.artifactVersion.id.toLowerCase() === normalizedIdentifier;
+};
+const selectWizardArtifacts = (items, identifiers) => {
+  const selectedItems = items.filter(item => identifiers.some(identifier => matchesWizardArtifactIdentifier(item, identifier)));
+  const missingIdentifiers = identifiers.filter(identifier => !selectedItems.some(item => matchesWizardArtifactIdentifier(item, identifier)));
+  return {
+    selectedItems,
+    missingIdentifiers
+  };
+};
+export 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 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 authState = await resolveStoredAuthState(input.worktree, config);
+      const catalog = {
+        ...toPublishedSkillCatalog(filteredPublishedSkillsResult.fetchResult.payload),
+        availableTools: resolveAvailableTools(authState?.role ?? null)
+      };
+      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 executeWizardArtifactCatalogTool = async ({
+    args,
+    context
+  }) => {
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    const artifactKind = toWizardArtifactKind(args.artifactKind);
+    if (!artifactKind) {
+      return buildUnsupportedWizardArtifactOutput({
+        artifactKind: args.artifactKind ?? '',
+        directoryPath
+      });
+    }
+    if (artifactKind === 'DESIGN_DOC') {
+      const workspaceResolution = await resolveWorkspace({
+        config,
+        directory: requestedDirectory
+      });
+      const fetchResult = await fetchWizardArtifactsCatalog(input.worktree, config, workspaceResolution, artifactKind, context.abort, clearPublishedSkillState);
+      if (!fetchResult.ok) {
+        return {
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            runtimeMode: 'tool_fetch_only',
+            status: fetchResult.status,
+            artifactKind,
+            requestedDirectoryPath: directoryPath,
+            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+            message: fetchResult.message,
+            fetchedAt: fetchResult.fetchedAt,
+            source: fetchResult.source
+          }, null, 2),
+          metadata: {
+            status: fetchResult.status,
+            artifactKind,
+            directoryPath,
+            source: fetchResult.source
+          }
+        };
+      }
+      const authState = await resolveStoredAuthState(input.worktree, config);
+      const catalog = toWizardArtifactCatalog(fetchResult.payload, {
+        pluginId: PLUGIN_ID,
+        availableTools: resolveAvailableTools(authState?.role ?? null)
+      });
+      return {
+        output: JSON.stringify({
+          ...catalog,
+          status: 'ready',
+          requestedDirectoryPath: directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+          fetchedAt: fetchResult.fetchedAt,
+          source: fetchResult.source,
+          message: 'DESIGN_DOC catalog discovery only. Full DESIGN.md bodies/files require opencode_wizard_artifact_fetch with artifactKind DESIGN_DOC.'
+        }, null, 2),
+        metadata: {
+          status: 'ready',
+          artifactKind,
+          artifactCount: catalog.artifactCount.toString(),
+          ...toWorkspaceResolutionMetadata(workspaceResolution),
+          source: fetchResult.source
+        }
+      };
+    }
+    const result = await executePublishedSkillsFetchTool({
+      args: {
+        directory: args.directory,
+        refresh: args.refresh
+      },
+      context
+    });
+    return withWizardArtifactEnvelope(result, artifactKind);
+  };
+  const executeWizardArtifactFetchTool = async ({
+    args,
+    context
+  }) => {
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    const artifactKind = toWizardArtifactKind(args.artifactKind);
+    if (!artifactKind) {
+      return buildUnsupportedWizardArtifactOutput({
+        artifactKind: args.artifactKind ?? '',
+        directoryPath
+      });
+    }
+    if (artifactKind === 'DESIGN_DOC') {
+      const requestedArtifacts = parseRequestedSkillArgs({
+        skill: args.artifact,
+        skills: args.artifacts
+      });
+      const workspaceResolution = await resolveWorkspace({
+        config,
+        directory: requestedDirectory
+      });
+      const fetchResult = await fetchWizardArtifactsCatalog(input.worktree, config, workspaceResolution, artifactKind, context.abort, clearPublishedSkillState);
+      if (!fetchResult.ok) {
+        return {
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            runtimeMode: 'tool_fetch_only',
+            status: fetchResult.status,
+            artifactKind,
+            requestedDirectoryPath: directoryPath,
+            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+            message: fetchResult.message,
+            fetchedAt: fetchResult.fetchedAt,
+            source: fetchResult.source
+          }, null, 2),
+          metadata: {
+            status: fetchResult.status,
+            artifactKind,
+            directoryPath,
+            source: fetchResult.source
+          }
+        };
+      }
+      const selection = selectWizardArtifacts(fetchResult.payload.artifacts, requestedArtifacts);
+      if (requestedArtifacts.length === 0) {
+        const authState = await resolveStoredAuthState(input.worktree, config);
+        const catalog = toWizardArtifactCatalog(fetchResult.payload, {
+          pluginId: PLUGIN_ID,
+          availableTools: resolveAvailableTools(authState?.role ?? null)
+        });
+        return {
+          output: JSON.stringify({
+            ...catalog,
+            status: 'ready',
+            requestedDirectoryPath: directoryPath,
+            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+            fetchedAt: fetchResult.fetchedAt,
+            source: fetchResult.source,
+            message: 'Provide artifact or artifacts to fetch DESIGN.md body/files.'
+          }, null, 2),
+          metadata: {
+            status: 'ready',
+            artifactKind,
+            ...toWorkspaceResolutionMetadata(workspaceResolution)
+          }
+        };
+      }
+      if (selection.selectedItems.length === 0 && requestedArtifacts.length === 1) {
+        return {
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            runtimeMode: 'tool_fetch_only',
+            status: 'not_found',
+            artifactKind,
+            requestedArtifact: requestedArtifacts[0],
+            availableArtifacts: fetchResult.payload.artifacts.map(toWizardArtifactSummary),
+            requestedDirectoryPath: directoryPath,
+            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution)
+          }, null, 2),
+          metadata: {
+            status: 'not_found',
+            artifactKind,
+            ...toWorkspaceResolutionMetadata(workspaceResolution)
+          }
+        };
+      }
+      const detailResults = await Promise.all(selection.selectedItems.map(item => fetchWizardArtifactDetail({
+        worktree: input.worktree,
+        config,
+        resolution: workspaceResolution,
+        artifactKind,
+        artifactVersionId: item.artifactVersion.id,
+        signal: context.abort,
+        onAuthStateChanged: clearPublishedSkillState,
+        purpose: 'TOOL_FETCH'
+      })));
+      const failedDetail = detailResults.find(result => !result.ok);
+      if (failedDetail && !failedDetail.ok) {
+        return {
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            runtimeMode: 'tool_fetch_only',
+            status: failedDetail.result.status,
+            artifactKind,
+            requestedDirectoryPath: directoryPath,
+            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+            message: failedDetail.result.message,
+            fetchedAt: failedDetail.result.fetchedAt,
+            source: failedDetail.result.source
+          }, null, 2),
+          metadata: {
+            status: failedDetail.result.status,
+            artifactKind,
+            ...toWorkspaceResolutionMetadata(workspaceResolution)
+          }
+        };
+      }
+      const details = detailResults.map((result, index) => {
+        if (!result.ok) throw new Error('Wizard artifact detail result unexpectedly missing after success guard.');
+        return toWizardArtifactDetail({
+          ...selection.selectedItems[index],
+          artifactVersion: result.artifact
+        });
+      });
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          runtimeMode: 'tool_fetch_only',
+          artifactKind,
+          requestedDirectoryPath: directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+          workspace: fetchResult.payload.workspace,
+          fetchedAt: fetchResult.fetchedAt,
+          source: fetchResult.source,
+          requestedArtifacts,
+          missingArtifacts: selection.missingIdentifiers,
+          artifacts: details
+        }, null, 2),
+        metadata: {
+          status: selection.missingIdentifiers.length > 0 ? 'partial' : 'ready',
+          artifactKind,
+          matchedCount: details.length.toString(),
+          ...toWorkspaceResolutionMetadata(workspaceResolution)
+        }
+      };
+    }
+    const result = await executePublishedSkillsFetchTool({
+      args: {
+        skill: args.artifact,
+        skills: args.artifacts,
+        directory: args.directory,
+        refresh: args.refresh
+      },
+      context
+    });
+    return withWizardArtifactEnvelope(result, artifactKind);
+  };
+  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) {
+        await emitPreferenceOutcome('PREFERENCE_FAILED');
+        return toFetchFailureOutput({
+          worktree: input.worktree,
+          config,
+          publishedSkillsResult: catalogResult,
+          loginBootstrapSnapshot: loginBootstrap.snapshot
+        });
+      }
+      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');
+      const message = error instanceof Error ? error.message : 'Unknown published skill preference failure.';
+      const metadata = {
+        status: 'preference_failed',
+        directoryPath
+      };
+      context.metadata({
+        title: 'opencode-wizard published skill preference failed',
+        metadata
+      });
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'preference_failed',
+          requestedIdentifier: requestedSkill,
+          requestedDirectoryPath: directoryPath,
+          message,
+          guidance: 'The preference tool remains available. Check opencode_wizard_status for safe auth/catalog state, rerun fetch/status to bootstrap auth, and retry after catalog status is ready.'
+        }, null, 2),
+        metadata
+      };
+    }
+  };
+  const executeWizardArtifactPreferenceTool = async ({
+    args,
+    context
+  }) => {
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    const artifactKind = toWizardArtifactKind(args.artifactKind);
+    if (!artifactKind) {
+      return buildUnsupportedWizardArtifactOutput({
+        artifactKind: args.artifactKind ?? '',
+        directoryPath
+      });
+    }
+    if (artifactKind === 'DESIGN_DOC') {
+      try {
+        const action = toPublishedSkillPreferenceAction(args.action);
+        const workspaceResolution = await resolveWorkspace({
+          config,
+          directory: requestedDirectory
+        });
+        const response = await fetchPublishedSkillsGraphQl({
+          worktree: input.worktree,
+          config,
+          query: SET_WIZARD_ARTIFACT_PREFERENCE_MUTATION,
+          variables: {
+            input: {
+              workspaceSlug: workspaceResolution.workspaceSlug,
+              repositoryUrl: workspaceResolution.repositoryUrl,
+              directoryPath: workspaceResolution.directoryPath,
+              artifactKind,
+              artifactSlug: args.artifact.trim(),
+              preferenceScope: toPublishedSkillPreferenceScope(args.preferenceScope, 'project') === 'global' ? 'GLOBAL' : 'WORKSPACE',
+              installed: action === 'install' ? true : action === 'uninstall' ? false : undefined,
+              ignored: action === 'ignore' ? true : action === 'unignore' ? false : undefined
+            }
+          },
+          signal: context.abort,
+          onAuthStateChanged: clearPublishedSkillState
+        });
+        if (!response.ok) {
+          return {
+            output: JSON.stringify({
+              pluginId: PLUGIN_ID,
+              status: response.result.status,
+              artifactKind,
+              requestedIdentifier: args.artifact,
+              requestedDirectoryPath: directoryPath,
+              message: response.result.message,
+              fetchedAt: response.result.fetchedAt,
+              source: response.result.source
+            }, null, 2),
+            metadata: {
+              status: response.result.status,
+              artifactKind,
+              directoryPath
+            }
+          };
+        }
+        return {
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            status: 'updated',
+            artifactKind,
+            requestedIdentifier: args.artifact,
+            action,
+            requestedDirectoryPath: directoryPath,
+            preferenceState: response.data.setWizardArtifactPreference,
+            message: 'Wizard artifact preference updated through the generic backend API.'
+          }, null, 2),
+          metadata: {
+            status: 'updated',
+            artifactKind,
+            directoryPath,
+            action
+          }
+        };
+      } catch (error) {
+        return {
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            status: 'preference_failed',
+            artifactKind,
+            requestedIdentifier: args.artifact,
+            requestedDirectoryPath: directoryPath,
+            message: error instanceof Error ? error.message : 'Unknown wizard artifact preference failure.'
+          }, null, 2),
+          metadata: {
+            status: 'preference_failed',
+            artifactKind,
+            directoryPath
+          }
+        };
+      }
+    }
+    const result = await executePublishedSkillPreferenceTool({
+      args: {
+        skill: args.artifact,
+        action: args.action,
+        preferenceScope: args.preferenceScope,
+        directory: args.directory
+      },
+      context
+    });
+    return withWizardArtifactEnvelope(result, artifactKind);
+  };
+  const executeEditorPublishSkillTool = async ({
+    args,
+    context
+  }) => {
+    const requestedSkillSlug = args.skillSlug.trim();
+    if (!requestedSkillSlug) {
+      throw new Error('Editor publish requires a non-empty skill slug.');
+    }
+    const authState = await resolveStoredAuthState(input.worktree, config);
+    if (!authState || authState.role !== 'EDITOR') {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'forbidden',
+          skillSlug: requestedSkillSlug,
+          message: 'This tool requires EDITOR role. Your current session does not have the required editor permission.'
+        }, null, 2),
+        metadata: {
+          status: 'forbidden',
+          role: authState?.role ?? 'none'
+        }
+      };
+    }
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    lastInteractiveDirectoryPath = directoryPath;
+    const workspaceResolution = await resolveWorkspace({
+      config,
+      directory: requestedDirectory
+    });
+    const repositoryRoot = workspaceResolution.repositoryRoot;
+    const skillFilePath = path.resolve(repositoryRoot, config.rootSkillSeedPath, requestedSkillSlug, 'SKILL.md');
+    let markdownContent;
+    try {
+      markdownContent = await fs.readFile(skillFilePath, 'utf8');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'file_not_found',
+          skillSlug: requestedSkillSlug,
+          skillFilePath,
+          message: `Skill markdown file not found at ${skillFilePath}: ${message}`
+        }, null, 2),
+        metadata: {
+          status: 'file_not_found',
+          skillSlug: requestedSkillSlug,
+          directoryPath
+        }
+      };
+    }
+    const response = await fetchPublishedSkillsGraphQl({
+      worktree: input.worktree,
+      config,
+      query: CREATE_OR_UPDATE_SKILL_FROM_MARKDOWN_MUTATION,
+      variables: {
+        markdownContent
+      },
+      signal: context.abort
+    });
+    if (!response.ok) {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'request_failed',
+          skillSlug: requestedSkillSlug,
+          message: response.result.message
+        }, null, 2),
+        metadata: {
+          status: 'request_failed',
+          skillSlug: requestedSkillSlug,
+          directoryPath
+        }
+      };
+    }
+    const payload = response.data.createOrUpdateSkillFromMarkdown;
+    await scheduleInteractivePresenceStart();
+    return {
+      output: JSON.stringify({
+        pluginId: PLUGIN_ID,
+        status: payload.success ? 'published' : 'publish_failed',
+        skillSlug: payload.skillSlug,
+        skillVersionId: payload.skillVersionId,
+        errors: payload.errors
+      }, null, 2),
+      metadata: {
+        status: payload.success ? 'published' : 'publish_failed',
+        skillSlug: payload.skillSlug,
+        skillVersionId: payload.skillVersionId ?? '',
+        directoryPath
+      }
+    };
+  };
+  const role = initialAuthState?.role ?? null;
+  const isEditor = role === 'EDITOR';
+  const {
+    sharedTools,
+    editorOnlyTools
+  } = createPublishedSkillToolDefinitions(tool, {
+    fetchPublishedSkills: (args, context) => executePublishedSkillsFetchTool({
+      args,
+      context
+    }),
+    fetchWizardArtifactCatalog: (args, context) => executeWizardArtifactCatalogTool({
+      args,
+      context
+    }),
+    fetchWizardArtifacts: (args, context) => executeWizardArtifactFetchTool({
+      args,
+      context
+    }),
+    updatePublishedSkillPreference: (args, context) => executePublishedSkillPreferenceTool({
+      args,
+      context
+    }),
+    updateWizardArtifactPreference: (args, context) => executeWizardArtifactPreferenceTool({
+      args,
+      context
+    }),
+    getStatus: (args, context) => executeStatusTool({
+      args,
+      context
+    }),
+    publishEditorSkill: (args, context) => executeEditorPublishSkillTool({
+      args,
+      context
+    })
+  });
+  return {
+    tool: {
+      ...sharedTools,
+      ...(isEditor ? editorOnlyTools : {})
+    },
+    '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 systemNote = buildSystemNote(filteredPublishedSkillsResult, config, []);
+      if (!systemNote) return;
+      output.system.push(systemNote);
+    }
+  };
+};
+export default {
+  id: PLUGIN_ID,
+  server: OpencodeWizardSkillsPlugin
+};
+//# sourceMappingURL=runtime.js.map