incremnt 0.8.7 → 0.8.9

package/src/training-language-public-terms.json

@@ -0,0 +1,97 @@
+{
+  "version": 1,
+  "approvedTerms": [
+    "Training",
+    "Progress",
+    "Recovery",
+    "Muscles",
+    "Plan",
+    "Driver",
+    "Workout",
+    "Rest",
+    "Effort"
+  ],
+  "bannedPublicPhrases": [
+    {
+      "term": "muscle work",
+      "replacement": "muscles trained",
+      "rationale": "Avoid internal score wording for muscle group training."
+    },
+    {
+      "term": "muscle coverage",
+      "replacement": "muscles trained",
+      "rationale": "Coverage is a score-engine concept, not user-facing coaching language."
+    },
+    {
+      "term": "scored workouts",
+      "replacement": "workouts",
+      "rationale": "Users log workouts; scoring eligibility is internal."
+    },
+    {
+      "term": "strength work",
+      "replacement": "training",
+      "rationale": "Use broad training language unless a strength-specific set is being described."
+    },
+    {
+      "term": "health signals",
+      "replacement": "sleep, heart rate, HRV, soreness, and recent training",
+      "rationale": "Name the concrete recovery inputs instead of an analytics abstraction."
+    },
+    {
+      "term": "training signal",
+      "replacement": "recent training",
+      "rationale": "Signal is an internal data-quality term."
+    },
+    {
+      "term": "readiness signal",
+      "replacement": "recovery data",
+      "rationale": "Signal is an internal data-quality term."
+    },
+    {
+      "term": "observation window",
+      "replacement": "recent period",
+      "rationale": "Observation window is an implementation detail."
+    },
+    {
+      "term": "weighted drag",
+      "replacement": "main limiter",
+      "rationale": "Weighted scoring math should not leak to users."
+    },
+    {
+      "term": "weighted points",
+      "replacement": "points",
+      "rationale": "Weighted scoring math should not leak to users."
+    }
+  ],
+  "bannedPublicWords": [
+    {
+      "term": "stimulus",
+      "replacement": "training",
+      "rationale": "Stimulus is score-engine vocabulary."
+    },
+    {
+      "term": "coverage",
+      "replacement": "muscles trained",
+      "rationale": "Coverage is score-engine vocabulary."
+    },
+    {
+      "term": "adherence",
+      "replacement": "following the plan",
+      "rationale": "Adherence sounds clinical and dashboard-like."
+    },
+    {
+      "term": "component",
+      "replacement": "driver",
+      "rationale": "Component is implementation structure; Driver is approved public language."
+    },
+    {
+      "term": "signal",
+      "replacement": "data",
+      "rationale": "Signal is internal analytics language."
+    }
+  ],
+  "notes": [
+    "Internal enum, schema, database, and fixture terms may keep existing names when they are not user-facing.",
+    "Driver is approved as the public word for why a score or recommendation moved."
+  ]
+}

package/src/training-language.js

@@ -0,0 +1,94 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const contractPath = path.join(moduleDir, 'training-language-public-terms.json');
+
+let cachedContract = null;
+
+function loadContractFromDisk() {
+  const raw = readFileSync(contractPath, 'utf8');
+  return JSON.parse(raw);
+}
+
+export function loadPublicTrainingLanguageContract() {
+  if (!cachedContract) {
+    cachedContract = loadContractFromDisk();
+  }
+  return cachedContract;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function boundaryPattern(term) {
+  const escaped = escapeRegExp(term).replace(/\s+/g, '\\s+');
+  return new RegExp(`(?<![\\p{L}\\p{N}_-])${escaped}(?![\\p{L}\\p{N}_-])`, 'giu');
+}
+
+function normalizeRule(rule, kind) {
+  if (typeof rule === 'string') {
+    return { kind, term: rule, replacement: null, rationale: null };
+  }
+  return {
+    kind,
+    term: rule.term,
+    replacement: rule.replacement ?? null,
+    rationale: rule.rationale ?? null
+  };
+}
+
+export function publicTrainingLanguageViolations(text, options = {}) {
+  if (typeof text !== 'string' || text.length === 0) return [];
+  const contract = options.contract ?? loadPublicTrainingLanguageContract();
+  const rules = [
+    ...(contract.bannedPublicPhrases ?? []).map((rule) => normalizeRule(rule, 'phrase')),
+    ...(contract.bannedPublicWords ?? []).map((rule) => normalizeRule(rule, 'word'))
+  ];
+
+  const violations = [];
+  for (const rule of rules) {
+    if (!rule.term) continue;
+    const pattern = boundaryPattern(rule.term);
+    const matches = text.matchAll(pattern);
+    for (const match of matches) {
+      violations.push({
+        kind: rule.kind,
+        term: rule.term,
+        match: match[0],
+        index: match.index,
+        replacement: rule.replacement,
+        rationale: rule.rationale
+      });
+    }
+  }
+  return violations;
+}
+
+export function assertPublicTrainingLanguage(text, options = {}) {
+  const violations = publicTrainingLanguageViolations(text, options);
+  if (violations.length > 0) {
+    const terms = violations.map((violation) => violation.term).join(', ');
+    throw new Error(`Public training language violation: ${terms}`);
+  }
+  return true;
+}
+
+export function replacePublicTrainingLanguageTerms(text, options = {}) {
+  if (typeof text !== 'string' || text.length === 0) return text;
+  const contract = options.contract ?? loadPublicTrainingLanguageContract();
+  const rules = [
+    ...(contract.bannedPublicPhrases ?? []).map((rule) => normalizeRule(rule, 'phrase')),
+    ...(contract.bannedPublicWords ?? []).map((rule) => normalizeRule(rule, 'word'))
+  ]
+    .filter((rule) => rule.term && rule.replacement)
+    .sort((a, b) => b.term.length - a.term.length);
+
+  let output = text;
+  for (const rule of rules) {
+    output = output.replace(boundaryPattern(rule.term), rule.replacement);
+  }
+  return output;
+}

package/src/transport.js

@@ -1,10 +1,11 @@
 import { readSnapshot, resolveSnapshotSource } from './local.js';
 import { createRemoteTransport } from './remote.js';
 import { askMissingObservationFollowUpContext, askObservationFollowUpContext, askRoutedContext } from './ask-coach.js';
+import { contractVersion } from './contract.js';
 import { sanitizeHistory } from './prompt-security.js';
 import { executeCoachReadTool, executeReadCommand, shouldKeepCurrentCoachObservation } from './queries.js';
 import { isSessionExpired } from './state.js';
-import { fetchRemoteContract, refreshRemoteSession } from './auth.js';
+import { fetchRemoteContract, refreshRemoteContractMetadata, refreshRemoteSession } from './auth.js';
 import { resolveConfiguredBaseUrl } from './service-url.js';
 
 function prefersLocal(options) {
@@ -167,6 +168,11 @@ export async function createTransport(options, sessionState) {
       }
     }
 
+    if (!options['dry-run'] && !expired && baseUrl && session.auth?.accessToken && Number(session.transport?.contractVersion) !== contractVersion) {
+      const refreshed = await refreshRemoteContractMetadata(baseUrl, session.auth.accessToken, session);
+      session = refreshed.session;
+    }
+
     return {
       ...createRemoteTransport({
         ...sessionState,

package/src/validate.js

@@ -40,6 +40,16 @@ export function validateOption(opt, rawValue) {
 
   const format = opt.format ?? (opt.type === 'number' ? 'number' : 'text');
 
+  if (opt.type === 'boolean') {
+    if (rawValue === true || rawValue === false) return rawValue;
+    if (typeof rawValue === 'string') {
+      const normalized = rawValue.trim().toLowerCase();
+      if (['true', '1', 'yes'].includes(normalized)) return true;
+      if (['false', '0', 'no'].includes(normalized)) return false;
+    }
+    throw new ValidationError(`--${opt.name} must be a boolean flag`, { option: opt.name, format: 'boolean' });
+  }
+
   if (rawValue === null) {
     throw new ValidationError(`--${opt.name} must not be null`, { option: opt.name, format, code: 'MISSING_OPTION' });
   }
@@ -129,7 +139,7 @@ export function validateOptions(commandEntry, options) {
   const out = { ...options };
   for (const opt of commandEntry.options) {
     if (out[opt.name] === undefined) continue;
-    if (out[opt.name] === true) {
+    if (out[opt.name] === true && opt.type !== 'boolean') {
       const format = opt.format ?? (opt.type === 'number' ? 'number' : 'text');
       throw new ValidationError(`--${opt.name} requires a value`, { option: opt.name, format, code: 'MISSING_OPTION' });
     }