@remits/remits-cli 0.1.128 → 0.1.129

package/index.js

@@ -6,16 +6,16 @@
 - L22  Runtime Bootstrap And Shared State
 - L116  Sessions, Account Resolution, And Production Guards
 - L595  Local State, Workspaces, And Verification Evidence
-- L1399  Account Repos, Guide Sync, And Platform Repo
-- L2057  Component Discovery And HTTP Logging
-- L2549  Skill Delivery And TOC Resolution
-- L2859  Auth And Component Staging
-- L3457  Component Summaries, Status, And Sync Gates
-- L5323  Branches, Promotion, Commit, And Test Runs
-- L6562  Tokens, Tools, Verification, And Config
-- L7478  Service Dashboard And WebSocket Listener
-- L9573  Agent And Ticket Workflows
-- L12631  Help, Auto Update, And Command Dispatch
+- L1448  Account Repos, Guide Sync, And Platform Repo
+- L2106  Component Discovery And HTTP Logging
+- L2598  Skill Delivery And TOC Resolution
+- L2908  Auth And Component Staging
+- L3506  Component Summaries, Status, And Sync Gates
+- L5457  Branches, Promotion, Commit, And Test Runs
+- L6682  Tokens, Tools, Verification, And Config
+- L7598  Service Dashboard And WebSocket Listener
+- L9693  Agent And Ticket Workflows
+- L12751  Help, Auto Update, And Command Dispatch
 */
 
 /*
@@ -1107,6 +1107,43 @@ async function postVerificationCommand(api, cwd, session, accountId, command, pa
   return response;
 }
 
+// The repo/session account a packet was recorded from, stated explicitly in its world. `world.accountId` is the
+// account the command EXECUTED as, so an --as-account run carried the subscriber there and a manifest's
+// repoAccountId could never match it. Only fills a missing value; a packet that already knows keeps its own.
+function stampPacketRepoAccount(packet, accountId) {
+  if (!packet || accountId === undefined || accountId === null || accountId === '') return packet;
+  const repoAccountId = Number(accountId);
+  if (!Number.isFinite(repoAccountId)) return packet;
+  if (!packet.world || typeof packet.world !== 'object') packet.world = {};
+  if (packet.world.repoAccountId === undefined || packet.world.repoAccountId === null) {
+    packet.world.repoAccountId = repoAccountId;
+  }
+  return packet;
+}
+
+// A sync packet is evidence of WHAT a sync planned or wrote, not a second copy of the preview. The per-field
+// trunk/branch text a dry run attaches for the admin diff panel is up to 400 KB per sync, and storing it on
+// every packet made one busy envelope 9.4 MB — slow enough that `verify show` timed out. Field NAMES
+// (`changedFields`) stay; the full plan is always one `components sync --dry-run` away.
+function syncEvidencePayload(sync) {
+  if (!sync || typeof sync !== 'object') return sync;
+  const results = sync.syncResults;
+  if (!results || typeof results !== 'object') return sync;
+  const trimmedResults = {};
+  Object.keys(results).forEach((bucket) => {
+    const entries = results[bucket];
+    trimmedResults[bucket] = Array.isArray(entries)
+      ? entries.map((entry) => {
+        if (!entry || typeof entry !== 'object' || !('fields' in entry)) return entry;
+        const copy = Object.assign({}, entry);
+        delete copy.fields;
+        return copy;
+      })
+      : entries;
+  });
+  return Object.assign({}, sync, { syncResults: trimmedResults });
+}
+
 async function appendVerificationPacket(api, cwd, session, accountId, flags, packet, options = {}) {
   const context = activeVerificationContext(cwd, flags, session, accountId);
   const envelopeId = verificationEnvelopeIdForCommand(cwd, flags, context);
@@ -1117,6 +1154,7 @@ async function appendVerificationPacket(api, cwd, session, accountId, flags, pac
     success: true
   }, packet || {});
   finalPacket.envelopeId = envelopeId;
+  stampPacketRepoAccount(finalPacket, accountId);
   writeLocalVerificationPacket(cwd, envelopeId, finalPacket);
   try {
     const response = await postVerificationCommand(api, cwd, session, accountId, 'packet', {
@@ -1281,6 +1319,17 @@ function buildCommandWorld(response, fallback = {}) {
   };
 }
 
+// A variant sync writes overlays on exactly one component branch; say so in the packet world, where a manifest's
+// componentBranch is compared. Without it no sync_mutation could satisfy a manifest that declares one.
+function syncPacketWorld(response, world, branchName) {
+  const sync = (response && response.sync) || {};
+  const out = Object.assign({}, world || {});
+  if (sync.mode === 'variant' && !out.componentBranch) {
+    out.componentBranch = sync.branchName || branchName || null;
+  }
+  return out;
+}
+
 function laneContentHashFrom(response) {
   if (!response) return null;
   const laneSummary = response.laneSummary || (response.staging && response.staging.laneSummary) ||
@@ -4542,7 +4591,7 @@ async function syncComponentsCommand(rawFlags) {
     type: response.sync && response.sync.dryRun ? 'sync_dry_run' : 'sync_mutation',
     success: response.success !== false,
     claim: response.sync && response.sync.dryRun ? 'Component sync dry-run observed' : 'Component sync completed',
-    world: buildCommandWorld(response, { accountId, dataMode, branchName, workspace, host: normalizeBaseUrl(baseUrl), sourceLayer: response.sync && response.sync.mode === 'variant' ? 'variant' : 'trunk' }),
+    world: syncPacketWorld(response, buildCommandWorld(response, { accountId, dataMode, branchName, workspace, host: normalizeBaseUrl(baseUrl), sourceLayer: response.sync && response.sync.mode === 'variant' ? 'variant' : 'trunk' }), branchName),
     revision: Object.assign(collectVerificationSource(cwd, flags), {
       platformSyncedSha: response.sync && (response.sync.postSyncSha || response.sync.branchHeadSha)
     }),
@@ -4551,7 +4600,7 @@ async function syncComponentsCommand(rawFlags) {
       { category: response.sync && response.sync.dryRun ? 'sync_dry_run' : 'sync_mutation', summary }
     ],
     rawRefs: { command: 'components sync' },
-    sync: response.sync,
+    sync: syncEvidencePayload(response.sync),
     summary
   }, { quiet: flagEnabled(flags.json) });
 
@@ -4582,11 +4631,31 @@ async function syncComponentsCommand(rawFlags) {
     return response;
   }
   console.log('Components sync:', JSON.stringify(response, null, 2));
+  printVariantSyncWrites(summary);
   printPromotionSignals(response);
   failOnSyncGate(gate);
   return response;
 }
 
+// The one line a person needs from a variant sync of a long-lived branch: what THIS sync changes, apart from
+// the overlays it merely re-confirms (the totals alone read the same on every sync).
+function printVariantSyncWrites(summary) {
+  const writes = summary && summary.writes;
+  if (!writes || summary.mode !== 'variant') return;
+  console.log('');
+  if (!writes.known) {
+    console.log('Overlay changes: unknown (this platform does not report which overlays were already stored).');
+    return;
+  }
+  const verb = summary.dryRun ? 'would change' : 'changed';
+  console.log('Overlay changes: ' + writes.changed + ' ' + verb + ', ' + writes.alreadyCurrent + ' already current, ' +
+    writes.removed + ' removed, ' + writes.pruned + ' pruned (converged back to trunk)');
+  (writes.changedComponents || []).forEach((entry) => {
+    console.log('  ' + String(entry.type || 'component').toLowerCase() + ':' + (entry.id != null ? entry.id : entry.name) +
+      (entry.name && entry.id != null ? '  ' + entry.name : ''));
+  });
+}
+
 // A sync is a step in a longer loop, and the steps after it are the ones that get skipped — so print what
 // the server just observed about this branch's relationship to trunk, not only what it wrote.
 function printPromotionSignals(response) {
@@ -4755,7 +4824,9 @@ function syncPlanEntries(response) {
         type: String(entry.type || entry.kind || 'component').toLowerCase(),
         id: entry.id == null ? null : String(entry.id),
         name: entry.name || null,
-        path: entry.path || null
+        path: entry.path || null,
+        // true when the overlay already stored for this component matches the branch: re-confirmed, not changed.
+        storedCurrent: entry.storedCurrent === true
       });
     });
   });
@@ -4801,6 +4872,8 @@ function evaluateSyncGates(response, flags, changedFromWorkingTree, cwd) {
   const expectedRemoved = parseExpectedRemoved(flags);
   const violations = [];
   const checks = {};
+  // Overlays the --changed-only gate did not count because the platform already stores them with this content.
+  let alreadyCurrentCount = null;
 
   if (flagEnabled(flags['fail-on-errors']) || flagEnabled(flags.failOnErrors)) {
     checks.failOnErrors = errors.length === 0;
@@ -4840,13 +4913,20 @@ function evaluateSyncGates(response, flags, changedFromWorkingTree, cwd) {
       const allowedIds = new Set(changedSet.filter((c) => c.id != null).map((c) => c.type + ':' + c.id));
       const allowedNames = new Set(changedSet.filter((c) => c.name).map((c) => c.type + ':' + String(c.name).toLowerCase()));
       const allowedPaths = new Set([].concat(...changedSet.map((c) => (Array.isArray(c.paths) ? c.paths : []))).map(String));
+      // An overlay the platform ALREADY stores with this exact content is not something this sync changes. A
+      // long-lived branch (a permanent customer release train) re-reports every one of its overlays on every sync,
+      // so counting those made the gate refuse ordinary work with "plan touches 80 components" and blame a stale
+      // branch that `components promotion` reported as ready. Removals are never exempt.
+      const alreadyCurrent = entries.filter((entry) => entry.storedCurrent && entry.bucket !== 'removed');
       const unexpected = entries.filter((entry) => {
+        if (entry.storedCurrent && entry.bucket !== 'removed') return false;
         if (entry.path && allowedPaths.has(String(entry.path))) return false;
         if (entry.id != null && allowedIds.has(entry.type + ':' + entry.id)) return false;
         if (entry.name && allowedNames.has(entry.type + ':' + String(entry.name).toLowerCase())) return false;
         return true;
       });
       checks.changedOnly = unexpected.length === 0;
+      alreadyCurrentCount = alreadyCurrent.length;
       if (unexpected.length) {
         // Name the most likely cause instead of only the symptom. An empty changed set with a non-empty
         // plan is the ordinary post-commit state, not evidence that the plan is dangerous.
@@ -4858,11 +4938,10 @@ function evaluateSyncGates(response, flags, changedFromWorkingTree, cwd) {
           // physically carries old copies of files nobody on it touched, and a variant sync turns each of
           // those into an unrelated override. Naming the cause is the difference between a gate that
           // stops the damage and a gate that also tells you how to clear it.
-          : (changedSet.length && unexpected.length > changedSet.length)
-            ? '\n    Most likely cause: this branch is BEHIND trunk and still carries old copies of files ' +
-              'it never changed. A variant sync turns each of those into an unrelated override.' +
-              '\n    Next step: merge trunk into this branch, push, then re-run the same command:' +
-              '\n      git merge <trunk> && git push origin <branch>'
+          // With --changed-since the empty-set hint above does not apply, so a ref that shows no committed change
+          // still needs the cause named — that is exactly the behind-trunk branch whose plan is all stale copies.
+          : ((changedSet.length || since) && unexpected.length > changedSet.length)
+            ? staleBranchGateHint(response)
             : '';
         violations.push('--changed-only: plan touches ' + unexpected.length + ' component(s) this checkout did not change: ' +
           unexpected.slice(0, 20).map(syncEntryToken).join(', ') + (unexpected.length > 20 ? ', ...' : '') + hint);
@@ -4870,7 +4949,28 @@ function evaluateSyncGates(response, flags, changedFromWorkingTree, cwd) {
     }
   }
 
-  return { violations, checks };
+  return { violations, checks, alreadyCurrentCount };
+}
+
+// Name the stale-branch cause only when the platform's own git comparison says the branch IS behind trunk. The
+// hint used to fire on the count alone, and told agents on an up-to-date permanent branch to merge trunk in.
+function staleBranchGateHint(response) {
+  const sync = (response && response.sync) || {};
+  const comparison = sync.branchComparison || (sync.promotion && sync.promotion.git) || null;
+  const behindBy = comparison && Number.isFinite(Number(comparison.behindBy)) ? Number(comparison.behindBy) : null;
+  if (behindBy !== null && behindBy > 0) {
+    return '\n    Most likely cause: this branch is BEHIND trunk by ' + behindBy + ' commit(s) and still carries old copies ' +
+      'of files it never changed. A variant sync turns each of those into an unrelated override.' +
+      '\n    Next step: merge trunk into this branch, push, then re-run the same command:' +
+      '\n      git merge <trunk> && git push origin <branch>';
+  }
+  if (behindBy === 0) {
+    return '\n    The branch is current with trunk, so these are not stale copies: they are overlays whose stored content ' +
+      'differs from this branch but that this checkout\'s changed set does not name. Widen --changed-since to the ' +
+      'commit the platform last synced (components promotion shows it), or review the plan with --dry-run.';
+  }
+  return '\n    The platform could not compare this branch with trunk. Run `remits-cli components promotion` to see ' +
+    'whether it is behind before merging anything.';
 }
 
 function failOnSyncGate(gate) {
@@ -5163,6 +5263,36 @@ function printTrunkSyncWarning(trunkBranch, options) {
   emit('  For a gated plan, work on a variant branch instead.');
 }
 
+function variantSyncWrites(overridden, added, removed, unchanged) {
+  const overlays = overridden.concat(added);
+  const known = overlays.every((entry) => entry && typeof entry.storedCurrent === 'boolean');
+  const pruned = unchanged.filter((entry) => entry && entry.pruned === true).length;
+  if (!known) {
+    return { changed: null, alreadyCurrent: null, removed: removed.length, pruned, known: false };
+  }
+  const changed = overlays.filter((entry) => !entry.storedCurrent);
+  return {
+    changed: changed.length,
+    changedComponents: changed.slice(0, 50).map((entry) => ({ type: entry.type, name: entry.name, id: entry.id })),
+    alreadyCurrent: overlays.length - changed.length,
+    removed: removed.length,
+    pruned,
+    known: true
+  };
+}
+
+// `|` separates selectors and a repeated --names needs no separator. A COMMA is never a separator any more: it
+// is sent as part of the selector, and the platform matches a comma-bearing selector either as one whole case name
+// ("… the complete statement, offer, and surcharge matrix") or, for older invocations, as its comma-separated
+// parts (Test.selectorMatchesCase). Splitting in the CLI took the real name apart before the platform could see it.
+function parseTestCaseSelectors(rawNames) {
+  return (Array.isArray(rawNames) ? rawNames : [rawNames])
+    .filter((value) => value !== undefined && value !== null)
+    .flatMap((value) => String(value).split('|'))
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
 function buildSyncSummary(response) {
   const sync = (response && response.sync) || {};
   const results = sync.syncResults || {};
@@ -5292,6 +5422,10 @@ function buildSyncSummary(response) {
     gateViolations: (response && response.gateViolations) || null,
     overridden: overridden.length,
     added: added.length,
+    // What THIS sync changes, as opposed to the whole overlay set it re-reports. `overridden`/`added` are totals,
+    // so five consecutive syncs of a long-lived branch all printed `overridden: 48, added: 32` and nobody could see
+    // which overlays their own sync moved. Null counts mean the platform predates the storedCurrent flag.
+    writes: variantSyncWrites(overridden, added, removed, unchanged),
     removed: removed.map((entry) => ({
       type: entry.type,
       kind: entry.kind,
@@ -6345,26 +6479,12 @@ async function testCommand(flags) {
     throw new Error('Missing --test <id-or-name>');
   }
 
-  // Test case names are English prose, so COMMAS occur in them naturally. A comma-delimited selector
-  // therefore split a legitimate name in half, matched nothing, and (before the server learned to
-  // report unmatched selectors) reported a clean run of zero cases. `|` is the delimiter now; the
-  // comma still works when no `|` is present, so existing invocations keep behaving as before.
-  // `--names` may also be repeated, which needs no delimiter at all.
+  // Test case names are English prose, so COMMAS occur in them naturally. `|` (or repeating --names) is the
+  // only delimiter; see parseTestCaseSelectors for how a comma-bearing selector is matched.
   const rawNames = flags.names === undefined || flags.names === null
     ? []
     : (Array.isArray(flags.names) ? flags.names : [flags.names]);
-  const repeated = rawNames.length > 1;
-  const names = rawNames
-    .flatMap((value) => {
-      const text = String(value);
-      if (text.includes('|')) return text.split('|');
-      // Comma-splitting is the legacy behaviour, kept so existing invocations still work. It is applied
-      // ONLY to a single --names value: repeating the flag is already unambiguous, so splitting there
-      // would take a deliberate literal name back apart.
-      return repeated ? [text] : text.split(',');
-    })
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const names = parseTestCaseSelectors(rawNames);
 
   const api = buildAxios(baseUrl, session.token);
   // --as-account runs the Test AS a (descendant) subscriber account, so that account's relationship

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remits/remits-cli",
-  "version": "0.1.128",
+  "version": "0.1.129",
   "description": "Local CLI for auth, component sync, and live test execution against Remits",
   "license": "MIT",
   "private": false,

package/skills/remits-cli/references/branch-variants.md

@@ -363,7 +363,9 @@ The analogous hazard is different, and you must still respect it:
   explicitly.
 - **Use `components sync --dry-run` before risky variant syncs.** It reports `overridden`, `added`,
   `removed`, `unchanged`, `skipped`, and `errors` without writing rows, caching the sync SHA, or clearing
-  staging. Existing overlay ids appear as `variantId`; an `unchanged` row with `pruned:true` means the
+  staging. `overridden`/`added` are the branch's WHOLE overlay set; read the `Overlay changes:` line (or
+  `writes` in `--summary`) for what this sync actually changes, and `storedCurrent: true` on an entry for
+  an overlay that is already stored as-is. Existing overlay ids appear as `variantId`; an `unchanged` row with `pruned:true` means the
   branch has converged back to trunk and the overlay would be removed. It is rejected on trunk, and
   `components commit --dry-run` is unsupported because `commit` performs compile validation and local git
   writes before syncing.

package/skills/remits-cli/references/command-reference.md

@@ -341,8 +341,9 @@ For tests specifically:
 - If `--data-mode` is omitted, `remits-cli test run` uses `test` and sends `dataModeSource:"cliDefault"`.
   An explicit `--data-mode prod` sends `dataModeSource:"explicitFlag"` so production test runs are
   auditable from the server status payload even when the original terminal history is gone.
-- `--names` is `|`-delimited (a comma still splits a single value) and may be repeated; an unmatched
-  selector fails the run instead of reporting zero cases as success.
+- `--names` is `|`-delimited and may be repeated. A selector containing commas matches a case with that
+  exact name first, else its comma-separated parts; an unmatched selector fails the run instead of
+  reporting zero cases as success.
 - `--as-account <ID>` runs AS a descendant subscriber so its edge selects the component branch
   (*"what does customer X get?"*); `--variant-branch <name>` probes a branch from any checkout
   (*"what does branch Y look like?"*), and `--variant-branch none` forces production/subscription semantics.