@remits/remits-cli 0.1.126 → 0.1.127

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
-- L1234  Account Repos, Guide Sync, And Platform Repo
-- L1892  Component Discovery And HTTP Logging
-- L2382  Skill Delivery And TOC Resolution
-- L2692  Auth And Component Staging
-- L3280  Component Summaries, Status, And Sync Gates
-- L4991  Branches, Promotion, Commit, And Test Runs
-- L5988  Tokens, Tools, Verification, And Config
-- L6889  Service Dashboard And WebSocket Listener
-- L8984  Agent And Ticket Workflows
-- L12042  Help, Auto Update, And Command Dispatch
+- L1296  Account Repos, Guide Sync, And Platform Repo
+- L1954  Component Discovery And HTTP Logging
+- L2444  Skill Delivery And TOC Resolution
+- L2754  Auth And Component Staging
+- L3352  Component Summaries, Status, And Sync Gates
+- L5107  Branches, Promotion, Commit, And Test Runs
+- L6231  Tokens, Tools, Verification, And Config
+- L7141  Service Dashboard And WebSocket Listener
+- L9236  Agent And Ticket Workflows
+- L12294  Help, Auto Update, And Command Dispatch
 */
 
 /*
@@ -811,6 +811,42 @@ function writeToolResponseFile(cwd, callId, responsePayload) {
   return file;
 }
 
+function fileEvidence(pathname) {
+  if (!pathname || !fs.existsSync(pathname)) return {};
+  const body = fs.readFileSync(pathname);
+  return {
+    responseFile: pathname,
+    bytes: body.length,
+    sha256: sha256(body)
+  };
+}
+
+function boundedToolExcerpt(data = {}) {
+  const result = data.result && typeof data.result === 'object' ? data.result : {};
+  const candidates = [
+    data.message,
+    data.toolMessage,
+    data.error,
+    result.message,
+    result.error,
+    result.reason
+  ].filter(Boolean).map((value) => String(value));
+  const excerpt = candidates.join(' | ').trim();
+  return excerpt ? excerpt.slice(0, 1200) : null;
+}
+
+function toolEvidenceSummary(data = {}, responseFile) {
+  return Object.assign({
+    callId: data.callId,
+    name: data.name,
+    async: data.async,
+    status: data.status,
+    toolSuccess: data.toolSuccess,
+    threadGroupingId: data.threadGroupingId,
+    message: boundedToolExcerpt(data)
+  }, fileEvidence(responseFile));
+}
+
 function readToolResponseFile(cwd, callId) {
   if (!callId) return null;
   const paths = ensureLocalState(cwd);
@@ -1100,12 +1136,28 @@ function printVerificationEnvelope(envelope, fallbackEnvelopeId) {
   }
 }
 
+function printAcceptanceWarnings(envelope) {
+  const warnings = envelope && envelope.acceptance && Array.isArray(envelope.acceptance.warnings)
+    ? envelope.acceptance.warnings
+    : [];
+  if (!warnings.length) return;
+  console.log('Manifest warnings:');
+  warnings.forEach((warning) => {
+    console.log('- ' + (warning.message || warning.code || JSON.stringify(warning)));
+  });
+}
+
 function buildCommandWorld(response, fallback = {}) {
   const source = (response && response.staging) || {};
   const resolution = (response && response.resolution) || {};
+  const result = (response && response.result) || {};
+  const laneHash = laneContentHashFrom(response) || fallback.laneContentHash || fallback.stagedOverlayHash;
+  const executionAccountId = response && (response.executionAccountId || result.accountId || source.executionAccountId || response.accountId) ||
+    resolution.executionAccountId ||
+    fallback.executionAccountId;
   return {
     accountId: response && (response.accountId || response.ownerAccountId) || fallback.accountId,
-    executionAccountId: response && (response.executionAccountId || response.accountId) || resolution.executionAccountId || fallback.executionAccountId,
+    executionAccountId,
     addressedAccountId: resolution.addressedAccountId || fallback.addressedAccountId,
     host: fallback.host,
     dataMode: response && response.dataMode || fallback.dataMode,
@@ -1113,16 +1165,26 @@ function buildCommandWorld(response, fallback = {}) {
     branchName: response && response.branchName || fallback.branchName,
     workspace: response && response.workspace !== undefined ? response.workspace : fallback.workspace,
     stagingLane: response && response.stagingLane || source.stagingLane || fallback.stagingLane,
+    laneContentHash: laneHash,
+    stagedOverlayHash: laneHash,
     // `variantWorld.componentBranch` is the platform's answer for the run (the variant branch, else the
     // subscription); a bare `variantBranch` is null whenever the subscription decided.
     componentBranch: resolution.componentBranch ||
       response && ((response.variantWorld && response.variantWorld.componentBranch) || response.variantBranch) ||
       fallback.componentBranch,
+    variantBranchSource: response && (response.variantBranchSource || (response.variantWorld && response.variantWorld.variantBranchSource)) || fallback.variantBranchSource,
     variantId: resolution.variantId || fallback.variantId,
     sourceLayer: fallback.sourceLayer || (source.testComponentSource === 'staged' ? 'staged' : undefined)
   };
 }
 
+function laneContentHashFrom(response) {
+  if (!response) return null;
+  const laneSummary = response.laneSummary || (response.staging && response.staging.laneSummary) ||
+    (response.componentStatus && response.componentStatus.laneSummary);
+  return laneSummary && laneSummary.contentHash ? laneSummary.contentHash : null;
+}
+
 function normalizeName(name) {
   return name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/\s+/g, ' ').trim();
 }
@@ -3057,6 +3119,7 @@ async function pushComponentsCommand(flags) {
         rawRefs: { command: 'components stage' },
         stage: (err.responseBody || {}).stage,
         compileValidation: (err.responseBody || {}).compileValidation,
+        refusalDetails: stageRefusalDetails(err.responseBody || {}),
         changedFromWorkingTree: changedFromWorkingTree || [],
         unrepresentableChanges: unstageable
       }, { quiet: true });
@@ -3091,6 +3154,7 @@ async function pushComponentsCommand(flags) {
     rawRefs: { command: 'components stage' },
     stage: response.stage,
     laneSummary: response.laneSummary,
+    compileValidation: response.compileValidation || null,
     changedFromWorkingTree: response.changedFromWorkingTree,
     unrepresentableChanges: response.unrepresentableChanges
   }, { quiet: flagEnabled(flags.json) });
@@ -3276,6 +3340,14 @@ async function stageOrRefuse(api, cwd, payload) {
   }
 }
 
+function stageRefusalDetails(body = {}) {
+  const details = {};
+  ['duplicates', 'compileValidation', 'policy', 'editLease', 'skipped', 'reconcile', 'laneHoldsRejectedSource'].forEach((key) => {
+    if (body[key] !== undefined) details[key] = sanitizeForLog(body[key]);
+  });
+  return Object.keys(details).length ? details : undefined;
+}
+
 /*
 ## Component Summaries, Status, And Sync Gates
 */
@@ -3331,6 +3403,10 @@ function printCompileValidation(validation, options) {
   // 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 : [];
+  const warnings = Array.isArray(validation.warnings) ? validation.warnings : [];
+  warnings.forEach((warning) => {
+    emit('  Warning: ' + (warning.message || JSON.stringify(warning)));
+  });
   if (unchecked.length) {
     emit('  ' + unchecked.length + ' NOT compile-checked: ' + unchecked.map((entry) =>
       (entry.type || 'component') + ' ' + (entry.id || entry.name || '?') + ' (' + (entry.reason || 'unchecked') + ')').join(', '));
@@ -3495,6 +3571,9 @@ function printStageSummary(response, flags) {
   // The CLI's own findings (deleted files) and the platform's (a README withheld on a variant branch) are
   // different sources. Preferring the first whenever it existed — even as an empty list — hid the second.
   printUnrepresentableChanges(mergeUnrepresentable(response.unrepresentableChanges, stage.unrepresentable));
+  if (typeof printOrphanedWorkspaceWarning === 'function') {
+    printOrphanedWorkspaceWarning(response);
+  }
   if (typeof printAccountLanes === 'function') {
     printAccountLanes(response);
   }
@@ -3520,6 +3599,7 @@ function printStatusSummary(response, flags) {
   printBranchContext(response);
   printStagingLane(response.branchName, response.workspace, null);
   printLaneSummary(response);
+  printOrphanedWorkspaceWarning(response);
   printStagingFreshness(response.freshness);
   printRepositoryCheck(response.repositoryCheck);
   printComponentTypeCounts(response.entries || []);
@@ -3678,6 +3758,36 @@ function printAccountLanes(response) {
   console.log('  resolves the account\'s subscription beneath its staged entries and cannot be landed.');
 }
 
+function printOrphanedWorkspaceWarning(response) {
+  const currentCount = Number((response && response.stagedCount) ||
+    (response && response.laneSummary && response.laneSummary.stagedCount) || 0);
+  if (currentCount > 0) return;
+  const lanes = Array.isArray(response && response.accountLanes) ? response.accountLanes : [];
+  const currentBranch = response && response.branchName;
+  const currentWorkspace = response && response.workspace;
+  const orphan = lanes.find((lane) => lane && lane.sameWorkspaceOtherBranch === true);
+  if (!orphan) return;
+  const age = orphan.updatedAtMs ? formatAge(Date.now() - Number(orphan.updatedAtMs)) + ' ago' : 'recently';
+  console.log('');
+  console.log('WARNING: Your workspace "' + (currentWorkspace || orphan.workspace || 'shared') + '" has ' +
+    (orphan.stagedCountAsOf || orphan.stagedCount || 0) + ' staged entr' +
+    ((orphan.stagedCountAsOf || orphan.stagedCount || 0) === 1 ? 'y' : 'ies') +
+    ' on branch "' + orphan.branchName + '" (staged ' + age + '); this checkout is now on "' +
+    (currentBranch || 'unknown') + '". Re-stage here, or switch back.');
+}
+
+function formatAge(ms) {
+  const value = Number(ms);
+  if (!Number.isFinite(value) || value < 0) return 'unknown age';
+  const seconds = Math.round(value / 1000);
+  if (seconds < 90) return seconds + 's';
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 90) return minutes + 'm';
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return hours + 'h';
+  return Math.round(hours / 24) + 'd';
+}
+
 // The world a lane row resolves, from the platform's answer. null onTrunk means the owner could not be
 // resolved, and a non-trunk lane without a reported source (an older platform) is only known to be
 // non-trunk — never guessed to be a variant branch. Pure.
@@ -3846,6 +3956,7 @@ async function statusComponentsCommand(flags) {
   // supplies the facts (the last SHA it synced, each entry's base) and the comparison happens here.
   response.freshness = stagingFreshness({
     head: safeGitValue(cwd, 'git rev-parse HEAD'),
+    originHead: safeGitValue(cwd, 'git rev-parse ' + shellQuote('origin/' + branchName)),
     lastSyncedSha: response.branchContext && response.branchContext.lastSyncedSha,
     entries: response.entries,
     laneSummary: response.laneSummary,
@@ -4759,7 +4870,7 @@ function gitIsAncestor(cwd, ancestor, descendant) {
  * `stageBaseSha`; only the local checkout can order commits, so the comparison happens here. Pure — git is
  * injected as `isAncestor(a, b)` — so it can be tested without a repository.
  */
-function stagingFreshness({ head, lastSyncedSha, entries, laneSummary, isAncestor }) {
+function stagingFreshness({ head, originHead, lastSyncedSha, entries, laneSummary, isAncestor }) {
   const rows = Array.isArray(entries) ? entries : [];
   const staged = rows.filter((entry) => entry && entry.stageBaseSha);
   const memo = new Map();
@@ -4785,7 +4896,9 @@ function stagingFreshness({ head, lastSyncedSha, entries, laneSummary, isAncesto
 
   return {
     head: head || null,
+    originHead: originHead || null,
     lastSyncedSha: lastSyncedSha || null,
+    freshnessUnknownReason: !originHead ? 'branch has no upstream' : (!lastSyncedSha ? 'platform has no last synced SHA for this branch' : null),
     landedSinceHead,
     entriesBehindLastSync: behindLastSync.length,
     entriesFromOtherCommits: fromOtherCommits.length,
@@ -4799,6 +4912,9 @@ function stagingFreshness({ head, lastSyncedSha, entries, laneSummary, isAncesto
 function printStagingFreshness(freshness) {
   if (!freshness) return;
   const plural = (n) => n + ' staged entr' + (n === 1 ? 'y' : 'ies');
+  if (freshness.freshnessUnknownReason) {
+    console.log('Freshness unknown:', freshness.freshnessUnknownReason + '.');
+  }
   if (freshness.landedSinceHead === true) {
     console.log('');
     console.log('LANDED SINCE YOUR BASE: the platform last synced ' + short(freshness.lastSyncedSha) +
@@ -5759,6 +5875,84 @@ async function waitForStatus(api, cwd, accountId, branchName, taskId, token, dat
   }
 }
 
+function testEvidenceCategories(status = {}, selectedNames = []) {
+  const categories = new Set(['test_run']);
+  const test = status.test || {};
+  if (test.name) categories.add('test_run.suite:' + String(test.name));
+  if (test.id !== undefined && test.id !== null) categories.add('test_run.suite_id:' + String(test.id));
+  (Array.isArray(selectedNames) ? selectedNames : []).forEach((name) => {
+    if (name) categories.add('test_run.' + String(name));
+  });
+  const results = status.result && Array.isArray(status.result.tests) ? status.result.tests : [];
+  results.forEach((result) => {
+    if (result && result.passed === true && result.name) {
+      categories.add('test_run.case:' + String(result.name));
+      categories.add('test_run.' + String(result.name));
+    }
+  });
+  return Array.from(categories);
+}
+
+function testComponentProvenance(status = {}) {
+  const direct = status.resolvedComponentProvenance || (status.result && status.result.resolvedComponentProvenance) ||
+    (status.staging && status.staging.resolvedComponentProvenance);
+  if (Array.isArray(direct)) return direct;
+  const staging = status.staging || {};
+  if (staging.testComponentSignature) {
+    return [{
+      type: 'test',
+      id: status.test && status.test.id,
+      name: status.test && status.test.name,
+      signature: staging.testComponentSignature,
+      source: staging.testComponentSource || null
+    }];
+  }
+  return [];
+}
+
+function testCompileSignatures(status = {}) {
+  return testComponentProvenance(status)
+    .map((entry) => entry && entry.signature)
+    .filter(Boolean);
+}
+
+function printTestRunPivots(status = {}) {
+  const tests = status.result && Array.isArray(status.result.tests) ? status.result.tests : [];
+  if (!tests.length) return;
+  const slowest = tests.slice().sort((a, b) => Number(b.duration || 0) - Number(a.duration || 0))[0];
+  if (slowest && slowest.duration != null) {
+    console.log('Slowest case:', (slowest.name || '(unnamed)') + ' in ' + formatDurationMs(slowest.duration));
+  }
+  tests.filter((test) => test && test.passed === false).forEach((test) => {
+    console.log('Pivots for failed case:', test.name || '(unnamed)');
+    if (test.duration != null) console.log('  Duration:', formatDurationMs(test.duration));
+    if (test.threadGroupingId || test.threadGroupId || test.traceId) {
+      console.log('  Trace:', test.traceId || test.threadGroupingId || test.threadGroupId);
+    }
+    if (test.error) console.log('  Error:', String(test.error).slice(0, 500));
+    const diagnostics = test.diagnostics && typeof test.diagnostics === 'object' ? test.diagnostics : null;
+    if (diagnostics && Object.keys(diagnostics).length) {
+      console.log('  Diagnostics:', JSON.stringify(diagnostics).slice(0, 1200));
+    }
+    if (Array.isArray(test.resolvedComponentProvenance) && test.resolvedComponentProvenance.length) {
+      console.log('  Components:', test.resolvedComponentProvenance.slice(0, 8).map((entry) =>
+        (entry.type || 'component') + ' ' + (entry.id || entry.name || '?') +
+        (entry.source ? ' [' + entry.source + ']' : '') +
+        (entry.signature ? ' ' + short(entry.signature) : '')).join(', '));
+    }
+    if (Array.isArray(test.liveHttpCalls) && test.liveHttpCalls.length) {
+      console.log('  Live HTTP calls:', test.liveHttpCalls.length);
+    }
+  });
+}
+
+function formatDurationMs(value) {
+  const ms = Number(value);
+  if (!Number.isFinite(ms)) return String(value);
+  if (ms < 1000) return ms + 'ms';
+  return (ms / 1000).toFixed(ms < 10000 ? 1 : 0) + 's';
+}
+
 async function waitForToolStatus(api, cwd, options) {
   const started = Date.now();
   let pollDelayMs = parsePositiveInt(options.pollIntervalMs, 1000);
@@ -5909,6 +6103,7 @@ async function testCommand(flags) {
     printResolvedBaseUrl(baseUrl);
     printStagingLane(branchName, workspace, workspaceSource(cwd, flags));
     if (start.staging && Array.isArray(start.staging.accountLanes)) {
+      printOrphanedWorkspaceWarning(start.staging);
       printAccountLanes({ accountLanes: start.staging.accountLanes, branchName, workspace });
     }
     console.log('Test run started:', start.taskId);
@@ -5935,6 +6130,7 @@ async function testCommand(flags) {
     console.log(JSON.stringify(status, null, 2));
   } else {
     console.log('Final status:', JSON.stringify(status, null, 2));
+    printTestRunPivots(status);
   }
 
   // A selector that matched no case is a mis-specified run, not a passing one. Say so in the terminal
@@ -5965,7 +6161,8 @@ async function testCommand(flags) {
     claim: 'Test run ' + String(testRef),
     world: buildCommandWorld(status, { accountId, dataMode: status.dataMode || dataMode, dataModeSource, branchName, workspace, host: normalizeBaseUrl(baseUrl), sourceLayer: status.staging && status.staging.testComponentSource }),
     revision: Object.assign(collectVerificationSource(cwd, flags), {
-      compileSignatures: status.staging && status.staging.testComponentSignature ? [status.staging.testComponentSignature] : []
+      compileSignatures: testCompileSignatures(status),
+      componentProvenance: testComponentProvenance(status)
     }),
     test: {
       taskId: start.taskId,
@@ -5974,16 +6171,62 @@ async function testCommand(flags) {
       selectedCases: names,
       passed: status.result && status.result.passed,
       failed: status.result && status.result.failed,
+      tests: status.result && status.result.tests,
       dataModeSource: status.dataModeSource || dataModeSource,
       unmatchedTestNames: unmatched
     },
-    evidenceCategories: ['test_run'].concat(names.map((name) => 'test_run.' + name)),
+    evidenceCategories: testEvidenceCategories(status, names),
     limitations: unmatched.length ? ['One or more requested test case selectors matched no case.'] : [],
     rawRefs: { testStatusKey: start.taskId },
     status
   }, { quiet: jsonOutput });
 }
 
+async function testStatusCommand(flags) {
+  const cwd = process.cwd();
+  ensureLocalState(cwd);
+  const sessionContext = resolveSessionContext(cwd, flags);
+  const { session, accountId } = sessionContext;
+  const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
+  const branchName = flags.branch || currentBranch(cwd);
+  const dataMode = hasExplicitDataModeFlag(flags)
+    ? resolveDataMode(flags, null)
+    : DEFAULT_DATA_MODE;
+  const taskId = flags['task-id'] || flags.taskId || flags.id || (flags._ && flags._[2]);
+  const jsonOutput = flagEnabled(flags.json);
+  if (!taskId) throw new Error('Missing --task-id <taskId>');
+
+  const api = buildAxios(baseUrl, session.token);
+  const status = await loggedPost(api, cwd, '/cli/test', {
+    token: session.token,
+    command: 'status',
+    accountId,
+    branchName,
+    taskId,
+    dataMode
+  }).then((r) => r.data);
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(status, null, 2));
+    return status;
+  }
+  printSessionResolutionWarning(sessionContext);
+  printResolvedBaseUrl(baseUrl);
+  console.log('Test run status:', status.status || 'unknown');
+  console.log('Task ID:', taskId);
+  console.log('Data mode:', status.dataMode || dataMode);
+  if (status.result) {
+    console.log('Cases:', (status.result.passed || 0) + ' passed, ' + (status.result.failed || 0) + ' failed, ' + (status.result.total || 0) + ' total');
+  }
+  if (status.error || status.message) {
+    console.log('Message:', status.error || status.message);
+  }
+  if (status.status === 'failed' || (status.result && status.result.failed > 0)) {
+    process.exitCode = 1;
+  }
+  return status;
+}
+
 /*
 ## Tokens, Tools, Verification, And Config
 */
@@ -6308,8 +6551,7 @@ async function toolCommand(flags) {
       revision: collectVerificationSource(cwd, flags),
       evidenceCategories: ['tool_call'],
       rawRefs: { toolResponsePath: statusResponse.responseFile, callId: requestedCallId },
-      tool: { callId: requestedCallId, status: data.status, name: stored && stored.name },
-      result: data
+      tool: Object.assign(toolEvidenceSummary(data, statusResponse.responseFile), { callId: requestedCallId, name: stored && stored.name })
     }, { quiet: jsonOutput });
     if (jsonOutput) {
       console.log(JSON.stringify(data, null, 2));
@@ -6322,7 +6564,8 @@ async function toolCommand(flags) {
     console.log('Data mode:', data.dataMode || dataMode);
     if (data.threadGroupingId) console.log('Thread grouping ID:', data.threadGroupingId);
     console.log('Session log:', data.sessionLog);
-    console.log('Tool response file:', data.responseFile);
+    const responseEvidence = fileEvidence(data.responseFile);
+    console.log('Tool response file:', data.responseFile + (responseEvidence.bytes ? ' (' + responseEvidence.bytes + ' bytes, sha256 ' + responseEvidence.sha256.slice(0, 12) + ')' : ''));
     if (polledFailed) {
       console.log('Tool error:', data.toolMessage);
     }
@@ -6373,6 +6616,9 @@ async function toolCommand(flags) {
   data.sessionLog = sessionJsonlFile(cwd);
   if (toolFailureMessage && !data.toolMessage) data.toolMessage = toolFailureMessage;
 
+  let evidenceData = data;
+  let evidenceResponseFile = response.responseFile;
+
   if (!jsonOutput) {
     printSessionResolutionWarning(sessionContext);
     printResolvedBaseUrl(baseUrl);
@@ -6390,7 +6636,8 @@ async function toolCommand(flags) {
       console.log('Component:', `${data.componentSource}${sig}`);
     }
     console.log('Session log:', data.sessionLog);
-    console.log('Tool response file:', data.responseFile);
+    const responseEvidence = fileEvidence(data.responseFile);
+    console.log('Tool response file:', data.responseFile + (responseEvidence.bytes ? ' (' + responseEvidence.bytes + ' bytes, sha256 ' + responseEvidence.sha256.slice(0, 12) + ')' : ''));
   }
 
   // Non-zero exit so scripted/agent callers that check status notice the refusal too.
@@ -6410,9 +6657,12 @@ async function toolCommand(flags) {
 
     finalStatus.data.responseFile = finalStatus.responseFile;
     finalStatus.data.sessionLog = sessionJsonlFile(cwd);
+    evidenceData = finalStatus.data;
+    evidenceResponseFile = finalStatus.responseFile;
     if (!jsonOutput) {
       console.log('Final status:', finalStatus.data.status);
-      console.log('Tool response file:', finalStatus.responseFile);
+      const finalEvidence = fileEvidence(finalStatus.responseFile);
+      console.log('Tool response file:', finalStatus.responseFile + (finalEvidence.bytes ? ' (' + finalEvidence.bytes + ' bytes, sha256 ' + finalEvidence.sha256.slice(0, 12) + ')' : ''));
     }
     if (finalStatus.data.status !== 'completed') {
       process.exitCode = 1;
@@ -6422,20 +6672,19 @@ async function toolCommand(flags) {
 
   await appendVerificationPacket(api, cwd, session, accountId, flags, {
     type: 'tool_call',
-    success: !toolFailed && (!asyncMode || !waitForAsync || process.exitCode !== 1),
+    success: asyncMode && !waitForAsync ? null : (!toolFailed && (!asyncMode || process.exitCode !== 1)),
     claim: 'Tool call ' + String(toolName),
-    world: buildCommandWorld(data, { accountId: data.accountId || accountId, dataMode: data.dataMode || dataMode, branchName: data.branchName || branchName, workspace: resolveWorkspace(cwd, flags), host: normalizeBaseUrl(baseUrl), sourceLayer: data.componentSource }),
+    world: buildCommandWorld(evidenceData, { accountId: evidenceData.accountId || accountId, dataMode: evidenceData.dataMode || dataMode, branchName: evidenceData.branchName || branchName, workspace: resolveWorkspace(cwd, flags), host: normalizeBaseUrl(baseUrl), sourceLayer: evidenceData.componentSource }),
     revision: Object.assign(collectVerificationSource(cwd, flags), {
-      compileSignatures: data.componentSignature ? [data.componentSignature] : []
+      compileSignatures: evidenceData.componentSignature ? [evidenceData.componentSignature] : []
     }),
     evidenceCategories: ['tool_call'],
     dependencies: {
       mocks: [],
-      liveHttpCalls: data.liveHttpCalls || []
+      liveHttpCalls: evidenceData.liveHttpCalls || []
     },
-    rawRefs: { toolResponsePath: response.responseFile, callId },
-    tool: { callId, name: String(toolName), async: asyncMode, status: data.status, toolSuccess: data.toolSuccess },
-    result: data
+    rawRefs: { toolResponsePath: evidenceResponseFile, callId },
+    tool: Object.assign(toolEvidenceSummary(evidenceData, evidenceResponseFile), { callId, name: String(toolName), async: asyncMode })
   }, { quiet: jsonOutput });
   if (jsonOutput) {
     console.log(JSON.stringify(data, null, 2));
@@ -6522,7 +6771,8 @@ async function verifyCommand(flags, subcommand) {
       source.componentBranch = verifiedWorld.componentBranch;
       source.sourceLayer = verifiedWorld.sourceLayer;
       if (verifiedWorld.variantBranchSource) source.variantBranchSource = verifiedWorld.variantBranchSource;
-      source.stagedOverlayHash = statusResponse.laneSummary ? sha256(stableStringify(statusResponse.laneSummary)) : null;
+      source.laneContentHash = laneContentHashFrom(statusResponse);
+      source.stagedOverlayHash = source.laneContentHash;
     }
 
     const response = await postVerificationCommand(api, cwd, session, accountId, 'start', {
@@ -6537,6 +6787,7 @@ async function verifyCommand(flags, subcommand) {
     writeActiveVerificationEnvelope(cwd, envelope.envelopeId, activeContext);
     console.log('Verification envelope started:', envelope.envelopeId);
     console.log('Target:', 'account=' + accountId + ', branch=' + branchName + ', workspace=' + (workspace || 'shared') + ', dataMode=' + dataMode);
+    printAcceptanceWarnings(envelope);
     console.log('Local mirror:', verificationPaths(cwd, envelope.envelopeId).base);
     return envelope;
   }
@@ -6577,6 +6828,7 @@ async function verifyCommand(flags, subcommand) {
     writeLocalVerificationEnvelope(cwd, response.envelope);
     console.log('Manifest attached to envelope:', envelopeId);
     console.log('Required evidence:', (((response.envelope || {}).acceptance || {}).requiredEvidence || []).length);
+    printAcceptanceWarnings(response.envelope);
     return response.envelope;
   }
 
@@ -12337,11 +12589,13 @@ function printComponentsHelp(subcommand) {
 
 function printTestHelp() {
   console.log('Usage: remits-cli test run --test <id|name> [--base-url URL] [--branch stagingScope] [--names "a|b"] [--watch true|false] [--data-mode test|prod] [--as-account ID] [--variant-branch NAME|none] [--json]');
+  console.log('       remits-cli test status --task-id <taskId> [--base-url URL] [--account-id ID] [--branch stagingScope] [--data-mode test|prod] [--json]');
   console.log('');
   console.log('Runs a Test component against the staged/variant world for this checkout.');
   console.log('Examples:');
   console.log('  remits-cli test run --test 11');
   console.log('  remits-cli test run --test "Merchant Statements" --names "managed account case"');
+  console.log('  remits-cli test status --task-id 7a1b...');
   console.log('');
   console.log('Notes:');
   console.log('  --names is delimited by "|" (comma also works when no "|" is present), and may be repeated.');
@@ -12728,6 +12982,10 @@ async function main() {
     await testCommand(args);
     return;
   }
+  if (command === 'test' && subcommand === 'status') {
+    await testStatusCommand(args);
+    return;
+  }
 
   if (command === 'token') {
     await tokenCommand(args);

package/package.json

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

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

@@ -207,6 +207,7 @@ remits-cli components branch <name> --subscribe <accountId> [--parent-account <i
 remits-cli components branch <name> --unsubscribe <accountId>                          # return that account to trunk
 remits-cli components branch <name> --retire [--force]                                 # delete the branch's overlays
 remits-cli test run --test <id|name> [--branch <stagingScope>] [--names "a|b"] [--watch true|false] [--data-mode test|prod] [--as-account <ID>] [--variant-branch <name|none>] [--json]
+remits-cli test status --task-id <taskId> [--branch <stagingScope>] [--data-mode test|prod] [--json]
 remits-cli token [--path <embeddablePathOrId>] [--data-mode test|prod] [--as-account <ID>] [--variant-branch <name|none>]
 remits-cli token inspect --token <token|tokenKey|URL>                  # inspect token metadata, safety/dataMode evidence, and full context
 remits-cli tools [--branch <name>] [--data-mode test|prod] [--variant-branch <name|none>]
@@ -268,6 +269,23 @@ remits-cli verify report
 Existing commands also accept `--verify-envelope <id>` to attach to a specific envelope and
 `--no-verify-envelope` to suppress automatic attachment for one command.
 
+Failed `remits-cli test run` output includes compact pivots per failed case: duration, trace id,
+bounded `report(...)` diagnostics, live HTTP signals, and resolved component provenance when the
+platform returns it. Re-read an existing run with `remits-cli test status --task-id <taskId>` before
+rerunning a long suite.
+
+Test-run requirements must name the suite/cases they mean:
+
+```json
+{"id":"api_flow", "packetType":"test_run", "suite":"Statement API Flow", "allCases":true}
+{"id":"one_case", "packetType":"test_run", "suite":"Statement API Flow", "cases":["rejects duplicated fee evidence"]}
+```
+
+`verify start` and `verify manifest` warn when a requirement has a `packetType` but no discriminator.
+The evaluator treats pending async tool packets as pending, not passing; a later `tool status` packet is
+the proof. Tool packets store the response file path, byte size and hash rather than copying the whole
+tool payload into the envelope.
+
 Use `remits-cli verify list` to review open envelopes for the account without SQL. If a newer envelope
 replaces an older one, use `verify supersede`; if a duplicate or abandoned attempt should no longer read
 as live work, use `verify abandon`. Both keep the evidence history.

package/skills/remits-cli/references/component-resolution.md

@@ -57,9 +57,10 @@ source-layer facts the command observed. A staged test packet is proof of the st
 is proof of a source transition; a token packet is proof of the browser token's resolution tuple. Those
 are not interchangeable.
 
-Use `remits-cli verify report` before summarizing the work. It will naturally say when the evidence only
-covered staged source, when committed variant/trunk proof is missing, or when evidence became stale after
-the git head, overlay, or platform sync moved.
+Use `remits-cli verify report` before summarizing the work. It will say when the evidence only covered
+staged source, when committed variant/trunk proof is missing, when the manifest world does not match the
+packet world, or when later packet facts made an earlier proof stale. Packets carry a lane content hash,
+git head, workspace, data lane, and variant-world facts so a re-stage or branch move is visible.
 
 ### Staging cache key format
 
@@ -212,6 +213,9 @@ commit write `ComponentVariant` overlays for a branch nobody subscribes to).
 - `remits-cli components clear --all` is scoped to YOUR lane and never touches another agent's.
 - In lane rows, `currentLane` (also `mine`) marks THIS command's lane; `ownedByCaller` marks every lane
   staged by your CLI user — your other clones' agents included.
+- If your current lane is empty but the same workspace has staged entries on another branch, the CLI
+  prints a warning. That usually means the checkout switched branches after staging; re-stage on this
+  branch or switch back.
 - **A landing clears only the lander's lane.** Every stage records the commit it came from
   (`stageBaseSha`), and `components status` compares that with the last commit the platform synced for the
   branch (`branchContext.lastSyncedSha`) using your local git:

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

@@ -97,6 +97,17 @@ remits-cli verify report
 The report is the final-response source. It separates verified claims, missing evidence, stale packets,
 and the source/account/lane tuple, so do not replace it with a generic "verified" sentence.
 
+For Test requirements, be specific enough for the evaluator to know what a pass means:
+
+```json
+{"id":"api_flow", "packetType":"test_run", "suite":"Statement API Flow", "allCases":true}
+{"id":"duplicate_fee_case", "packetType":"test_run", "suite":"Statement API Flow", "cases":["rejects duplicated fee evidence"]}
+```
+
+A requirement that says only `{"packetType":"test_run"}` is intentionally only a warning-worthy sketch:
+it will not turn a random Test packet into acceptance. Full-suite runs emit suite and passed-case
+categories automatically, so case-level requirements can be satisfied by a real full run.
+
 ## Development Workflow
 
 ### The Golden Rule: Writing Code Is Not Finishing the Job
@@ -327,9 +338,13 @@ This applies to:
 ```bash
 remits-cli test run --test <TEST_ID_OR_NAME>
 remits-cli test run --test "Invoice Tests" --names "specific test case"
+remits-cli test status --task-id <TASK_ID>
 ```
 
-Tests run on the platform against your staged snapshot. They stream results in real-time. If they fail, fix the code, re-stage, and re-run.
+Tests run on the platform against your staged snapshot. They stream results in real-time. If they fail,
+read the printed pivots first: failed cases include timing, trace ids, bounded `report(...)`
+diagnostics, live HTTP signals, and resolved component provenance when available. Fix the code,
+re-stage, and re-run only after those pivots explain the failure.
 
 Important test-runner constraints:
 - `remits-cli test run` now defaults to `test` dataMode unless you explicitly pass `--data-mode prod`.