@remits/remits-cli 0.1.122 → 0.1.124

package/index.js

@@ -1819,6 +1819,19 @@ function resolveSessionContext(cwd, flags) {
   };
 }
 
+/**
+ * Record the FILE identity of a component (type + filename id, or type + filename stem) on an object without
+ * sending it anywhere. Non-enumerable, so JSON payloads and the content hash never see it.
+ *
+ * It exists because a component is named twice: by its files, and by its `.meta.yml` `name:`. For a `new_`
+ * file there is no id, so the two can disagree (`new_PDFStatement` vs `name: PDF Statement`), and the file
+ * identity is the only thing both the payload and the git changed set agree on.
+ */
+function withFileKey(target, key) {
+  Object.defineProperty(target, 'fileKey', { value: key, enumerable: false, configurable: true });
+  return target;
+}
+
 function collectComponents(cwd) {
   const mapping = {
     schemas: 'schema',
@@ -1866,7 +1879,7 @@ function collectComponents(cwd) {
         //
         // A partial stage (mcp_component_edit writing one field) deliberately does NOT set this and
         // keeps the merge semantics it needs.
-        byKey.set(key, { type, id, name, metadataAuthoritative: true });
+        byKey.set(key, withFileKey({ type, id, name, metadataAuthoritative: true }, key));
       }
       const component = byKey.get(key);
       const filePath = path.join(dir, fileName);
@@ -2033,11 +2046,11 @@ function changedComponentsFromWorkingTree(cwd) {
     if (!entry.statuses.includes(status)) entry.statuses.push(status);
     if (!entry.paths.includes(info.path)) entry.paths.push(info.path);
   }
-  return Array.from(byKey.values()).map((entry) => ({
+  return Array.from(byKey.entries()).map(([key, entry]) => withFileKey({
     ...entry,
     fields: entry.fields.sort(),
     paths: entry.paths.sort()
-  })).sort((a, b) => {
+  }, key)).sort((a, b) => {
     const typeCmp = String(a.type).localeCompare(String(b.type));
     if (typeCmp !== 0) return typeCmp;
     return String(a.id || a.name || '').localeCompare(String(b.id || b.name || ''));
@@ -2071,7 +2084,7 @@ function changedComponentsSinceRef(cwd, ref) {
     const info = componentPathInfo(cwd, filePath);
     if (!info) continue;
     if (!byKey.has(info.key)) {
-      byKey.set(info.key, { type: info.type, id: info.id, name: info.name, fields: [], paths: [] });
+      byKey.set(info.key, withFileKey({ type: info.type, id: info.id, name: info.name, fields: [], paths: [] }, info.key));
     }
     const entry = byKey.get(info.key);
     if (!entry.fields.includes(info.field)) entry.fields.push(info.field);
@@ -2759,7 +2772,7 @@ async function pushComponentsCommand(flags) {
   const dataMode = resolveDataMode(flags, session);
   const requestedMode = String(flags.mode || 'stage').toLowerCase();
   const mode = requestedMode === 'push' ? 'stage' : requestedMode;
-  const changedFromWorkingTree = changedComponentsFromWorkingTree(cwd);
+  const changedFromGit = changedComponentsFromWorkingTree(cwd);
 
   // WHAT this stage is. Three shapes, and the difference between them is the difference between a lane
   // that reads as "7 components in flight" and one that reads as "115 staged":
@@ -2779,6 +2792,8 @@ async function pushComponentsCommand(flags) {
   const emptyWorksetPolicy = normalizeEmptyWorksetPolicy(flags);
 
   let components = collectComponents(cwd);
+  // Named the way the payload is named, BEFORE anything compares the two — see alignChangedSetWithComponents.
+  const changedFromWorkingTree = alignChangedSetWithComponents(changedFromGit, components);
   // Changes git reported that a component payload cannot carry — a deleted component file has nothing to
   // stage, and Redis staging has no way to say "hide this during CLI-scoped runs". Removing its staged
   // entry falls back to the committed row, so the component still resolves. Reported out loud rather than
@@ -2788,10 +2803,8 @@ async function pushComponentsCommand(flags) {
     if (changedFromWorkingTree === null) {
       throw new Error('--changed-only needs a git working tree to establish the changed set, and this directory is not one.');
     }
-    const wanted = new Set(changedFromWorkingTree.map((entry) =>
-      entry.type + ':' + (entry.id ? 'id:' + entry.id : 'name:' + String(entry.name || '').toLowerCase())));
-    components = components.filter((component) => wanted.has(
-      component.type + ':' + (component.id ? 'id:' + component.id : 'name:' + String(component.name || '').toLowerCase())));
+    const wanted = new Set(changedFromWorkingTree.map(stageIdentityKey));
+    components = components.filter((component) => wanted.has(stageIdentityKey(component)));
     if (!components.length && !(worksetReplace && emptyWorksetPolicy === 'clear')) {
       // Deliberately NOT an error, and deliberately not a clear. An agent that has not edited anything yet
       // is in an ordinary state; failing its loop teaches it nothing, and reconciling the lane to an empty
@@ -2943,16 +2956,71 @@ function normalizeEmptyWorksetPolicy(flags) {
  *
  * Returns [] when git could not answer, because "nothing is unrepresentable" would be a claim.
  */
+/**
+ * The ONE identity a stage compares components by: type + id, or type + name for an id-less `new_` file.
+ * The workset filter and the unrepresentable check used to spell this out separately.
+ */
+function stageIdentityKey(entry) {
+  return entry.type + ':' + (entry.id ? 'id:' + entry.id : 'name:' + String(entry.name || '').toLowerCase());
+}
+
+/**
+ * Name each git-changed component the way its payload is named.
+ *
+ * The changed set is built from FILENAMES; the payload takes `name` from the `.meta.yml`. For a `new_` file
+ * there is no id, so `new_PDFStatement.groovy` + `name: PDF Statement` produced two identities for one
+ * component: `--workset` filtered it out, it was reported as "no-local-files", and the platform (which
+ * matches the changed set against the stored name) never marked it as workset — so a full snapshot staged
+ * it WITHOUT compiling it. Both sides carry the file identity (`fileKey`), so align on that.
+ */
+function alignChangedSetWithComponents(changed, components) {
+  if (!Array.isArray(changed)) return changed;
+  const byFileKey = new Map();
+  (components || []).forEach((component) => {
+    if (component && component.fileKey) byFileKey.set(component.fileKey, component);
+  });
+  return changed.map((entry) => {
+    const component = entry && entry.fileKey ? byFileKey.get(entry.fileKey) : null;
+    if (!component || entry.id || !component.name || component.name === entry.name) return entry;
+    return withFileKey(Object.assign({}, entry, { name: component.name }), entry.fileKey);
+  });
+}
+
+/**
+ * The local components, for identity alignment ONLY on paths that did not already collect them (the sync
+ * gates). Best-effort: a sidecar that does not parse must not stop a sync the server is about to judge.
+ */
+function collectComponentsForIdentity(cwd) {
+  try {
+    return collectComponents(cwd);
+  } catch (_) {
+    return [];
+  }
+}
+
 function unrepresentableChanges(changedFromWorkingTree, collected) {
   if (!Array.isArray(changedFromWorkingTree)) return [];
-  const present = new Set((collected || []).map((component) =>
-    component.type + ':' + (component.id ? 'id:' + component.id : 'name:' + String(component.name || '').toLowerCase())));
-  return changedFromWorkingTree
-    .filter((entry) => !present.has(entry.type + ':' + (entry.id ? 'id:' + entry.id : 'name:' + String(entry.name || '').toLowerCase())))
-    .map((entry) => Object.assign({}, entry, {
-      unrepresentable: true,
-      reason: (entry.statuses || []).some((s) => String(s).includes('D')) ? 'deleted' : 'no-local-files'
-    }));
+  const contentFields = ['source', 'prompt', 'html', 'javascript', 'previewData', 'inputSchema', 'messages', 'schema'];
+  const present = new Map((collected || []).map((component) => [stageIdentityKey(component), component]));
+  const report = [];
+  changedFromWorkingTree.forEach((entry) => {
+    const deleted = (entry.statuses || []).some((s) => String(s).includes('D'));
+    const component = present.get(stageIdentityKey(entry));
+    if (!component) {
+      report.push(Object.assign({}, entry, { unrepresentable: true, reason: deleted ? 'deleted' : 'no-local-files' }));
+      return;
+    }
+    // The component is still present (its other files remain), so it IS staged — but a content file git
+    // reports as deleted has nothing to send, and staged content fields LAYER: the lane keeps whatever it
+    // held before. Reported alongside the component, which stays in the workset.
+    const deletedFields = deleted
+      ? (entry.fields || []).filter((field) => contentFields.includes(field) && component[field] == null)
+      : [];
+    if (deletedFields.length) {
+      report.push(Object.assign({}, entry, { unrepresentable: true, reason: 'content-file-deleted', fields: deletedFields }));
+    }
+  });
+  return report;
 }
 
 function printUnrepresentableChanges(unstageable) {
@@ -2960,12 +3028,23 @@ function printUnrepresentableChanges(unstageable) {
   console.log('');
   console.log('NOT REPRESENTABLE IN REDIS STAGING — ' + unstageable.length + ' change(s):');
   unstageable.slice(0, 20).forEach((entry) => {
+    const fields = Array.isArray(entry.fields) && entry.reason === 'content-file-deleted' ? ': ' + entry.fields.join(', ') : '';
     console.log('  ' + entry.type + ' ' + (entry.id || entry.name || '(unknown)') +
-      '  (' + entry.reason + ')  ' + (entry.paths || []).join(', '));
+      '  (' + entry.reason + fields + ')  ' + (entry.paths || []).join(', '));
   });
   console.log('  A staged entry cannot hide a component. Clearing it falls back to the committed row, so');
   console.log('  the component still resolves in a CLI-scoped run. Prove a deletion through the durable');
   console.log('  plan instead:  remits-cli components sync --dry-run --summary --fail-on-errors');
+  const partial = unstageable.filter((entry) => entry.reason === 'content-file-deleted');
+  if (partial.length) {
+    console.log('  A deleted CONTENT file of a component that is still present is not a staged removal: the');
+    console.log('  lane keeps the content it already held, and compile validation judges THAT. Drop it with:');
+    partial.slice(0, 5).forEach((entry) => {
+      console.log(entry.id
+        ? '    remits-cli components clear --component-type ' + entry.type + ' --component-id ' + entry.id
+        : '    remits-cli components clear --all   (' + entry.type + ' ' + entry.name + ' has no id; this clears only your lane)');
+    });
+  }
 }
 
 /**
@@ -2995,6 +3074,10 @@ async function stageOrRefuse(api, cwd, payload) {
       // over a stage with nine broken components fixes one, re-stages, and pays nine round trips. Render
       // the whole list HERE, where the body is still in hand, then throw the one-line summary.
       printCompileValidation(body.compileValidation, { stderr: true });
+      // A refusal can be ABOUT an unrepresentable change: a deleted source file leaves the lane holding the
+      // content it had, and that is what was judged. Without this the refusal names a file that no longer
+      // exists and "fix it and re-stage" cannot work. Read from the payload, which still carries `fields`.
+      printUnrepresentableChanges((payload.changedSet || []).filter((entry) => entry && entry.unrepresentable));
       const failure = new Error(body.message);
       failure.responseBody = body;
       failure.status = status;
@@ -3052,6 +3135,13 @@ function printCompileValidation(validation, options) {
   emit('Compile validation: ' + status + ' — ' + validation.passed + '/' + validation.attempted +
     ' compiled in ' + validation.durationMs + 'ms' +
     (validation.concurrency ? ' (' + validation.concurrency + ' parallel)' : ''));
+  // A skip is neither a pass nor a failure, and it used to be printed as a pass ("1/1 compiled" over a
+  // component whose source was blank). Named, so the reader knows exactly what was NOT looked at.
+  const unchecked = Array.isArray(validation.unchecked) ? validation.unchecked : [];
+  if (unchecked.length) {
+    emit('  ' + unchecked.length + ' NOT compile-checked: ' + unchecked.map((entry) =>
+      (entry.type || 'component') + ' ' + (entry.id || entry.name || '?') + ' (' + (entry.reason || 'unchecked') + ')').join(', '));
+  }
   const shown = failures.slice(0, COMPILE_FAILURES_SHOWN);
   shown.forEach((failure) => {
     emit('  ' + (failure.type || 'component') + ' ' + (failure.id || failure.name || '') +
@@ -3692,7 +3782,9 @@ async function syncComponentsCommand(rawFlags) {
   const forceTombstones = flagEnabled(flags['force-tombstones']) || flagEnabled(flags.forceTombstones);
   const dryRun = flagEnabled(flags['dry-run']) || flagEnabled(flags.dryRun);
   const api = buildAxios(baseUrl, session.token);
-  const changedFromWorkingTree = changedComponentsFromWorkingTree(cwd);
+  // Aligned for the same reason a stage is: the server's plan names a `new_` component by its sidecar
+  // `name:`, and the changed set would otherwise name it by its filename and the gate would refuse it.
+  const changedFromWorkingTree = alignChangedSetWithComponents(changedComponentsFromWorkingTree(cwd), collectComponentsForIdentity(cwd));
   const preflightRequested = syncPreflightRequested(flags);
   const namesOnly = flagEnabled(flags['names-only']) || flagEnabled(flags.namesOnly);
 
@@ -4100,7 +4192,7 @@ function evaluateSyncGates(response, flags, changedFromWorkingTree, cwd) {
 
   if (flagEnabled(flags['changed-only']) || flagEnabled(flags.changedOnly)) {
     const since = flags['changed-since'] || flags.changedSince;
-    const fromRef = since ? changedComponentsSinceRef(cwd, String(since)) : null;
+    const fromRef = since ? alignChangedSetWithComponents(changedComponentsSinceRef(cwd, String(since)), collectComponentsForIdentity(cwd)) : null;
     if (since && fromRef === null) {
       violations.push('--changed-since: could not diff against "' + since + '". Check the ref exists (git fetch first for a remote ref).');
       checks.changedOnly = false;

package/package.json

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

package/skills/remits-cli/references/development-loop.md

@@ -235,6 +235,11 @@ Two things to read correctly when it refuses:
   lease) and writes nothing at all.
 - **Every failure is printed, not just the first.** The one-line error is the first failure; the full list
   (identified by type and id) follows it. Fix them in one pass rather than one round trip each.
+- **`N NOT compile-checked` is not a pass.** A `new_` component whose source file is empty or blank cannot
+  be judged, so it is listed by name with its reason instead of being counted as compiled. It will not run.
+- **Deleting a component's source file while its sidecar stays is `content-file-deleted`.** The lane keeps
+  the source it already held, and that is what gets compiled and run. Clear that one component with the
+  command the CLI prints (`components clear --component-type <type> --component-id <id>`).
 
 If git cannot identify the changed set — you are not in a working tree, or git failed — there is no
 workset to validate, and the CLI prints `Compile validation: NOT RUN — workset-unknown` rather than