@aexol/opencode-wizard 0.3.1 → 0.3.3

package/README.md

@@ -50,7 +50,13 @@ Catalog discovery uses the backend-issued plugin session token stored at `~/.con
 
 Call `opencode_wizard_published_skills_fetch` without `skill` or `skills` to manually bootstrap plugin login if needed and return catalog-only discovery output for the current directory scope.
 
-No-arg discovery returns published skill summaries, assignment counts split into `global` and `project`, policy metadata, and no markdown bodies. Existing `skill` and `skills` calls still fetch one or more full skill body/detail payloads by slug, artifact name, or skill name.
+No-arg discovery returns published skill summaries, assignment counts split into `global`, `project`, `user`, and `other`, policy metadata, and no markdown bodies. Existing `skill` and `skills` calls still fetch one or more full skill body/detail payloads by slug, artifact name, or skill name.
+
+Workspace delivery still follows the backend contract: the plugin sends `workspaceSlug` when it has one, otherwise falls back to `repositoryUrl`. The plugin now prefers configured or learned workspace slug mappings over a repo-basename fallback, and learns durable slug-to-repo mappings from successful backend catalog responses so worktrees and nontrivial repo roots stay aligned.
+
+Published skill fetches still support `refresh: true`, but normal cache entries now self-expire after 30 seconds and fetch/status payloads surface `source`, `workspaceSlug`, and `workspaceSlugSource` so stale-vs-refreshed behavior is visible without relying on manual cache deletion.
+
+Use `opencode_wizard_published_skill_preference_set` for non-TUI preference actions (`install`, `uninstall`, `ignore`, `unignore`) against the same server-backed preference API used by the TUI overlay.
 
 `GLOBAL_CONTEXT` skills are active context skills and are not meant to be installed per project. `PROJECT_INSTALLABLE` skills are gallery/installable skills that may be attached globally or to a workspace/path through assignment records; those assignments remain the source of truth for what is active in a catalog response.
 

package/dist/server.d.ts

@@ -5,6 +5,7 @@ type ResolvedConfig = {
     authSessionUrl: string;
     presenceUrl: string;
     actionsUrl: string;
+    configuredWorkspaceSlug: string | null;
     fallbackWorkspaceSlug: string;
     rootSkillSeedPath: string;
     authStatePath: string;
@@ -13,6 +14,8 @@ type WorkspaceResolution = {
     requestedDirectory: string;
     repositoryRoot: string;
     repositoryUrl: string | null;
+    workspaceSlug?: string | null;
+    workspaceSlugSource?: 'configured' | 'learned' | 'backend' | 'fallback' | 'repositoryUrl' | 'placeholder';
     fallbackWorkspaceSlug: string | null;
     directoryPath: string;
     cacheKey: string;
@@ -271,6 +274,8 @@ declare const toWorkspaceResolutionOutput: (resolution: WorkspaceResolution) =>
     requestedDirectory: string;
     repositoryRoot: string;
     repositoryUrl: string | null;
+    workspaceSlug: string | null | undefined;
+    workspaceSlugSource: "configured" | "learned" | "backend" | "fallback" | "repositoryUrl" | "placeholder" | undefined;
     fallbackWorkspaceSlug: string | null;
     directoryPath: string;
 };

package/dist/server.js

@@ -14,6 +14,7 @@ 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';
@@ -55,7 +56,7 @@ const statusPathLoginBootstrap = {
   failedAt: null
 };
 const importOpencodePluginModule = new Function('specifier', 'return import(specifier)');
-export const AVAILABLE_PUBLISHED_SKILL_TOOLS = ['opencode_wizard_published_skills_fetch', 'opencode_wizard_status'];
+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',
@@ -330,14 +331,19 @@ const resolveBackendOrigin = async worktree => {
     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 = process.env.OPENCODE_WIZARD_SKILLS_WORKSPACE_SLUG?.trim();
-  if (configuredWorkspaceSlug) return toWorkspaceSlug(configuredWorkspaceSlug);
+  const configuredWorkspaceSlug = readConfiguredWorkspaceSlug();
+  if (configuredWorkspaceSlug) return configuredWorkspaceSlug;
   return toWorkspaceSlug(path.basename(path.resolve(worktree)));
 };
 export const resolveConfig = async worktree => {
@@ -348,6 +354,7 @@ export const resolveConfig = async worktree => {
     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
@@ -408,22 +415,31 @@ const resolveWorkspace = async ({
   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 workspaceIdentity = `workspaceSlug:${fallbackWorkspaceSlug}`;
+  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.fallbackWorkspaceSlug) {
+  if (resolution.workspaceSlug) {
     return {
-      workspaceSlug: resolution.fallbackWorkspaceSlug,
+      workspaceSlug: resolution.workspaceSlug,
       directoryPath: resolution.directoryPath
     };
   }
@@ -475,6 +491,76 @@ const withoutLegacyPublishedSkillPreferences = config => {
 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;
@@ -517,8 +603,21 @@ const toIgnoredSkillSlug = value => {
   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.fallbackWorkspaceSlug;
+  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))}`;
@@ -866,6 +965,8 @@ const toWorkspaceResolutionOutput = resolution => ({
   requestedDirectory: resolution.requestedDirectory,
   repositoryRoot: resolution.repositoryRoot,
   repositoryUrl: resolution.repositoryUrl,
+  workspaceSlug: resolution.workspaceSlug,
+  workspaceSlugSource: resolution.workspaceSlugSource,
   fallbackWorkspaceSlug: resolution.fallbackWorkspaceSlug,
   directoryPath: resolution.directoryPath
 });
@@ -873,6 +974,8 @@ 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) => {
@@ -1170,7 +1273,12 @@ const toPluginStatusMetadata = snapshot => ({
   pluginStatus: snapshot.status,
   authStatus: snapshot.authState.status,
   authEmail: snapshot.authState.email ?? '',
-  authUserId: snapshot.authState.userId ?? ''
+  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();
@@ -1491,6 +1599,24 @@ const fetchPublishedSkillsCatalog = async (worktree, config, resolution, signal,
     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,
@@ -1928,6 +2054,11 @@ const OpencodeWizardSkillsPlugin = async input => {
     }
     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
@@ -1958,7 +2089,7 @@ const OpencodeWizardSkillsPlugin = async input => {
     const cacheKey = getDetailCacheKey(catalogCacheKey, item.skillVersion.id);
     const inflightKey = getDetailInflightKey(catalogCacheKey, item.skillVersion.id, purpose);
     const cached = detailCache.get(cacheKey);
-    if (purpose === 'SYSTEM_CONTEXT' && useCache && cached && cached.expiresAt > Date.now()) {
+    if (useCache && cached && cached.expiresAt > Date.now()) {
       return {
         ok: true,
         detail: toPublishedSkillDetail({
@@ -2135,11 +2266,13 @@ const OpencodeWizardSkillsPlugin = async input => {
           },
           fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
           source: filteredPublishedSkillsResult.fetchResult.source,
-          message: 'Catalog discovery only. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.'
+          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(),
@@ -2229,6 +2362,7 @@ const OpencodeWizardSkillsPlugin = async input => {
         metadata: {
           status: 'ready',
           ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          source: filteredPublishedSkillsResult.fetchResult.source,
           skillSlug: detail.skillSlug
         }
       };
@@ -2258,6 +2392,7 @@ const OpencodeWizardSkillsPlugin = async input => {
       metadata: {
         status: selection.missingIdentifiers.length > 0 ? 'partial' : 'ready',
         ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+        source: filteredPublishedSkillsResult.fetchResult.source,
         matchedCount: skillDetails.length.toString()
       }
     };
@@ -2286,6 +2421,9 @@ const OpencodeWizardSkillsPlugin = async input => {
         // 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}`,
@@ -2296,6 +2434,96 @@ const OpencodeWizardSkillsPlugin = async input => {
       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({
@@ -2313,6 +2541,21 @@ const OpencodeWizardSkillsPlugin = async input => {
           });
         }
       }),
+      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: {
@@ -2352,6 +2595,9 @@ const OpencodeWizardSkillsPlugin = async input => {
           return;
         }
       }
+      if (publishedSkillsResult.fetchResult.ok) {
+        await scheduleInteractivePresenceStart();
+      }
       const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
       const details = await loadSystemNoteDetails({
         publishedSkillsResult: filteredPublishedSkillsResult,