@remits/remits-cli 0.1.153 → 0.1.155

package/index.js

@@ -5,17 +5,17 @@
 
 - L22  Runtime Bootstrap And Shared State
 - L124  Sessions, Account Resolution, And Production Guards
-- L621  Local State, Workspaces, And Verification Evidence
-- L2659  Account Repos, Guide Sync, And Platform Repo
-- L3499  Component Discovery And HTTP Logging
-- L4267  Skill Delivery And TOC Resolution
-- L4582  Auth And Component Staging
-- L5214  Component Summaries, Status, And Sync Gates
-- L7515  Branches, Promotion, Commit, And Test Runs
-- L9631  Tokens, Tools, Verification, And Config
-- L11058  Service Dashboard And WebSocket Listener
-- L13557  Agent And Ticket Workflows
-- L17692  Help, Auto Update, And Command Dispatch
+- L630  Local State, Workspaces, And Verification Evidence
+- L2668  Account Repos, Guide Sync, And Platform Repo
+- L3508  Component Discovery And HTTP Logging
+- L4276  Skill Delivery And TOC Resolution
+- L4591  Auth And Component Staging
+- L5223  Component Summaries, Status, And Sync Gates
+- L7547  Branches, Promotion, Commit, And Test Runs
+- L9676  Tokens, Tools, Verification, And Config
+- L11103  Service Dashboard And WebSocket Listener
+- L13602  Agent And Ticket Workflows
+- L17778  Help, Auto Update, And Command Dispatch
 */
 
 /*
@@ -136,6 +136,15 @@ function parseArgs(argv) {
       out._.push(arg);
       continue;
     }
+    // `B="--data-mode prod --base-url URL"; remits-cli ... $B` reaches us as ONE argument under zsh, which
+    // does not word-split an unquoted variable. Parsed as a flag NAME it matched nothing, so the command ran
+    // with no host and no lane at all - against whatever the defaults named - and its answer looked like
+    // a real one. A flag name never contains whitespace, so say what happened instead.
+    if (/\s/.test(arg)) {
+      throw new Error('One argument holds several flags: "' + arg + '". Your shell passed them as a single ' +
+        'word (zsh does not split an unquoted $VAR). Write the flags out, or use an array: ' +
+        'B=(--data-mode prod --base-url URL); remits-cli ... "${B[@]}".');
+    }
     const shortName = arg.startsWith('--') ? null : arg.slice(1);
     const key = shortName ? (SHORT_FLAG_ALIASES[shortName] || shortName) : arg.slice(2);
     const next = argv[i + 1];
@@ -6423,6 +6432,16 @@ async function syncComponentsCommand(rawFlags) {
   const dryRun = flagEnabled(flags['dry-run']) || flagEnabled(flags.dryRun);
   const timeoutMs = parsePositiveInt(flags['timeout-ms'] || flags.timeoutMs, 60000);
   const api = buildAxios(baseUrl, session.token, timeoutMs);
+  const observeOperation = (operationId) => loggedPost(api, cwd, '/cli/components', {
+    token: session.token, accountId, branchName, workspace, dataMode, mode: 'sync-status', operationId
+  }).then((r) => r.data);
+  const operationOptions = { waitMs: parsePositiveInt(flags['wait-timeout-ms'], 600000) };
+  if (flags.resume) {
+    const result = await require('./lib/sync-operation').observeSync(observeOperation, String(flags.resume), operationOptions);
+    console.log(JSON.stringify(result, null, 2));
+    if (result.success === false) process.exitCode = 1;
+    return result;
+  }
   // 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));
@@ -6627,7 +6646,20 @@ async function syncComponentsCommand(rawFlags) {
 
   // Through the same refusal-aware door as `stage`: the landing lease and the account's commit rules both
   // answer 409 with the sentence to act on, and that sentence must reach the caller intact.
-  const response = await stageOrRefuse(api, cwd, syncPayload);
+  if (!dryRun && !namesOnly) {
+    syncPayload.operationId = crypto.randomUUID();
+    const receiptDir = path.join(localStatePaths(cwd).actorDir, 'sync-operations');
+    fs.mkdirSync(receiptDir, { recursive: true });
+    fs.writeFileSync(path.join(receiptDir, syncPayload.operationId + '.json'), JSON.stringify({
+      operationId: syncPayload.operationId, baseUrl: normalizeBaseUrl(baseUrl), accountId,
+      branchName, workspace, dataMode, created: new Date().toISOString()
+    }, null, 2), { mode: 0o600 });
+    console.error('Sync operation: ' + syncPayload.operationId);
+  }
+  const response = syncPayload.operationId
+    ? await require('./lib/sync-operation').submitSync(
+      (payload) => stageOrRefuse(api, cwd, payload), observeOperation, syncPayload, operationOptions)
+    : await stageOrRefuse(api, cwd, syncPayload);
 
   if (!response.success) {
     throw new Error(response.message || 'Server sync failed');
@@ -8344,8 +8376,9 @@ async function waitForStatus(api, cwd, accountId, branchName, taskId, token, dat
   }
 }
 
+// `incomplete`: a durable checkpoint nothing replaced — the run stopped without a final result (ticket 67537).
 function testStatusIsTerminal(status = {}) {
-  return ['completed', 'failed', 'interrupted'].includes(String(status.status || '').toLowerCase());
+  return ['completed', 'failed', 'interrupted', 'incomplete'].includes(String(status.status || '').toLowerCase());
 }
 
 function testEvidenceCategories(status = {}, selectedNames = []) {
@@ -8477,6 +8510,15 @@ function detectNondeterministicTestRun(priorPackets, currentStatus, currentProve
   return null;
 }
 
+// The selection a run was ASKED for. Executed case names are not a selection: a full-suite run executes every
+// case, and reporting those names as `selectedCases` made it read as a run filtered down to them (ticket 67106).
+// Results recorded before the suite reported its selection fall back to the executed names, the old reading.
+function requestedTestSelection(status = {}) {
+  const result = status.result || {};
+  if (Array.isArray(result.selectedTestNames)) return result.selectedTestNames.filter(Boolean);
+  return Array.isArray(result.tests) ? result.tests.map((t) => t && t.name).filter(Boolean) : [];
+}
+
 async function appendTerminalTestRunEvidence(options = {}) {
   const {
     api,
@@ -8532,6 +8574,7 @@ async function appendTerminalTestRunEvidence(options = {}) {
       testId: status.test && status.test.id,
       testName: status.test && status.test.name,
       selectedCases: selectedNames,
+      declaredCases: status.result && Array.isArray(status.result.declaredTestNames) ? status.result.declaredTestNames : undefined,
       passed: status.result && status.result.passed,
       failed: status.result && status.result.failed,
       tests: status.result && status.result.tests,
@@ -9420,7 +9463,7 @@ async function testStatusCommand(flags) {
         flags: statusVerification.evidenceFlags,
         status,
         testRef: status.test && (status.test.name || status.test.id) || taskId,
-        selectedNames: status.result && Array.isArray(status.result.tests) ? status.result.tests.map((t) => t && t.name).filter(Boolean) : [],
+        selectedNames: requestedTestSelection(status),
         dataMode,
         dataModeSource,
         branchName,
@@ -9440,8 +9483,10 @@ async function testStatusCommand(flags) {
   testRunHeadlineLines(status, {
     taskId,
     source: status.durable
-      ? 'durable run record (the live status has expired; this run is final)'
-      : 'live run status',
+      ? (status.status === 'incomplete'
+        ? 'durable checkpoint (the run never recorded a final result; these are the cases it finished)'
+        : 'durable run record (the live status has expired; this run is final)')
+      : (status.partialResult ? 'live run status (the run failed outside its cases; these are the cases it finished)' : 'live run status'),
     dataMode,
     // A durable run reports the lane it RAN in. When that differs from the lane this command asked for,
     // say so: auditing prod activity and being handed a test-lane run is correct and reads as if it were not.
@@ -9460,7 +9505,7 @@ async function testStatusCommand(flags) {
       flags: statusVerification.evidenceFlags,
       status,
       testRef: status.test && (status.test.name || status.test.id) || taskId,
-      selectedNames: status.result && Array.isArray(status.result.tests) ? status.result.tests.map((t) => t && t.name).filter(Boolean) : [],
+      selectedNames: requestedTestSelection(status),
       dataMode,
       dataModeSource,
       branchName,
@@ -9476,7 +9521,7 @@ async function testStatusCommand(flags) {
       });
     }
   }
-  if (status.status === 'failed' || status.status === 'interrupted' || (status.result && status.result.failed > 0)) {
+  if (status.status === 'failed' || status.status === 'interrupted' || status.status === 'incomplete' || (status.result && status.result.failed > 0)) {
     process.exitCode = 1;
   }
   return status;
@@ -14158,23 +14203,50 @@ function resolveAgentId(flags, options = {}) {
   if (explicit) {
     return String(explicit).trim();
   }
+  const own = ownLocalAgent(flags);
+  if (own) {
+    return own.agentId;
+  }
+  if (options.optional) return null;
   const local = listLocalAgents();
   if (!local.length) {
-    if (options.optional) return null;
     throw new Error('No local agent is registered in this session. Run: remits-cli agent register');
   }
-  const cwd = process.cwd();
-  const inCwd = local.filter((entry) => entry.cwd === cwd);
-  const candidates = inCwd.length ? inCwd : local;
-  if (candidates.length === 1) {
-    return candidates[0].agentId;
-  }
   throw new Error(
-    'Several local agents are registered. Pass --agent-id (or set REMITS_AGENT_ID). Candidates:\n' +
-    candidates.map((entry) => '  ' + entry.agentId + '  ' + (entry.label || '') + '  ' + entry.cwd).join('\n')
+    'No agent is registered for THIS terminal session; the local agents below belong to other sessions. ' +
+    'Pass --agent-id (or set REMITS_AGENT_ID) to act as one of them on purpose. Candidates:\n' +
+    local.map((entry) => '  ' + entry.agentId + '  ' + (entry.label || '') + '  ' + entry.cwd).join('\n')
   );
 }
 
+/**
+ * The local agent registration THIS process belongs to — never merely "an agent on this machine".
+ *
+ * `~/.remits-cli/agents.json` is machine-wide: every live terminal that ran `agent register`/`serve` has
+ * an entry there. Commands used to take the first entry (the most recently registered) or "the
+ * only one in this cwd", so a Codex session registered against localhost silently pointed a Claude
+ * session's `ticket` verbs at localhost — where the ticket does not exist, answered "No accessible
+ * support ticket" — and `agent release`/`agent work` could act as the other session's agent.
+ *
+ * Ownership is explicit (`--agent-id` / `REMITS_AGENT_ID`, which a supervised worker always carries) or
+ * the registration anchored to this terminal's own agent/shell process — the same anchor `agent
+ * register` records. Anything else is somebody else's, and the caller falls back to its flags and the
+ * CLI default rather than inheriting a stranger's host, lane and identity.
+ */
+function ownLocalAgent(flags, knownAnchor) {
+  const local = listLocalAgents();
+  if (!local.length) return null;
+  const explicit = textFlag(flags && (flags['agent-id'] || flags.agentId)) || textFlag(process.env.REMITS_AGENT_ID);
+  if (explicit) {
+    return local.find((entry) => entry.agentId === explicit) || null;
+  }
+  const anchor = knownAnchor || resolveAgentAnchorPid();
+  if (!anchor || !anchor.pid) return null;
+  const mine = local.filter((entry) => entry.anchorPid === anchor.pid && entry.anchorSource === anchor.source);
+  const cwd = process.cwd();
+  return mine.find((entry) => entry.cwd === cwd) || mine[0] || null;
+}
+
 /**
  * The host and lane a support agent registers against when it is told nothing.
  *
@@ -14304,10 +14376,10 @@ async function agentRegisterCommand(flags, options = {}) {
   const explicitPersona = textFlag(flags.persona) || textFlag(options.serve && options.serve.persona) || textFlag(process.env.REMITS_AGENT_PERSONA);
   // Adopt a previous registration only for THIS terminal. Matching on (cwd, anchorPid) alone was enough
   // to let an unrelated record be adopted whenever two registrations shared an anchor.
-  const existingId = explicitId ||
-    (listLocalAgents().find((entry) =>
-      entry.cwd === cwd && entry.anchorPid === anchor.pid && entry.anchorSource === anchor.source) || {}).agentId ||
-    null;
+  // `ownLocalAgent` is the one definition of "this terminal's registration"; re-registering additionally
+  // requires the same checkout, so a second repo in one terminal registers its own agent.
+  const own = explicitId ? null : ownLocalAgent(flags, anchor);
+  const existingId = explicitId || (own && own.cwd === cwd ? own.agentId : null);
 
   const api = buildAxios(baseUrl, session.token, 15000);
   const payload = {
@@ -15497,6 +15569,20 @@ function printTicketPolicy(response) {
   }
 }
 
+/**
+ * A ticket refusal names the platform and data lane that refused it.
+ *
+ * Ticket ids are global, but the record lives on ONE platform. A refusal from the wrong host - a local
+ * bootRun, a test lane - reads exactly like a refusal from the right one ("No accessible support ticket
+ * 67491"), and a caller who cannot see which host answered keeps retrying the wrong one.
+ */
+function ticketRefusalLine(context, message) {
+  const where = context && context.baseUrl
+    ? ' by ' + context.baseUrl + (context.dataMode ? ' (' + context.dataMode + ' lane)' : '')
+    : '';
+  return 'Refused' + where + ': ' + message;
+}
+
 async function ticketCommand(flags, subcommand) {
   const action = String(subcommand || 'read').toLowerCase();
 
@@ -15520,7 +15606,7 @@ async function ticketCommand(flags, subcommand) {
     throw new Error('A --ticket ID is required (or set REMITS_SUPPORT_TICKET_ID).');
   }
 
-  const local = listLocalAgents()[0] || null;
+  const local = ownLocalAgent(flags);
   const context = agentSessionFor(flags, local);
 
   // Routing lives on its own endpoint (the operator surface the dashboard and any Embeddable share),
@@ -15536,7 +15622,7 @@ async function ticketCommand(flags, subcommand) {
       .then((r) => r.data)
       .catch((err) => (err && err.response && err.response.data) || null);
     if (!result || result.success === false) {
-      console.error('Refused: ' + ((result && result.message) || 'routing failed'));
+      console.error(ticketRefusalLine(context, (result && result.message) || 'routing failed'));
       process.exitCode = 1;
       return;
     }
@@ -15632,7 +15718,7 @@ async function ticketCommand(flags, subcommand) {
     // reach them intact rather than as an HTTP status.
     const body = err && err.response && err.response.data;
     if (body && body.message) {
-      console.error('Refused: ' + body.message);
+      console.error(ticketRefusalLine(context, body.message));
       process.exitCode = 1;
       return;
     }
@@ -15973,7 +16059,7 @@ function printTicketQueueRows(tickets) {
 }
 
 async function ticketGlobalQueueCommand(flags) {
-  const local = listLocalAgents()[0] || null;
+  const local = ownLocalAgent(flags);
   const context = agentSessionFor(flags, local);
   const entries = globalTicketQueueAccountEntries(flags, context);
   if (!entries.length) {
@@ -16072,7 +16158,7 @@ async function ticketQueueCommand(flags) {
     return ticketGlobalQueueCommand(flags);
   }
 
-  const local = listLocalAgents()[0] || null;
+  const local = ownLocalAgent(flags);
   const context = agentSessionFor(flags, local);
   const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
   if (!Number.isFinite(accountId) || accountId <= 0) {
@@ -16125,7 +16211,7 @@ async function ticketQueueCommand(flags) {
  * listing cannot cause a wrong reclaim even if this list is minutes old.</p>
  */
 async function ticketReclaimSweepCommand(flags) {
-  const local = listLocalAgents()[0] || null;
+  const local = ownLocalAgent(flags);
   const context = agentSessionFor(flags, local);
   const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
   if (!Number.isFinite(accountId) || accountId <= 0) {
@@ -16198,7 +16284,7 @@ async function ticketReclaimSweepCommand(flags) {
  * ticket it was given until the record no longer described one piece of work, or to drop the finding.</p>
  */
 async function ticketCreateCommand(flags) {
-  const local = listLocalAgents()[0] || null;
+  const local = ownLocalAgent(flags);
   const context = agentSessionFor(flags, local);
   const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
   if (!Number.isFinite(accountId) || accountId <= 0) {
@@ -16231,7 +16317,7 @@ async function ticketCreateCommand(flags) {
   } catch (err) {
     const body = err && err.response && err.response.data;
     if (body && body.message) {
-      console.error('Refused: ' + body.message);
+      console.error(ticketRefusalLine(context, body.message));
       process.exitCode = 1;
       return;
     }
@@ -16986,7 +17072,7 @@ async function agentWorkMapCommand(flags) {
 
 async function agentListCommand(flags) {
   const cwd = process.cwd();
-  const mine = listLocalAgents()[0] || null;
+  const mine = ownLocalAgent(flags);
   const context = agentSessionFor(flags, mine);
 
   // An explicit --account-id asks about one account. Otherwise, if this machine has a registered
@@ -17890,7 +17976,7 @@ function printComponentsHelp(subcommand) {
     return;
   }
   if (subcommand === 'sync') {
-    console.log('Usage: remits-cli components sync [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--create-variant-branch] [--summary] [--timeout-ms 60000] [--json]');
+    console.log('Usage: remits-cli components sync [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--create-variant-branch] [--summary] [--timeout-ms 60000] [--resume OPERATION_ID] [--wait-timeout-ms 600000] [--json]');
     console.log('       remits-cli components sync doctor [--json]');
     console.log('');
     console.log('On trunk this reconciles the pushed repository into live component rows.');
@@ -18000,7 +18086,7 @@ function printComponentsHelp(subcommand) {
   console.log('  remits-cli components lanes [--base-url URL] [--account-id ID] [--wait-change [--lane-id ID] [--timeout 600]] [--json]');
   console.log('  remits-cli components entries --lane-id ID [--base-url URL] [--account-id ID] [--json|--verbose]');
   console.log('  remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
-  console.log('  remits-cli components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary] [--timeout-ms 60000]');
+  console.log('  remits-cli components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary] [--timeout-ms 60000] [--resume OPERATION_ID] [--wait-timeout-ms 600000]');
   console.log('  remits-cli components commit [--yes] [--safe] [--message|-m "msg"] [--allow-empty true|false] [--skip-git true|false] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--json [--summary]]');
   console.log('');
   console.log('  --force-tombstones applies only on non-trunk variant syncs, when a missing trunk');
@@ -18309,7 +18395,7 @@ async function main() {
     console.log('  remits-cli components lanes [--base-url URL] [--account-id ID] [--json]');
     console.log('  remits-cli components entries --lane-id ID [--base-url URL] [--account-id ID] [--json|--verbose]');
     console.log('  remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
-    console.log('  remits-cli components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary] [--timeout-ms 60000]');
+    console.log('  remits-cli components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary] [--timeout-ms 60000] [--resume OPERATION_ID] [--wait-timeout-ms 600000]');
     console.log('  remits-cli components commit [--yes] [--safe] [--message|-m \"msg\"] [--allow-empty true|false] [--skip-git true|false] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--json [--summary]]');
     console.log('  remits-cli components promotion [<branch>] [--json] [--no-fail]  # promotion readiness + ordered next steps');
     console.log('  remits-cli components branches [--json]                     # committed branch variants for this account');

package/lib/sync-operation.js

@@ -0,0 +1,54 @@
+'use strict';
+
+// Observation never submits another sync. A timeout means the first request's outcome is unknown.
+async function observeSync(observe, operationId, options = {}) {
+  const now = options.now || Date.now;
+  const sleep = options.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const end = now() + (options.waitMs || 600000);
+  // A request can still be queued for admission (workload slot, landing lease) after the client gave up on it,
+  // so its receipt may not exist YET. Keep looking for a short grace before calling the outcome unknown.
+  const notFoundGraceMs = options.notFoundGraceMs === undefined ? 30000 : options.notFoundGraceMs;
+  let firstNotFoundAt = null;
+  while (now() < end) {
+    let result;
+    try { result = await observe(operationId); }
+    catch (err) {
+      if (err.response && [400, 401, 403, 404].includes(err.response.status)) throw err;
+      await sleep(2000);
+      continue;
+    }
+    if (result.operationState === 'SUCCEEDED' || result.operationState === 'FAILED') return result;
+    if (result.operationState === 'NOT_FOUND') {
+      if (firstNotFoundAt === null) firstNotFoundAt = now();
+      if (now() - firstNotFoundAt >= notFoundGraceMs) {
+        throw new Error('Sync outcome is unknown for ' + operationId + '. Inspect components sync doctor before submitting a new operation.');
+      }
+      await sleep(2000);
+      continue;
+    }
+    if (result.operationState !== 'RUNNING') {
+      throw new Error('Sync outcome is unknown for ' + operationId + '. Inspect components sync doctor before submitting a new operation.');
+    }
+    // The server says the request has outlived any process that could still be running it. Waiting longer
+    // cannot produce an answer; hand the caller the server's note instead of polling to the timeout.
+    if (result.overdue) {
+      throw new Error((result.note || 'Sync ' + operationId + ' is overdue and recorded no outcome.') + ' (operation ' + operationId + ')');
+    }
+    await sleep(2000);
+  }
+  throw new Error('Sync is still unresolved. Resume observation with: remits-cli components sync --resume ' + operationId);
+}
+
+async function submitSync(submit, observe, payload, options = {}) {
+  let result;
+  try { result = await submit(payload); }
+  catch (err) {
+    // stageOrRefuse preserves HTTP status on .status when it turns a server message into an Error.
+    const status = err.status || (err.response && err.response.status);
+    if (err.refused || (status && ![502, 503, 504].includes(status))) throw err;
+    return observeSync(observe, payload.operationId, options);
+  }
+  return result.pending ? observeSync(observe, payload.operationId, options) : result;
+}
+
+module.exports = { observeSync, submitSync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remits/remits-cli",
-  "version": "0.1.153",
+  "version": "0.1.155",
   "description": "Local CLI for auth, component sync, and live test execution against Remits",
   "license": "MIT",
   "private": false,
@@ -11,6 +11,7 @@
   "type": "commonjs",
   "files": [
     "index.js",
+    "lib/sync-operation.js",
     "README.md",
     "scripts/prepare-index-toc.js",
     "skills/remits-cli/SKILL.md",

package/skills/remits-cli/SKILL.md

@@ -223,7 +223,9 @@ reference named after it.
   routable and starts nothing. Use `remits-cli agent prune-worktrees` to clean up finished ticket worktrees.
   (`support-tickets.md`)
 - **`remits-cli ticket` is the platform's own ticket surface** and works on every Remits platform.
-  `mcp_support_ticket` is one System Account's convention and refuses tickets it does not own.
+  `mcp_support_ticket` is one System Account's convention and refuses tickets it does not own. A ticket
+  lives on ONE platform: every ticket refusal names the host that refused it, and `Refused by
+  http://localhost:8080` means "wrong host", not "no access" — re-run with the right `--base-url`.
   (`support-tickets.md`)
 - **Reading and investigating are parallel-safe; editing one account's repository is exclusive**, via a
   lease. A refusal is not an error — carry on read-only and hand off with `ticket progress --next-step`.

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

@@ -583,6 +583,12 @@ For tests specifically:
   trunk sync reports an untouched component under `unchanged`, not `updated`.
 - `--timeout-ms` on `components sync` controls the per-request HTTP timeout for every sync request,
   including `--safe` status/preflight and the durable sync write.
+- New platforms record each mutating `components sync` under a durable operation id, printed before
+  submission and saved under the local actor's `sync-operations/`. A lost response triggers status
+  observation, never another submission. `components sync --resume <operation-id>` resumes observation
+  in the same account, user, branch and workspace; `--wait-timeout-ms` bounds observation (default 10m).
+  A process that died mid-sync can leave an unresolved receipt; after an hour the CLI reports it as overdue
+  and stops waiting. Inspect `sync doctor` before deliberately starting a new operation. Older platforms cannot recover a result by operation id.
 - `components sync doctor` does not mutate. Use it when a sync timed out, status/promotion disagree, or
   you need to know whether staged entries would shadow committed-variant verification. It prints local
   `HEAD`, `origin/<branch>`, platform last-sync SHA, overlay freshness, repository mismatch, and a

package/skills/remits-cli/references/support-tickets.md

@@ -421,6 +421,23 @@ remits-cli ticket planning --ticket 22454 --board-stage ready_for_qa --blocked-b
 remits-cli ticket release  --ticket 22454        # hand it back to the queue
 ```
 
+**Which platform answers.** A ticket id is global, but the record lives on ONE platform. Ticket verbs go
+to `--base-url` when you pass it; otherwise to the registration of THIS terminal's own agent (`agent
+serve`/`register`, or `REMITS_AGENT_ID` in a worker); otherwise to the production platform. Another
+terminal's agent on the same machine is never used — it may be pinned to localhost. Every refusal names
+who refused it: `Refused by http://localhost:8080 (prod lane): No accessible support ticket 67491` is a
+WRONG-HOST answer (a local bootRun does not hold production tickets), not an access problem. Re-run
+against the host you meant; do not retry the same call or look for another door.
+
+**`--account-id` does not pick or authorise the ticket.** The ticket's owning account does — the platform
+resolves it from the ticket itself. Leave `--account-id` off lifecycle verbs; it is for `queue`, `create`
+and `reclaim`, which have no ticket to resolve from.
+
+**Write flags out in full.** `B="--data-mode prod --base-url URL"; remits-cli ticket accept ... $B` passes
+ONE argument under zsh (it does not split an unquoted variable), so the command ran with neither flag. The
+CLI now refuses such an argument; use `B=(--data-mode prod --base-url URL)` and `"${B[@]}"` if you need a
+variable at all.
+
 **See the whole queue before deciding your ticket is unique.** Alert-raised tickets arrive in
 clusters, and the same root cause routinely appears under several different account names — so the
 first useful question is usually "how many of these are one fix?", and you cannot ask it from a single

package/skills/remits-cli/references/troubleshooting.md

@@ -17,6 +17,8 @@
 | Symptom | Fix |
 |---|---|
 | 401 or `Not authenticated` | Run `remits-cli auth` |
+| `Refused by <host>: No accessible support ticket N` | Read the host. A local or staging host does not hold production tickets, so this is a wrong-host answer: re-run with `--base-url` set to the platform that owns the ticket. `--account-id` cannot fix it (the ticket's own account is what is checked). See `support-tickets.md` → *Moving a ticket through its lifecycle*. |
+| `One argument holds several flags` | Your shell passed `--flag value --flag value` as ONE word (zsh does not split an unquoted `$VAR`). Write the flags out, or use an array and `"${B[@]}"`. |
 | `account-info.json not found` | Run from the account repo root |
 | Test not found (404) | New component not staged yet. Run `remits-cli components stage` first. For new tests (no ID), run by name not ID. |
 | Stage shows 0 updated | No changes since last stage (hash dedup) |