@robbiesrobotics/alice-agents 1.4.4 → 1.4.6

package/lib/installer.mjs

@@ -27,6 +27,8 @@ import { c, bold, dim, green, greenBold, red, yellow, cyan, gray,
          icons, separator, printSection, printSeparator, printBox,
          printStepDone, printStepFail, printStepSkip } from './colors.mjs';
 import { runSkillsWizardStep } from './skills.mjs';
+import { resolveCodingAgentPreference } from './coding-agent.mjs';
+import { loadAgentRegistry } from './agent-registry.mjs';
 
 function commandExists(cmd) {
   const probe = process.platform === 'win32' ? 'where' : 'which';
@@ -105,7 +107,11 @@ function getOpenClawVersion() {
 
 function getLatestNpmVersion() {
   try {
-    const output = execSync('npm view openclaw version', { stdio: 'pipe', encoding: 'utf8' });
+    const output = execSync('npm view openclaw version', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+      timeout: 5000,
+    });
     return output.trim();
   } catch {
     return null;
@@ -421,11 +427,6 @@ async function installRuntime(auto) {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-function loadAgentRegistry() {
-  const raw = readFileSync(join(__dirname, '..', 'templates', 'agents-starter.json'), 'utf8');
-  return JSON.parse(raw);
-}
-
 function printBanner() {
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url)));
   const version = pkg.version || '';
@@ -446,6 +447,13 @@ function printSummary(mode, tier, agents, preset, userInfo, detectedModels) {
   return printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedModels, null);
 }
 
+function normalizeTierOption(tier) {
+  if (!tier) return null;
+  const normalized = String(tier).trim().toLowerCase();
+  if (normalized === 'starter' || normalized === 'pro') return normalized;
+  throw new Error(`Invalid --tier value "${tier}". Use starter or pro.`);
+}
+
 function printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedModels, missionControl) {
   const modelLabel =
     preset === 'detected'
@@ -542,8 +550,6 @@ export async function runInstall(options = {}) {
     console.log(`  ${icons.info} ${dim('No model configured yet — you\'ll be prompted to choose one.')}\n`);
   }
 
-  const allAgents = loadAgentRegistry();
-
   // 2. Install mode
   let mode;
   if (options.modeOverride) {
@@ -596,7 +602,9 @@ export async function runInstall(options = {}) {
 
   // 5. Tier selection
   let tier;
-  if (auto) {
+  if (options.tierOverride) {
+    tier = normalizeTierOption(options.tierOverride);
+  } else if (auto) {
     tier = 'starter';
   } else {
     tier = await promptTier();
@@ -604,16 +612,49 @@ export async function runInstall(options = {}) {
 
   if (tier === 'pro') {
     const { checkProLicense, validateLicenseRemote, storeLicense, isValidFormat } = await import('./license.mjs');
+    const explicitLicenseKey = String(options.licenseKey || '').trim();
 
-    const existing = await checkProLicense();
+    const existing = await checkProLicense({ revalidate: true });
 
     if (existing.licensed) {
-      printStepDone(`Pro license found (${existing.key.slice(0, 12)}...)`);
+      if (existing.provisional) {
+        printStepDone(`Pro license found (${existing.key.slice(0, 12)}...)`, `temporary grace until ${existing.graceUntil}`);
+      } else if (existing.needsRevalidation) {
+        printStepDone(`Pro license found (${existing.key.slice(0, 12)}...)`, 'using cached validation while the service is unavailable');
+      } else {
+        printStepDone(`Pro license found (${existing.key.slice(0, 12)}...)`);
+      }
+    } else if (auto && explicitLicenseKey) {
+      if (!isValidFormat(explicitLicenseKey)) {
+        throw new Error('Invalid --license-key format. Key must be ALICE-XXXX-XXXX-XXXX.');
+      }
+
+      console.log('  Validating provided Pro license key...');
+      const result = await validateLicenseRemote(explicitLicenseKey);
+      if (result.valid) {
+        storeLicense(explicitLicenseKey, {
+          status: 'validated',
+          plan: result.plan || 'pro',
+          transport: result.transport,
+          source: 'remote',
+        });
+        printStepDone('License verified! Welcome to A.L.I.C.E. Pro.');
+      } else if (result.graceEligible) {
+        const graceRecord = storeLicense(explicitLicenseKey, {
+          status: 'grace',
+          plan: 'pro',
+          transport: result.transport,
+          source: 'grace',
+        });
+        printStepDone('Key stored', `temporary grace until ${graceRecord.graceUntil}`);
+      } else {
+        throw new Error(`Pro license validation failed: ${result.message ?? 'Not recognized'}`);
+      }
     } else if (auto) {
       // --yes flag: skip interactive prompt, fallback to Starter if no stored license
       console.log('');
       console.log(`  ${icons.info} ${dim('Pro tier requires a license key.')}`);
-      console.log(`  ${dim('Run without --yes to enter your license key.')}`);
+      console.log(`  ${dim('Run without --yes to enter your license key, or pass --license-key for automation.')}`);
       console.log(`  ${dim('Falling back to Starter tier.')}`);
       console.log(`  ${dim('Purchase a license at:')} ${cyan('https://getalice.av3.ai/pricing')}`);
       tier = 'starter';
@@ -635,12 +676,22 @@ export async function runInstall(options = {}) {
         const result = await validateLicenseRemote(key);
 
         if (result.valid) {
-          storeLicense(key);
-          if (result.message === 'offline') {
-            printStepDone('Key stored', 'offline — will validate on next run');
-          } else {
-            printStepDone('License verified! Welcome to A.L.I.C.E. Pro.');
-          }
+          storeLicense(key, {
+            status: 'validated',
+            plan: result.plan || 'pro',
+            transport: result.transport,
+            source: 'remote',
+          });
+          printStepDone('License verified! Welcome to A.L.I.C.E. Pro.');
+          break;
+        } else if (result.graceEligible) {
+          const graceRecord = storeLicense(key, {
+            status: 'grace',
+            plan: 'pro',
+            transport: result.transport,
+            source: 'grace',
+          });
+          printStepDone('Key stored', `temporary grace until ${graceRecord.graceUntil}`);
           break;
         } else {
           printStepFail(`Invalid key: ${result.message ?? 'Not recognized'}`);
@@ -684,12 +735,21 @@ export async function runInstall(options = {}) {
         dashboardUrl,
         ingestUrl,
         sourceNode,
+        teamId: String(options.cloudTeamId || existingMissionControl?.teamId || '').trim(),
+        teamSlug: String(options.cloudTeamSlug || existingMissionControl?.teamSlug || '').trim(),
+        teamName: String(options.cloudTeamName || existingMissionControl?.teamName || '').trim(),
+        teamPlan: String(options.cloudTeamPlan || existingMissionControl?.teamPlan || '').trim(),
         hasIngestToken: !!ingestToken,
         ingestToken,
       };
     }
   }
 
+  const codingAgent = resolveCodingAgentPreference({
+    detectedModels,
+    override: options.codingTool,
+  });
+  const allAgents = loadAgentRegistry(tier);
   const agents = allAgents;
 
   // 6. Confirmation
@@ -733,7 +793,7 @@ export async function runInstall(options = {}) {
   }
 
   // Scaffold workspaces
-  const results = scaffoldAll(agents, userInfo);
+  const { workspaces: results, installedSkill } = scaffoldAll(agents, userInfo, codingAgent);
   let newWorkspaces = 0;
   let updatedWorkspaces = 0;
   for (const r of results) {
@@ -744,6 +804,7 @@ export async function runInstall(options = {}) {
     }
   }
   printStepDone('Workspaces', `${newWorkspaces} created, ${updatedWorkspaces} updated`);
+  printStepDone('Coding agent skill', `${installedSkill.preferred.name} preferred, ${installedSkill.fallback.name} fallback`);
 
   // Skills installation step
   const finalRuntimeForSkills = await detectRuntime();
@@ -762,6 +823,9 @@ export async function runInstall(options = {}) {
     userName: userInfo.name,
     userTimezone: userInfo.timezone,
     modelPreset: effectivePreset,
+    skills: [...new Set([...(existing?.skills || []), installedSkill.skillId, ...(skillsInstalled || [])])],
+    codingTool: installedSkill.preferredTool,
+    codingSkill: installedSkill.skillId,
     missionControl: missionControl
       ? {
           enabled: true,

package/lib/license.mjs

@@ -7,19 +7,71 @@ const LICENSE_DIR = join(homedir(), '.alice');
 const LICENSE_FILE = join(LICENSE_DIR, 'license');
 const VALIDATE_URL = 'https://getalice.av3.ai/api/license/validate';
 const KEY_REGEX = /^ALICE-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+const GRACE_PERIOD_MS = 72 * 60 * 60 * 1000;
+const REVALIDATE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function parseLicenseRecord(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return null;
+
+  if (trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!parsed?.key) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+
+  return {
+    key: trimmed,
+    plan: 'pro',
+    status: 'validated',
+    validatedAt: null,
+    updatedAt: null,
+    source: 'legacy',
+  };
+}
+
+function createLicenseRecord(key, data = {}) {
+  return {
+    key: key.trim().toUpperCase(),
+    plan: data.plan || 'pro',
+    status: data.status || 'validated',
+    validatedAt: data.status === 'validated' ? (data.validatedAt || nowIso()) : (data.validatedAt || null),
+    graceUntil: data.status === 'grace' ? (data.graceUntil || new Date(Date.now() + GRACE_PERIOD_MS).toISOString()) : null,
+    updatedAt: nowIso(),
+    transport: data.transport || null,
+    source: data.source || 'local',
+  };
+}
+
+function shouldRevalidate(record) {
+  if (!record?.validatedAt) return true;
+  const validatedAt = Date.parse(record.validatedAt);
+  if (Number.isNaN(validatedAt)) return true;
+  return Date.now() - validatedAt >= REVALIDATE_INTERVAL_MS;
+}
 
 export function readStoredLicense() {
   try {
     if (!existsSync(LICENSE_FILE)) return null;
-    return readFileSync(LICENSE_FILE, 'utf8').trim();
+    return parseLicenseRecord(readFileSync(LICENSE_FILE, 'utf8'));
   } catch {
     return null;
   }
 }
 
-export function storeLicense(key) {
+export function storeLicense(key, data = {}) {
   mkdirSync(LICENSE_DIR, { recursive: true });
-  writeFileSync(LICENSE_FILE, key.trim(), 'utf8');
+  const record = createLicenseRecord(key, data);
+  writeFileSync(LICENSE_FILE, JSON.stringify(record, null, 2) + '\n', 'utf8');
+  return record;
 }
 
 export function isValidFormat(key) {
@@ -27,24 +79,116 @@ export function isValidFormat(key) {
 }
 
 export async function validateLicenseRemote(key) {
-  // Returns { valid: boolean, plan: string, message?: string }
+  // Returns { valid: boolean, plan?: string, message?: string, transient?: boolean, graceEligible?: boolean, transport?: string }
+  const normalizedKey = key.trim().toUpperCase();
+  const postBody = JSON.stringify({ key: normalizedKey });
+
   try {
-    const res = await fetch(`${VALIDATE_URL}?key=${encodeURIComponent(key)}`, {
+    const res = await fetch(VALIDATE_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: postBody,
       signal: AbortSignal.timeout(5000),
     });
-    if (!res.ok) return { valid: false, message: 'Validation service unavailable' };
-    return await res.json();
+    if (!res.ok && [404, 405, 415].includes(res.status)) {
+      const fallback = await fetch(`${VALIDATE_URL}?key=${encodeURIComponent(normalizedKey)}`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!fallback.ok) {
+        return {
+          valid: false,
+          message: 'Validation service unavailable',
+          transient: fallback.status >= 500,
+          graceEligible: isValidFormat(normalizedKey),
+          transport: 'get',
+        };
+      }
+      return { ...(await fallback.json()), transport: 'get' };
+    }
+    if (!res.ok) {
+      return {
+        valid: false,
+        message: res.status >= 500 ? 'Validation service unavailable' : 'License key not recognized',
+        transient: res.status >= 500,
+        graceEligible: res.status >= 500 && isValidFormat(normalizedKey),
+        transport: 'post',
+      };
+    }
+    return { ...(await res.json()), transport: 'post' };
   } catch {
-    // Network error — fail open (allow install, validate next time)
-    return { valid: true, plan: 'pro', message: 'offline' };
+    return {
+      valid: false,
+      message: 'Validation service unavailable',
+      transient: true,
+      graceEligible: isValidFormat(normalizedKey),
+      transport: 'post',
+    };
   }
 }
 
-export async function checkProLicense() {
+export async function checkProLicense(options = {}) {
   // Returns: { licensed: boolean, key: string|null, source: 'stored'|'none' }
-  const stored = readStoredLicense();
-  if (stored && isValidFormat(stored)) {
-    return { licensed: true, key: stored, source: 'stored' };
+  const record = readStoredLicense();
+  if (!record || !isValidFormat(record.key)) {
+    return { licensed: false, key: null, source: 'none' };
   }
-  return { licensed: false, key: null, source: 'none' };
+
+  if (record.status === 'grace') {
+    const graceUntil = Date.parse(record.graceUntil || '');
+    if (!Number.isNaN(graceUntil) && graceUntil > Date.now()) {
+      return {
+        licensed: true,
+        key: record.key,
+        source: 'grace',
+        provisional: true,
+        graceUntil: record.graceUntil,
+        needsRevalidation: true,
+      };
+    }
+    return { licensed: false, key: null, source: 'expired_grace', message: 'Temporary grace period expired' };
+  }
+
+  const shouldRefresh = options.revalidate === true || shouldRevalidate(record);
+  if (shouldRefresh) {
+    const refreshed = await validateLicenseRemote(record.key);
+    if (refreshed.valid) {
+      const stored = storeLicense(record.key, {
+        status: 'validated',
+        plan: refreshed.plan || record.plan || 'pro',
+        transport: refreshed.transport,
+        source: 'remote',
+      });
+      return {
+        licensed: true,
+        key: stored.key,
+        source: 'revalidated',
+        provisional: false,
+        validatedAt: stored.validatedAt,
+        needsRevalidation: false,
+      };
+    }
+
+    if (refreshed.transient) {
+      return {
+        licensed: true,
+        key: record.key,
+        source: 'stored',
+        provisional: false,
+        validatedAt: record.validatedAt,
+        needsRevalidation: true,
+        message: refreshed.message,
+      };
+    }
+
+    return { licensed: false, key: null, source: 'invalid', message: refreshed.message || 'License key not recognized' };
+  }
+
+  return {
+    licensed: true,
+    key: record.key,
+    source: record.source || 'stored',
+    provisional: false,
+    validatedAt: record.validatedAt,
+    needsRevalidation: false,
+  };
 }

package/lib/manifest.mjs

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 const MANIFEST_NAME = '.alice-manifest.json';
+const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version || '0.0.0';
 
 export function getManifestPath() {
   return join(homedir(), '.openclaw', MANIFEST_NAME);
@@ -18,16 +19,24 @@ export function readManifest() {
 }
 
 export function writeManifest(data) {
+  const existing = readManifest() || {};
+  const now = new Date().toISOString();
   const manifest = {
-    version: '1.0.0',
-    installedAt: data.installedAt || new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    tier: data.tier,
-    agents: data.agents,
-    userName: data.userName,
-    userTimezone: data.userTimezone,
-    modelPreset: data.modelPreset,
-    missionControl: data.missionControl || null,
+    ...existing,
+    version: data.version || existing.version || PACKAGE_VERSION,
+    schemaVersion: 2,
+    packageVersion: data.packageVersion || existing.packageVersion || PACKAGE_VERSION,
+    installedAt: data.installedAt || existing.installedAt || now,
+    updatedAt: now,
+    tier: data.tier ?? existing.tier ?? 'starter',
+    agents: Array.isArray(data.agents) ? [...new Set(data.agents)] : (existing.agents || []),
+    userName: data.userName ?? existing.userName ?? null,
+    userTimezone: data.userTimezone ?? existing.userTimezone ?? null,
+    modelPreset: data.modelPreset ?? existing.modelPreset ?? null,
+    missionControl: data.missionControl ?? existing.missionControl ?? null,
+    skills: Array.isArray(data.skills) ? [...new Set(data.skills)] : (existing.skills || []),
+    codingTool: data.codingTool ?? existing.codingTool ?? null,
+    codingSkill: data.codingSkill ?? existing.codingSkill ?? null,
   };
   writeFileSync(getManifestPath(), JSON.stringify(manifest, null, 2) + '\n', 'utf8');
   return manifest;

package/lib/mission-control.mjs

@@ -9,6 +9,7 @@ const CONFIG_PATH = join(OPENCLAW_HOME, 'openclaw.json');
 const MC_CONFIG_PATH = join(OPENCLAW_HOME, '.alice-mission-control.json');
 const BRIDGE_ID = 'mission-control-bridge';
 const DEFAULT_DASHBOARD_URL = 'https://alice.av3.ai';
+const DEFAULT_ADMIN_URL = 'https://admin.av3.ai';
 const DEFAULT_INGEST_URL = `${DEFAULT_DASHBOARD_URL}/api/v1/ingest`;
 const TEMPLATE_DIR = join(__dirname, '..', 'templates', 'mission-control-bridge');
 
@@ -42,17 +43,39 @@ export function readMissionControlConfig() {
 
 export function buildMissionControlSettings(input = {}) {
   const dashboardUrl = normalizeUrl(input.dashboardUrl, DEFAULT_DASHBOARD_URL);
+  const adminUrl = normalizeUrl(input.adminUrl, DEFAULT_ADMIN_URL);
   const ingestUrl = normalizeUrl(input.ingestUrl, `${dashboardUrl}/api/v1/ingest`);
+  const runtimeBaseUrl = normalizeUrl(input.runtimeBaseUrl, `${dashboardUrl}/api/v1/runtime`);
+  const adminHeartbeatUrl = normalizeUrl(input.adminHeartbeatUrl, `${adminUrl}/api/admin/v1/node-heartbeat`);
+  const commandsUrl = normalizeUrl(input.commandsUrl, `${runtimeBaseUrl}/commands`);
+  const nodeRegisterUrl = normalizeUrl(input.nodeRegisterUrl, `${runtimeBaseUrl}/nodes/register`);
+  const nodeHeartbeatUrl = normalizeUrl(input.nodeHeartbeatUrl, `${runtimeBaseUrl}/nodes/heartbeat`);
   const sourceNode = String(input.sourceNode || hostname() || 'openclaw-local').trim();
   const ingestToken = String(input.ingestToken || '').trim();
+  const workerToken = String(input.workerToken || ingestToken || '').trim();
+  const teamId = String(input.teamId || '').trim();
+  const teamSlug = String(input.teamSlug || '').trim();
+  const teamName = String(input.teamName || '').trim();
+  const teamPlan = String(input.teamPlan || '').trim();
 
   return {
     enabled: input.enabled !== false,
     provider: 'cloud',
     dashboardUrl,
+    adminUrl,
     ingestUrl,
+    runtimeBaseUrl,
+    adminHeartbeatUrl,
+    commandsUrl,
+    nodeRegisterUrl,
+    nodeHeartbeatUrl,
     sourceNode,
+    ...(teamId ? { teamId } : {}),
+    ...(teamSlug ? { teamSlug } : {}),
+    ...(teamName ? { teamName } : {}),
+    ...(teamPlan ? { teamPlan } : {}),
     ...(ingestToken ? { ingestToken } : {}),
+    ...(workerToken ? { workerToken } : {}),
   };
 }
 
@@ -134,9 +157,17 @@ export function configureMissionControlCloud(input = {}) {
       enabled: settings.enabled,
       provider: settings.provider,
       dashboardUrl: settings.dashboardUrl,
+      adminUrl: settings.adminUrl,
       ingestUrl: settings.ingestUrl,
+      runtimeBaseUrl: settings.runtimeBaseUrl,
+      adminHeartbeatUrl: settings.adminHeartbeatUrl,
       sourceNode: settings.sourceNode,
+      teamId: settings.teamId ?? null,
+      teamSlug: settings.teamSlug ?? null,
+      teamName: settings.teamName ?? null,
+      teamPlan: settings.teamPlan ?? null,
       hasIngestToken: !!settings.ingestToken,
+      hasWorkerToken: !!settings.workerToken,
     },
   };
 }

package/lib/release-guard.mjs

@@ -0,0 +1,131 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_REPO_ROOT = join(__dirname, '..');
+
+export function readPackageVersion(repoRoot = DEFAULT_REPO_ROOT) {
+  const packagePath = join(repoRoot, 'package.json');
+  const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+  return String(pkg.version || '').trim();
+}
+
+export function getExpectedTag(version) {
+  return `v${version}`;
+}
+
+function git(repoRoot, args) {
+  return execFileSync('git', args, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+export function getTagsOnHead(repoRoot = DEFAULT_REPO_ROOT) {
+  const output = git(repoRoot, ['tag', '--points-at', 'HEAD']);
+  return output ? output.split('\n').map((line) => line.trim()).filter(Boolean) : [];
+}
+
+export function hasChangelogEntry(repoRoot, version) {
+  const changelogPath = join(repoRoot, 'landing', 'content', 'changelog.md');
+  if (!existsSync(changelogPath)) return false;
+  const changelog = readFileSync(changelogPath, 'utf8');
+  return changelog.includes(`## v${version} — `);
+}
+
+export function getReleaseNotePath(repoRoot, version) {
+  return join(repoRoot, 'releases', `v${version}.md`);
+}
+
+export function getReleaseNoteChecks(repoRoot, version) {
+  const releaseNotePath = getReleaseNotePath(repoRoot, version);
+  if (!existsSync(releaseNotePath)) {
+    return {
+      exists: false,
+      hasTitle: false,
+      approved: false,
+      hasAnnouncementSection: false,
+      hasChannelsSection: false,
+      path: releaseNotePath,
+    };
+  }
+
+  const content = readFileSync(releaseNotePath, 'utf8');
+  return {
+    exists: true,
+    hasTitle: new RegExp(`^#\\s+v${version}\\b`, 'm').test(content),
+    approved: /^Status:\s*approved\s*$/im.test(content),
+    hasAnnouncementSection: /^##\s+Announcement\s*$/im.test(content),
+    hasChannelsSection: /^##\s+Channels\s*$/im.test(content),
+    path: releaseNotePath,
+  };
+}
+
+export function collectReleaseIssues(repoRoot = DEFAULT_REPO_ROOT) {
+  const version = readPackageVersion(repoRoot);
+  const expectedTag = getExpectedTag(version);
+  const issues = [];
+
+  if (!version) {
+    issues.push('package.json is missing a version.');
+    return issues;
+  }
+
+  const tagsOnHead = getTagsOnHead(repoRoot);
+  if (!tagsOnHead.includes(expectedTag)) {
+    issues.push(`HEAD is missing the matching git tag ${expectedTag}.`);
+  }
+
+  if (!hasChangelogEntry(repoRoot, version)) {
+    issues.push(`landing/content/changelog.md is missing the v${version} entry.`);
+  }
+
+  const releaseNote = getReleaseNoteChecks(repoRoot, version);
+  if (!releaseNote.exists) {
+    issues.push(`Missing release brief: releases/v${version}.md.`);
+  } else {
+    if (!releaseNote.hasTitle) {
+      issues.push(`releases/v${version}.md is missing the '# v${version}' title.`);
+    }
+    if (!releaseNote.approved) {
+      issues.push(`releases/v${version}.md must include 'Status: approved' before publish.`);
+    }
+    if (!releaseNote.hasAnnouncementSection) {
+      issues.push(`releases/v${version}.md is missing the '## Announcement' section.`);
+    }
+    if (!releaseNote.hasChannelsSection) {
+      issues.push(`releases/v${version}.md is missing the '## Channels' section.`);
+    }
+  }
+
+  return issues;
+}
+
+export function runReleaseGuard(repoRoot = DEFAULT_REPO_ROOT) {
+  const version = readPackageVersion(repoRoot);
+  const issues = collectReleaseIssues(repoRoot);
+
+  if (issues.length) {
+    const formatted = issues.map((issue) => `- ${issue}`).join('\n');
+    throw new Error(
+      `Release guard blocked publish for v${version}.\n${formatted}\n\n` +
+        'Fix the release brief, changelog, and git tag before running npm publish again.',
+    );
+  }
+
+  return `Release guard passed for v${version}.`;
+}
+
+const isEntrypoint = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+
+if (isEntrypoint) {
+  try {
+    console.log(runReleaseGuard());
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/lib/skills.mjs

@@ -51,7 +51,6 @@ export const SKILL_CATALOG = [
     skills: [
       { id: 'github',       label: 'GitHub',            desc: 'Issues, PRs, CI via gh CLI' },
       { id: 'gh-issues',    label: 'GitHub Issues Bot', desc: 'Auto-fix issues and open PRs' },
-      { id: 'coding-agent', label: 'Coding Agent',      desc: 'Delegate tasks to Codex / Claude Code' },
       { id: '1password',    label: '1Password',         desc: 'Secrets and credentials via op CLI' },
     ],
   },