thumbgate 0.9.13 → 1.0.0

package/scripts/async-job-runner.js

@@ -132,11 +132,54 @@ function serializeJobForState(job) {
     skill: job.skill || null,
     partnerProfile: job.partnerProfile || null,
     autoImprove: job.autoImprove !== false,
+    verificationMode: job.verificationMode === 'none' ? 'none' : 'standard',
+    recordFeedback: job.recordFeedback !== false,
     jobFilePath: job.jobFilePath || null,
     stages,
   };
 }
 
+function queueJob(job) {
+  const normalizedJob = {
+    ...job,
+    id: job.id || generateJobId(),
+    tags: Array.isArray(job.tags) ? job.tags : [],
+    autoImprove: job.autoImprove !== false,
+    verificationMode: job.verificationMode === 'none' ? 'none' : 'standard',
+    recordFeedback: job.recordFeedback !== false,
+    stages: normalizeStages(job),
+  };
+  const previousState = readJobState(normalizedJob.id);
+  const currentStage = normalizedJob.stages[0] ? normalizedJob.stages[0].name : null;
+  return writeJobState({
+    jobId: normalizedJob.id,
+    status: 'queued',
+    createdAt: previousState && previousState.createdAt ? previousState.createdAt : nowIso(),
+    startedAt: previousState && previousState.startedAt ? previousState.startedAt : null,
+    resumedAt: null,
+    updatedAt: nowIso(),
+    endedAt: null,
+    tags: normalizedJob.tags,
+    skill: normalizedJob.skill || null,
+    partnerProfile: normalizedJob.partnerProfile || null,
+    autoImprove: normalizedJob.autoImprove,
+    verificationMode: normalizedJob.verificationMode,
+    recordFeedback: normalizedJob.recordFeedback,
+    totalStages: normalizedJob.stages.length,
+    nextStageIndex: 0,
+    currentStage,
+    currentContext: '',
+    checkpoints: [],
+    stageHistory: [],
+    jobFilePath: normalizedJob.jobFilePath || null,
+    jobSpec: serializeJobForState(normalizedJob),
+    lastError: null,
+    stopReason: null,
+    improvementExperimentId: null,
+    verification: null,
+  });
+}
+
 function readJobState(jobId) {
   if (!jobId) return null;
   return readJson(getJobRuntimePaths(jobId).statePath);
@@ -618,6 +661,8 @@ function executeJob(job, options = {}) {
     id: job.id || generateJobId(),
     tags: Array.isArray(job.tags) ? job.tags : [],
     autoImprove: job.autoImprove !== false,
+    verificationMode: job.verificationMode === 'none' ? 'none' : 'standard',
+    recordFeedback: job.recordFeedback !== false,
     stages: normalizeStages(job),
   };
   const previousState = options.previousState || readJobState(normalizedJob.id);
@@ -643,6 +688,8 @@ function executeJob(job, options = {}) {
     skill: normalizedJob.skill || null,
     partnerProfile: normalizedJob.partnerProfile || null,
     autoImprove: normalizedJob.autoImprove,
+    verificationMode: normalizedJob.verificationMode,
+    recordFeedback: normalizedJob.recordFeedback,
     totalStages: normalizedJob.stages.length,
     nextStageIndex,
     currentStage: normalizedJob.stages[nextStageIndex] ? normalizedJob.stages[nextStageIndex].name : 'verification',
@@ -733,7 +780,7 @@ function executeJob(job, options = {}) {
 
       clearJobControl(normalizedJob.id);
 
-      const feedback = error && error.code === 'JOB_CANCELLED'
+      const feedback = (error && error.code === 'JOB_CANCELLED') || normalizedJob.recordFeedback === false
         ? null
         : captureFeedback({
           signal: 'down',
@@ -756,48 +803,60 @@ function executeJob(job, options = {}) {
     }
   }
 
-  const verification = runVerificationLoop({
-    context: currentContext,
-    tags: normalizedJob.tags,
-    skill: normalizedJob.skill,
-    partnerProfile: normalizedJob.partnerProfile,
-    onRetry: normalizedJob.onRetry,
-    maxRetries: normalizedJob.maxRetries,
-  });
+  const verification = normalizedJob.verificationMode === 'none'
+    ? null
+    : runVerificationLoop({
+      context: currentContext,
+      tags: normalizedJob.tags,
+      skill: normalizedJob.skill,
+      partnerProfile: normalizedJob.partnerProfile,
+      onRetry: normalizedJob.onRetry,
+      maxRetries: normalizedJob.maxRetries,
+    });
 
-  const improvementExperiment = verification.accepted
+  const improvementExperiment = !verification || verification.accepted
     ? null
     : maybeQueueImprovementExperiment(normalizedJob, state, recall, {
       type: 'verification',
       verification,
     });
 
-  const feedback = captureFeedback({
-    signal: verification.accepted ? 'up' : 'down',
-    context: verification.accepted
-      ? `Job ${normalizedJob.id} passed verification after ${verification.attempts} attempt(s)`
-      : `Job ${normalizedJob.id} failed verification after ${verification.attempts} attempt(s): ${(verification.finalVerification.violations || []).map((violation) => violation.pattern).join('; ')}`,
-    whatWorked: verification.accepted ? 'Verification loop accepted output' : undefined,
-    whatWentWrong: !verification.accepted ? `Failed ${verification.attempts} verification attempts` : undefined,
-    whatToChange: !verification.accepted ? 'Improve output to avoid known mistake patterns' : undefined,
-    tags: [...normalizedJob.tags, 'verification-loop'],
-    skill: normalizedJob.skill || 'async-job-runner',
-  });
+  const feedback = normalizedJob.recordFeedback === false
+    ? null
+    : captureFeedback({
+      signal: !verification || verification.accepted ? 'up' : 'down',
+      context: !verification
+        ? `Job ${normalizedJob.id} completed without post-run verification`
+        : verification.accepted
+          ? `Job ${normalizedJob.id} passed verification after ${verification.attempts} attempt(s)`
+          : `Job ${normalizedJob.id} failed verification after ${verification.attempts} attempt(s): ${(verification.finalVerification.violations || []).map((violation) => violation.pattern).join('; ')}`,
+      whatWorked: !verification
+        ? 'Operational job completed successfully'
+        : verification.accepted
+          ? 'Verification loop accepted output'
+          : undefined,
+      whatWentWrong: verification && !verification.accepted ? `Failed ${verification.attempts} verification attempts` : undefined,
+      whatToChange: verification && !verification.accepted ? 'Improve output to avoid known mistake patterns' : undefined,
+      tags: !verification
+        ? [...normalizedJob.tags, 'async-job-runner', 'verification-skipped']
+        : [...normalizedJob.tags, 'verification-loop'],
+      skill: normalizedJob.skill || 'async-job-runner',
+    });
 
   const terminalState = writeJobState({
     ...(readJobState(normalizedJob.id) || state),
-    status: verification.accepted ? 'completed' : 'failed',
+    status: !verification || verification.accepted ? 'completed' : 'failed',
     updatedAt: nowIso(),
     endedAt: nowIso(),
     currentStage: null,
     nextStageIndex: normalizedJob.stages.length,
     currentContext,
     improvementExperimentId: improvementExperiment ? improvementExperiment.id : null,
-    verification: {
+    verification: verification ? {
       accepted: verification.accepted,
       attempts: verification.attempts,
       score: verification.finalVerification ? verification.finalVerification.score : 0,
-    },
+    } : null,
   });
 
   clearJobControl(normalizedJob.id);
@@ -880,6 +939,7 @@ function runBatch(jobs) {
 module.exports = {
   recallContext,
   executeJob,
+  queueJob,
   runBatch,
   appendJobLog,
   readJobLog,

package/scripts/auto-wire-hooks.js

@@ -53,6 +53,7 @@ function detectAgent(flagAgent) {
     if (['claude-code', 'claude'].includes(normalized)) return 'claude-code';
     if (['codex'].includes(normalized)) return 'codex';
     if (['gemini'].includes(normalized)) return 'gemini';
+    if (['forge', 'forgecode', 'forge-code'].includes(normalized)) return 'forge';
     return null;
   }
 
@@ -61,6 +62,7 @@ function detectAgent(flagAgent) {
   if (fs.existsSync(path.join(home, '.claude'))) return 'claude-code';
   if (fs.existsSync(path.join(home, '.codex'))) return 'codex';
   if (fs.existsSync(path.join(home, '.gemini'))) return 'gemini';
+  if (fs.existsSync(path.join(process.cwd(), 'forge.yaml'))) return 'forge';
   return null;
 }
 
@@ -310,13 +312,64 @@ function wireGeminiHooks(options) {
   return { changed: true, settingsPath, added };
 }
 
+// --- ForgeCode wiring ---
+
+function forgeConfigPath() {
+  return path.join(process.cwd(), 'forge.yaml');
+}
+
+function wireForgeHooks(options) {
+  const dryRun = options.dryRun || false;
+
+  const preToolCmd = preToolHookCommand();
+  const userPromptCmd = userPromptHookCommand();
+
+  // ForgeCode uses YAML config (forge.yaml). We write a JSON-based hooks
+  // sidecar file (.thumbgate/forge-hooks.json) and append skill entries to
+  // forge.yaml if they are not already present.
+  const hooksPath = options.settingsPath || path.join(path.dirname(forgeConfigPath()), '.thumbgate', 'forge-hooks.json');
+  let existing = loadJsonFile(hooksPath) || {};
+  existing.hooks = existing.hooks || {};
+
+  const added = [];
+
+  if (!hookAlreadyPresent(existing.hooks.PreToolUse, preToolCmd)) {
+    existing.hooks.PreToolUse = existing.hooks.PreToolUse || [];
+    existing.hooks.PreToolUse.push({
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: preToolCmd }],
+    });
+    added.push({ lifecycle: 'PreToolUse', command: preToolCmd });
+  }
+
+  if (!hookAlreadyPresent(existing.hooks.UserPromptSubmit, userPromptCmd)) {
+    existing.hooks.UserPromptSubmit = existing.hooks.UserPromptSubmit || [];
+    existing.hooks.UserPromptSubmit.push({
+      hooks: [{ type: 'command', command: userPromptCmd }],
+    });
+    added.push({ lifecycle: 'UserPromptSubmit', command: userPromptCmd });
+  }
+
+  if (added.length === 0) {
+    return { changed: false, settingsPath: hooksPath, added: [] };
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(hooksPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(hooksPath, JSON.stringify(existing, null, 2) + '\n');
+  }
+
+  return { changed: true, settingsPath: hooksPath, added };
+}
+
 // --- Dispatcher ---
 
 function wireHooks(options) {
   const agent = detectAgent(options.agent);
   if (!agent) {
     return {
-      error: 'Could not detect AI agent. Use --agent=claude-code|codex|gemini',
+      error: 'Could not detect AI agent. Use --agent=claude-code|codex|gemini|forge',
       agent: null,
       changed: false,
     };
@@ -333,6 +386,9 @@ function wireHooks(options) {
     case 'gemini':
       result = wireGeminiHooks(options);
       break;
+    case 'forge':
+      result = wireForgeHooks(options);
+      break;
     default:
       return { error: `Unsupported agent: ${agent}`, agent, changed: false };
   }
@@ -364,6 +420,7 @@ module.exports = {
   wireClaudeHooks,
   wireCodexHooks,
   wireGeminiHooks,
+  wireForgeHooks,
   hookAlreadyPresent,
   loadJsonFile,
   parseFlags,
@@ -372,6 +429,7 @@ module.exports = {
   codexConfigPath,
   geminiSettingsPath,
   syncClaudeStatusLine,
+  forgeConfigPath,
   CLAUDE_HOOKS,
   preToolHookCommand,
   userPromptHookCommand,

package/scripts/context-manager.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Context Manager — Unified Context-Augmented Generation (CAG) Orchestrator
+ *
+ * Single entry point that assembles a normalized context object from:
+ *   - Session state (primer / handoff)
+ *   - User profile (role, preferences, agent type)
+ *   - Relevant lessons (per-action retrieval)
+ *   - Prevention rules / pre-tool guards
+ *   - Context pack (ContextFS retrieval)
+ *   - Code-graph impact (optional, for coding tasks)
+ *
+ * Implements tiered graceful degradation:
+ *   Tier 1 (full)  — session + lessons + rules + context pack + code-graph
+ *   Tier 2 (warm)  — lessons + rules + context pack (no session)
+ *   Tier 3 (cold)  — prevention rules + global defaults only
+ *
+ * Role-aware filtering shapes output by agent type and license tier.
+ */
+
+const {
+  ensureContextFs,
+  constructContextPack,
+  readSessionHandoff,
+  recordProvenance,
+} = require('./contextfs');
+const { retrieveRelevantLessons } = require('./lesson-retrieval');
+const { evaluatePretool } = require('./hybrid-feedback-context');
+const { loadProfile } = require('./user-profile');
+const {
+  analyzeCodeGraphImpact,
+  formatCodeGraphRecallSection,
+} = require('./codegraph-context');
+
+// ---------------------------------------------------------------------------
+// Agent capability profiles — shapes what context each agent type receives
+// ---------------------------------------------------------------------------
+
+const AGENT_PROFILES = {
+  claude: {
+    maxLessons: 8,
+    includeCodeGraph: true,
+    includeStructuredRules: true,
+    contextBudget: 10000,
+  },
+  cursor: {
+    maxLessons: 5,
+    includeCodeGraph: true,
+    includeStructuredRules: true,
+    contextBudget: 6000,
+  },
+  forgecode: {
+    maxLessons: 5,
+    includeCodeGraph: false,
+    includeStructuredRules: true,
+    contextBudget: 6000,
+  },
+  codex: {
+    maxLessons: 6,
+    includeCodeGraph: true,
+    includeStructuredRules: true,
+    contextBudget: 8000,
+  },
+  default: {
+    maxLessons: 5,
+    includeCodeGraph: false,
+    includeStructuredRules: true,
+    contextBudget: 6000,
+  },
+};
+
+function getAgentProfile(agentType) {
+  const key = String(agentType || 'default').toLowerCase();
+  return AGENT_PROFILES[key] || AGENT_PROFILES.default;
+}
+
+// ---------------------------------------------------------------------------
+// Tier assembly helpers
+// ---------------------------------------------------------------------------
+
+function assembleSession() {
+  try {
+    return readSessionHandoff();
+  } catch {
+    return null;
+  }
+}
+
+function assembleLessons(query, agentProfile, options = {}) {
+  try {
+    return retrieveRelevantLessons(
+      options.toolName || '',
+      query,
+      { maxResults: agentProfile.maxLessons, feedbackDir: options.feedbackDir },
+    );
+  } catch {
+    return [];
+  }
+}
+
+function assembleGuards(toolName, toolInput) {
+  try {
+    return evaluatePretool(toolName || '', toolInput || {});
+  } catch {
+    return { mode: 'allow', reason: 'guard-unavailable' };
+  }
+}
+
+function assembleContextPack(query, agentProfile) {
+  try {
+    ensureContextFs();
+    return constructContextPack({
+      query,
+      maxItems: Math.min(8, Math.ceil(agentProfile.contextBudget / 1000)),
+      maxChars: agentProfile.contextBudget,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function assembleCodeGraph(query, repoPath, agentProfile) {
+  if (!agentProfile.includeCodeGraph) return null;
+  try {
+    const impact = analyzeCodeGraphImpact({
+      intentId: null,
+      context: query,
+      repoPath,
+    });
+    return formatCodeGraphRecallSection(impact) || null;
+  } catch {
+    return null;
+  }
+}
+
+function assembleUserProfile() {
+  try {
+    const profile = loadProfile();
+    if (!profile || !profile.entries || profile.entries.length === 0) return null;
+    return {
+      entries: profile.entries,
+      charCount: profile.charCount || 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tier classification
+// ---------------------------------------------------------------------------
+
+function classifyTier(components) {
+  const hasSession = !!components.session;
+  const hasLessons = components.lessons && components.lessons.length > 0;
+  const hasPack = !!components.contextPack;
+
+  if (hasSession && (hasLessons || hasPack)) return 'full';
+  if (hasLessons || hasPack) return 'warm';
+  return 'cold';
+}
+
+// ---------------------------------------------------------------------------
+// Main orchestrator
+// ---------------------------------------------------------------------------
+
+/**
+ * Assemble a unified context object for a given query.
+ *
+ * @param {Object} params
+ * @param {string} params.query - Task description / context query
+ * @param {string} [params.toolName] - Current tool being invoked (for lesson retrieval)
+ * @param {Object} [params.toolInput] - Current tool input (for guard evaluation)
+ * @param {string} [params.agentType] - Agent type: claude, cursor, forgecode, codex
+ * @param {string} [params.repoPath] - Repo path for code-graph analysis
+ * @param {string} [params.feedbackDir] - Override feedback directory
+ * @returns {Object} Normalized context object
+ */
+function assembleUnifiedContext(params = {}) {
+  const {
+    query = '',
+    toolName,
+    toolInput,
+    agentType,
+    repoPath,
+    feedbackDir,
+  } = params;
+
+  const agentProfile = getAgentProfile(agentType);
+
+  // Assemble all components — each is fault-tolerant
+  const session = assembleSession();
+  const userProfile = assembleUserProfile();
+  const lessons = assembleLessons(query, agentProfile, { toolName, feedbackDir });
+  const guards = assembleGuards(toolName, toolInput);
+  const contextPack = assembleContextPack(query, agentProfile);
+  const codeGraph = assembleCodeGraph(query, repoPath, agentProfile);
+
+  const components = { session, userProfile, lessons, guards, contextPack, codeGraph };
+  const tier = classifyTier(components);
+
+  const result = {
+    tier,
+    agentType: agentType || 'default',
+    agentProfile: {
+      maxLessons: agentProfile.maxLessons,
+      contextBudget: agentProfile.contextBudget,
+      includeCodeGraph: agentProfile.includeCodeGraph,
+    },
+    session: session || null,
+    userProfile: userProfile || null,
+    lessons,
+    guards,
+    contextPack: contextPack ? {
+      packId: contextPack.packId,
+      itemCount: Array.isArray(contextPack.items) ? contextPack.items.length : 0,
+      items: (contextPack.items || []).slice(0, 5).map((item) => ({
+        id: item.id,
+        namespace: item.namespace,
+        title: item.title,
+        tags: item.tags || [],
+        score: item.score,
+      })),
+      visibility: contextPack.visibility || null,
+      cached: !!(contextPack.cache && contextPack.cache.hit),
+    } : null,
+    codeGraph: codeGraph || null,
+    assembledAt: new Date().toISOString(),
+  };
+
+  // Record provenance for audit trail
+  try {
+    recordProvenance({
+      type: 'unified_context_assembled',
+      tier,
+      agentType: result.agentType,
+      lessonCount: lessons.length,
+      guardDecision: guards.mode || 'allow',
+      hasSession: !!session,
+      hasUserProfile: !!userProfile,
+      hasCodeGraph: !!codeGraph,
+      packId: result.contextPack ? result.contextPack.packId : null,
+    });
+  } catch {
+    // Provenance write failure must never break context assembly
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Formatting for MCP tool response
+// ---------------------------------------------------------------------------
+
+function formatUnifiedContext(ctx) {
+  const lines = [];
+
+  lines.push(`## Unified Context (Tier: ${ctx.tier})`);
+  lines.push(`Agent: ${ctx.agentType} | Assembled: ${ctx.assembledAt}`);
+  lines.push('');
+
+  // Session
+  if (ctx.session) {
+    lines.push('### Session');
+    if (ctx.session.lastTask) lines.push(`Last task: ${ctx.session.lastTask}`);
+    if (ctx.session.nextStep) lines.push(`Next step: ${ctx.session.nextStep}`);
+    if (ctx.session.blockers && ctx.session.blockers.length > 0) {
+      lines.push(`Blockers: ${ctx.session.blockers.join(', ')}`);
+    }
+    lines.push('');
+  }
+
+  // User profile
+  if (ctx.userProfile) {
+    lines.push('### User Profile');
+    ctx.userProfile.entries.slice(0, 3).forEach((entry) => {
+      lines.push(`- ${entry.slice(0, 120)}`);
+    });
+    lines.push('');
+  }
+
+  // Guards
+  if (ctx.guards && ctx.guards.mode !== 'allow') {
+    lines.push(`### Guard: ${ctx.guards.mode.toUpperCase()}`);
+    lines.push(ctx.guards.reason || 'No reason provided');
+    lines.push('');
+  }
+
+  // Lessons
+  if (ctx.lessons && ctx.lessons.length > 0) {
+    lines.push(`### Lessons (${ctx.lessons.length})`);
+    ctx.lessons.forEach((lesson) => {
+      const signal = lesson.signal === 'negative' ? '[-]' : '[+]';
+      lines.push(`${signal} ${lesson.title || lesson.id} (score: ${lesson.relevanceScore})`);
+      if (lesson.rule) {
+        lines.push(`  Rule: IF ${lesson.rule.condition || '?'} THEN ${lesson.rule.action || '?'}`);
+      }
+    });
+    lines.push('');
+  }
+
+  // Context pack
+  if (ctx.contextPack) {
+    lines.push(`### Context Pack (${ctx.contextPack.itemCount} items)`);
+    ctx.contextPack.items.forEach((item) => {
+      lines.push(`- [${item.namespace}] ${item.title} (score: ${item.score})`);
+    });
+    if (ctx.contextPack.cached) lines.push('(cached)');
+    lines.push('');
+  }
+
+  // Code graph
+  if (ctx.codeGraph) {
+    lines.push('### Code Graph Impact');
+    lines.push(ctx.codeGraph);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  assembleUnifiedContext,
+  formatUnifiedContext,
+  getAgentProfile,
+  AGENT_PROFILES,
+  classifyTier,
+};

package/scripts/dashboard.js

@@ -523,7 +523,7 @@ function computeInstrumentationReadiness(analytics, billing) {
   const cli = telemetry.cli || {};
 
   return {
-    plausibleConfigured: /\/js\/analytics\.js/.test(landingPage),
+    plausibleConfigured: /plausible\.io\/js\/script\.js|\/js\/analytics\.js/.test(landingPage),
     ga4Configured: Boolean(runtimeConfig.gaMeasurementId),
     googleSearchConsoleConfigured: Boolean(runtimeConfig.googleSiteVerification),
     softwareApplicationSchemaPresent: /"@type": "SoftwareApplication"/.test(landingPage),

package/scripts/distribution-surfaces.js

@@ -6,6 +6,7 @@ const path = require('node:path');
 const ROOT = path.join(__dirname, '..');
 const PRODUCTHUNT_URL = 'https://www.producthunt.com/products/thumbgate';
 const CLAUDE_PLUGIN_LATEST_ASSET_NAME = 'thumbgate-claude-desktop.mcpb';
+const CLAUDE_PLUGIN_NEXT_ASSET_NAME = 'thumbgate-claude-desktop-next.mcpb';
 
 function readJson(root, relativePath) {
   return JSON.parse(fs.readFileSync(path.join(root, relativePath), 'utf8'));
@@ -24,6 +25,14 @@ function getClaudePluginVersionedAssetName(version = getPackageVersion(ROOT)) {
   return `thumbgate-claude-desktop-v${normalized}.mcpb`;
 }
 
+function isPrereleaseVersion(version = getPackageVersion(ROOT)) {
+  return /^\d+\.\d+\.\d+-[0-9A-Za-z.-]+$/.test(String(version || '').trim());
+}
+
+function getClaudePluginChannelAssetName(version = getPackageVersion(ROOT)) {
+  return isPrereleaseVersion(version) ? CLAUDE_PLUGIN_NEXT_ASSET_NAME : CLAUDE_PLUGIN_LATEST_ASSET_NAME;
+}
+
 function getClaudePluginLatestDownloadUrl(root = ROOT) {
   return `${getRepositoryUrl(root)}/releases/latest/download/${CLAUDE_PLUGIN_LATEST_ASSET_NAME}`;
 }
@@ -35,10 +44,13 @@ function getClaudePluginVersionedDownloadUrl(root = ROOT, version = getPackageVe
 
 module.exports = {
   CLAUDE_PLUGIN_LATEST_ASSET_NAME,
+  CLAUDE_PLUGIN_NEXT_ASSET_NAME,
   PRODUCTHUNT_URL,
+  getClaudePluginChannelAssetName,
   getClaudePluginLatestDownloadUrl,
   getClaudePluginVersionedAssetName,
   getClaudePluginVersionedDownloadUrl,
   getPackageVersion,
   getRepositoryUrl,
+  isPrereleaseVersion,
 };