axstack 0.20.30 → 0.20.31

package/skills/axstack-watch/references/watch-runtime.md

@@ -90,8 +90,10 @@ busy, missing, fenced, protected, or permission-held driver is never interrupted
 or replaced.
 
 The driver records one Notification policy: `axstack-relay` Telegram home only
-for a user-decision hold, first merge-ready and fully merged milestones (at most
-two), or serious-risk hold. Quiet ticks never notify.
+for a user-decision hold (including spec and npm approval), merge-ready or
+merged milestones (at most two across implementation and release), or a
+serious-risk hold.
+Quiet ticks never notify.
 
 The driver alone routes repair. Re-read remote head/base and native ownership.
 Independent PRs may repair in parallel in separate Orca child worktrees within
@@ -116,8 +118,13 @@ re-read all feedback and approvals at the current head before readiness.
 Re-reading approvals checks current state, not re-requesting review from a
 human who already approved.
 
-Stop the chosen wake only when every watched PR is merged or closed, the user cancels,
-or it expires. The driver stops a harness-native wake and verifies its stop receipt;
+Stop the chosen wake only when every watched PR is merged or closed and the
+run's release step is settled or not applicable, the user cancels, or it
+expires. Without an Autopilot or Release record, the release step is not
+applicable to this watch. A required PR closed without merging records a
+decision hold and the wake remains active while unexpired until the user
+resolves scope, cancels, or the wake expires; the run is not release-eligible.
+The driver stops a harness-native wake and verifies its stop receipt;
 a failed or uncertain stop is a hold. Re-read membership and confirm no ambiguous
 publication or unsettled pass; cancellation
 prevents new work but does not prove running workers exited. The observer may

package/src/installer.js

@@ -635,8 +635,16 @@ export async function installBundle({
           const newIds = new Set(bundle.bundleRoles.map((role) => role.id));
           const addedRoleIds = bundle.bundleRoles.filter((role) => !oldIds.has(role.id)).map((role) => role.id);
           const removedRoleIds = old.roles.filter((role) => role?.id && !newIds.has(role.id)).map((role) => role.id);
+          const oldById = new Map(old.roles.filter((role) => role?.id).map((role) => [role.id, role]));
+          const changedRoleModels = bundle.bundleRoles.flatMap((role) => {
+            const previous = oldById.get(role.id);
+            if (!previous) return [];
+            const fields = ['modelClass', 'model'].filter((field) => previous[field] !== role[field]);
+            return fields.length ? [`${role.id} (${fields.join(', ')})`] : [];
+          });
           summary.addedRoleIds = addedRoleIds;
           summary.removedRoleIds = removedRoleIds;
+          summary.changedRoleModels = changedRoleModels;
         }
       } catch { /* No reliable role-ID diff for malformed prior bytes. */ }
     }

package/src/roles.js

@@ -4,19 +4,33 @@ const PROVIDER_BOUNDS = Object.freeze({
   'claude-only': new Set(['claude']),
 });
 
+const CLASS_PROVIDERS = Object.freeze({
+  fable: 'claude', opus: 'claude', sonnet: 'claude', haiku: 'claude',
+  astra: 'codex', sol: 'codex', luna: 'codex',
+});
+
+export function deriveModelClass(model) {
+  if (typeof model !== 'string') return null;
+  return model.match(/^gpt-(\d+(?:\.\d+)*)-(astra|sol|luna)$/)?.[2]
+    ?? model.match(/^claude-(fable|opus|sonnet|haiku)-/)?.[1]
+    ?? null;
+}
+
 const AUTHORED_ROUTES = Object.freeze({
   mixed: {
-    'codex/gpt-6-sol': ['axstack-reviewer-secondary', 'claude/claude-opus-5-5', 'medium'],
-    'claude/claude-opus-5-5': ['axstack-reviewer-primary', 'codex/gpt-6-sol', 'high'],
+    'codex/sol': ['axstack-reviewer-secondary', 'claude/opus', 'medium'],
+    'claude/opus': ['axstack-reviewer-primary', 'codex/sol', 'high'],
   },
   'codex-only': {
-    'codex/gpt-6-sol': ['axstack-reviewer-secondary', 'codex/gpt-6-luna', 'xhigh'],
+    'codex/sol': ['axstack-reviewer-secondary', 'codex/luna', 'xhigh'],
   },
   'claude-only': {
-    'claude/claude-opus-5-5': ['axstack-reviewer-secondary', 'claude/claude-sonnet-5-5', 'high'],
+    'claude/opus': ['axstack-reviewer-secondary', 'claude/sonnet', 'high'],
   },
 });
 
+const roleClass = (role) => role.modelClass ?? deriveModelClass(role.model);
+
 export function assertBundleRoles(roles) {
   if (!Array.isArray(roles) || roles.length === 0) {
     throw new Error('invalid bundle roles: expected a non-empty roles array');
@@ -36,12 +50,22 @@ export function assertBundleRoles(roles) {
     }
     if (ids.has(role.id)) throw new Error(`invalid bundle roles: duplicate role ID ${role.id}`);
     ids.add(role.id);
-    if (!Object.hasOwn(role, 'model')) {
+    const hasClass = Object.hasOwn(role, 'modelClass');
+    if (hasClass && (typeof role.modelClass !== 'string' || !Object.hasOwn(CLASS_PROVIDERS, role.modelClass))) {
+      throw new Error(`invalid bundle roles: ${role.id} has an unsupported modelClass`);
+    }
+    if (hasClass && role.provider !== CLASS_PROVIDERS[role.modelClass]) {
+      throw new Error(`invalid bundle roles: ${role.id} model class does not match provider`);
+    }
+    if (!hasClass && !Object.hasOwn(role, 'model')) {
       throw new Error('invalid bundle roles: model must be a non-empty string or explicit null');
     }
-    if (role.model !== null && (typeof role.model !== 'string' || role.model.trim() === '')) {
+    if (Object.hasOwn(role, 'model') && role.model !== null && (typeof role.model !== 'string' || role.model.trim() === '')) {
       throw new Error('invalid bundle roles: model must be a non-empty string or explicit null');
     }
+    if (hasClass && typeof role.model === 'string' && deriveModelClass(role.model) !== role.modelClass) {
+      throw new Error(`invalid bundle roles: ${role.id} model pin does not match model class`);
+    }
     for (const field of ['icon', 'color', 'modeId', 'thinkingOptionId', 'notes']) {
       if (role[field] !== undefined && typeof role[field] !== 'string') {
         throw new Error(`invalid bundle roles: ${field} must be a string when present`);
@@ -75,7 +99,7 @@ export function assessRoleReadiness(roles, preset) {
     if (!bounds.has(role.provider)) {
       gaps.push(`${role.id} provider ${JSON.stringify(role.provider)} is outside ${preset} bounds (${[...bounds].join('|')})`);
     }
-    if (!isIntentionalAbsence(role) && (typeof role.model !== 'string' || role.model.trim() === '')) {
+    if (!isIntentionalAbsence(role) && !Object.hasOwn(role, 'modelClass') && (typeof role.model !== 'string' || role.model.trim() === '')) {
       gaps.push(`${role.id} requires a configured model`);
     }
   }
@@ -86,7 +110,11 @@ export function assessRoleReadiness(roles, preset) {
   const primary = byId.get('axstack-reviewer-primary');
   const secondary = byId.get('axstack-reviewer-secondary');
   if (primary && secondary) {
-    if (primary.model === secondary.model) gaps.push('reviewer pair must use two distinct models');
+    const bothResolved = typeof primary.model === 'string' && typeof secondary.model === 'string';
+    const sameReviewer = bothResolved
+      ? primary.model === secondary.model
+      : roleClass(primary) !== null && roleClass(primary) === roleClass(secondary);
+    if (sameReviewer) gaps.push('reviewer pair must use two distinct models');
     if (preset === 'mixed' && primary.provider === secondary.provider) {
       gaps.push('mixed reviewer pair must use different providers');
     }
@@ -94,14 +122,14 @@ export function assessRoleReadiness(roles, preset) {
 
   const author = byId.get('axstack-author');
   if (author) {
-    const authorRoute = `${author.provider}/${author.model}`;
+    const authorRoute = `${author.provider}/${roleClass(author) ?? author.model}`;
     const route = AUTHORED_ROUTES[preset]?.[authorRoute];
     if (!route) {
       gaps.push(`authored routing gap: unsupported axstack-author route ${authorRoute}`);
     } else {
       const [reviewerId, reviewerRoute, effort] = route;
       const reviewer = byId.get(reviewerId);
-      if (!reviewer || `${reviewer.provider}/${reviewer.model}` !== reviewerRoute || reviewer.thinkingOptionId !== effort) {
+      if (!reviewer || `${reviewer.provider}/${roleClass(reviewer)}` !== reviewerRoute || reviewer.thinkingOptionId !== effort) {
         gaps.push(`authored routing gap: ${reviewerId} must be ${reviewerRoute}/${effort} for author ${authorRoute}`);
       }
     }