@remits/remits-cli 0.1.159 → 0.1.161

package/index.js

@@ -12,10 +12,10 @@
 - L4591  Auth And Component Staging
 - L5223  Component Summaries, Status, And Sync Gates
 - L7547  Branches, Promotion, Commit, And Test Runs
-- L9790  Tokens, Tools, Verification, And Config
-- L11307  Service Dashboard And WebSocket Listener
-- L13806  Agent And Ticket Workflows
-- L17982  Help, Auto Update, And Command Dispatch
+- L9791  Tokens, Tools, Verification, And Config
+- L11308  Service Dashboard And WebSocket Listener
+- L13808  Agent And Ticket Workflows
+- L18069  Help, Auto Update, And Command Dispatch
 */
 
 /*
@@ -9144,6 +9144,7 @@ function watchWebsocket(baseUrl, topicId, taskId, options = {}) {
   const emit = options.stderr ? console.error : console.log;
   const client = new Client({
     brokerURL: webSocketUrl(baseUrl),
+    connectHeaders: { 'X-Auth-Token': options.token || '' },
     reconnectDelay: 3000,
     heartbeatIncoming: 10000,
     heartbeatOutgoing: 10000,
@@ -9444,7 +9445,7 @@ async function testCommand(flags) {
   if (flags.watch !== 'false') {
     const topic = session.websocketTopic || start.websocketTopic || (session.user && String(session.user.uuid || '').replace(/-/g, ''));
     if (topic) {
-      stopWs = watchWebsocket(baseUrl, topic, start.shardTaskIds || start.taskId, { stderr: jsonOutput, verbose: flagEnabled(flags.verbose) });
+      stopWs = watchWebsocket(baseUrl, topic, start.shardTaskIds || start.taskId, { stderr: jsonOutput, verbose: flagEnabled(flags.verbose), token: session.token });
     }
   }
 
@@ -13548,6 +13549,7 @@ function createManagedWebsocketClient(baseUrl, urlSessions) {
     },
     debug: () => {},
     beforeConnect: () => {
+      client.connectHeaders['X-Remits-Tokens'] = JSON.stringify((managedClient.urlSessions || []).map((entry) => entry.token).filter(Boolean));
       managedClient.lastConnectAttemptAt = Date.now();
       ensureRuntimeWebsocketEntry(normalizedBaseUrl);
       runtimeState.websocket[normalizedBaseUrl] = {
@@ -16717,6 +16719,91 @@ function describeRunLocation(record) {
   return parts.join('  ');
 }
 
+function usageListFlag(value) {
+  if (value === undefined || value === null || value === true) return undefined;
+  const items = String(value).split(',').map((item) => item.trim()).filter(Boolean);
+  return items.length ? items : undefined;
+}
+
+async function usageCommand(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 api = buildAxios(baseUrl, session.token, 120000);
+  const query = {
+    from: flags.from,
+    to: flags.to,
+    timezone: flags.timezone || flags.tz,
+    by: flags.by,
+    groupBy: usageListFlag(flags['group-by'] || flags.groupBy),
+    capabilities: usageListFlag(flags.capabilities || flags.capability),
+    lanes: usageListFlag(flags.lanes || flags.lane),
+    accountId: flags['target-account-id'] || flags.targetAccountId,
+    includeDescendants: flagEnabled(flags['include-descendants']) || undefined,
+    includeSuites: flagEnabled(flags['include-suites']) || undefined,
+    includeMocked: flagEnabled(flags['include-mocked']) || undefined,
+    allocateShared: flagEnabled(flags['allocate-shared']) || undefined,
+    scope: flagEnabled(flags.platform) ? 'platform' : undefined
+  };
+  Object.keys(query).forEach((key) => query[key] === undefined && delete query[key]);
+  const response = await loggedPost(api, cwd, '/cli/usage', {
+    token: session.token,
+    accountId,
+    dataMode: resolveDataMode(flags, session),
+    query
+  }).then((r) => r.data);
+
+  if (!response.success) throw new Error(response.message || 'Usage report failed');
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return response;
+  }
+  printSessionResolutionWarning(sessionContext);
+  printResolvedBaseUrl(baseUrl);
+  printUsageSummary(response);
+  return response;
+}
+
+function formatUsageCurrencies(row) {
+  const entries = Object.entries(row.costByCurrency || { USD: row.cost || 0 });
+  return entries.length ? entries.map(([currency, value]) => currency + ' ' + Number(value).toFixed(4)).join(' / ') : 'USD 0.0000';
+}
+
+function formatUsageCost(row) {
+  const marker = row.costComplete === false ? ' (floor: ' + (row.unpricedEvents || 0) + ' unpriced)' : '';
+  return formatUsageCurrencies(row) + ' ' + (row.basis || '') + marker;
+}
+
+function printUsageSummary(report) {
+  const selector = report.selector || {};
+  console.log('Usage ' + selector.from + ' .. ' + selector.to + ' (' + (selector.timezone || 'UTC') + ', by ' + selector.by + ')');
+  console.log('Total: ' + formatUsageCost(report));
+  const rows = report.rows || [];
+  const names = report.accountNames || {};
+  rows.forEach((row) => {
+    const who = row.accountId !== undefined ? ' account ' + (row.accountId === null ? 'platform' : (names[row.accountId] || row.accountId)) : '';
+    const sku = row.sku !== undefined ? ' [' + (row.sku || '-') + ']' : '';
+    const quantities = Object.entries(row.quantities || {}).map(([unit, value]) => unit + '=' + value).join(' ');
+    console.log('  ' + row.period + '  ' + row.capability + who + sku + '  ' + formatUsageCost(row) + (quantities ? '  ' + quantities : ''));
+  });
+  const excluded = report.excluded || {};
+  const excludedKeys = Object.keys(excluded);
+  if (excludedKeys.length) {
+    console.log('Excluded by the filters: ' + excludedKeys.map((key) => key + ' ' + (excluded[key].events || 0) + ' ops ' + formatUsageCurrencies(excluded[key])).join(', '));
+  }
+  const coverage = report.coverage || {};
+  const partial = Object.keys(coverage).filter((cap) => coverage[cap].partial || coverage[cap].measured === false);
+  if (partial.length) {
+    console.log('Coverage: ' + partial.map((cap) => cap + (coverage[cap].measured === false ? ' not measured yet' : ' from ' + coverage[cap].coverageFrom)).join(', '));
+  }
+  if (report.invoiced && report.invoiced.available) {
+    console.log('Invoiced (allocated provider bill) in range: ' + formatUsageCurrencies(report.invoiced));
+    if (report.invoiced.message) console.log(report.invoiced.message);
+  }
+}
+
 async function activityInspectCommand(flags) {
   const cwd = process.cwd();
   ensureLocalState(cwd);
@@ -18597,6 +18684,7 @@ async function main() {
     console.log('  remits-cli agent map [--account-ids 1,4] [--json]                   # who is EDITING what, where, right now');
     console.log('  remits-cli activity inspect [--account-id ID] [--scope self|children|related] [--workspace NAME] [--workstream ID] [--user-email E] [--summary|--compact] [--json]');
     console.log('  remits-cli workstream status [--workstream ID|--workspace NAME] [--json]');
+    console.log('  remits-cli usage --from DATE [--to DATE] [--by hour|day|month] [--group-by account,sku] [--capabilities ai,document_store] [--json]');
     console.log('  remits-cli agent release                                            # stop receiving tickets now');
     console.log('  remits-cli start [--foreground true] [--port 8787]                  # human dashboard in the browser');
     console.log('  remits-cli stop');
@@ -18859,6 +18947,23 @@ async function main() {
     throw new Error('Unknown activity subcommand: ' + subcommand);
   }
 
+  if (command === 'usage') {
+    if (wantsHelp) {
+      console.log('Usage: remits-cli usage --from DATE [--to DATE] [--timezone ZONE] [--by hour|day|month]');
+      console.log('         [--group-by account,sku,segment,provider] [--capabilities ai,document_store,...]');
+      console.log('         [--target-account-id ID] [--include-descendants] [--lanes prod,test|all]');
+      console.log('         [--include-suites] [--include-mocked] [--allocate-shared] [--platform] [--json]');
+      console.log('');
+      console.log('What the account used and cost, by capability: the same answer as front-stage usage([...]).');
+      console.log('Defaults: prod lane, nothing a Test suite caused, nothing mocked; "Excluded" says what that left out.');
+      console.log('Each figure has a basis (invoiced > reported > estimated > metered); a cost marked "floor" has');
+      console.log('unpriced operations. --platform (platform administrators) reports every account and platform usage.');
+      return;
+    }
+    await usageCommand(args);
+    return;
+  }
+
   if (command === 'evidence') {
     if (wantsHelp) {
       console.log('Usage: remits-cli evidence [--limit N] [--json]');

package/lib/local-ai.js

@@ -66,8 +66,60 @@ function assertTextRequest(request) {
   }
 }
 
-function promptFor(packet) {
-  return [
+// The offered tools and choice rules, derived exactly as LocalAiBridge.decision derives them.
+function offeredTools(request = {}) {
+  const legacy = !request.tools?.length && !!request.functions?.length;
+  const names = [...new Set((request.tools?.length ? request.tools : request.functions || [])
+    .map((tool) => tool?.function?.name ?? tool?.name).filter((name) => typeof name === 'string' && name))];
+  const choice = legacy ? request.function_call : request.tool_choice;
+  const required = choice && typeof choice === 'object' ? (legacy ? choice.name : choice.function?.name) || null : null;
+  return { legacy, names, choice, required };
+}
+
+// The transport envelope for THIS packet. Only names and counts are constrained: arguments stay a plain
+// object because tool schemas are repaired forgivingly server-side, and the server still validates all.
+function decisionSchema(request) {
+  const { legacy, names, choice, required } = offeredTools(request);
+  const allowed = required ? names.filter((name) => name === required) : names;
+  let toolCalls;
+  if (!allowed.length || choice === 'none') toolCalls = { type: 'array', maxItems: 0 };
+  else {
+    toolCalls = { type: 'array', items: { type: 'object', additionalProperties: false, required: ['name', 'arguments'],
+      properties: { name: { type: 'string', enum: allowed }, arguments: { type: 'object' } } } };
+    if (choice === 'required' || required) toolCalls.minItems = 1;
+    if (legacy || request.parallel_tool_calls === false) toolCalls.maxItems = 1;
+  }
+  return { type: 'object', additionalProperties: false, required: ['content', 'toolCalls'],
+    properties: { content: { type: ['string', 'null'] }, toolCalls } };
+}
+
+// An exact continuation of the previous packet: appended messages, a few same-position replacements
+// (e.g. a regenerated runtime-context message) and changed top-level fields. Null when history was
+// pruned or reordered, when more than MAX_REPLACED messages changed, or when it would not be smaller.
+const MAX_REPLACED = 2;
+function continuation(base, request) {
+  if (!base?.request || !Array.isArray(base.request.messages) || !Array.isArray(request?.messages)) return null;
+  const previous = base.request.messages;
+  if (request.messages.length <= previous.length) return null;
+  const replacedMessages = {};
+  for (let i = 0; i < previous.length; i++) {
+    if (JSON.stringify(previous[i]) === JSON.stringify(request.messages[i])) continue;
+    if (previous[i]?.role !== request.messages[i]?.role || Object.keys(replacedMessages).length >= MAX_REPLACED) return null;
+    replacedMessages[i] = request.messages[i];
+  }
+  const changedFields = {};
+  for (const key of Object.keys(request)) {
+    if (key !== 'messages' && JSON.stringify(request[key]) !== JSON.stringify(base.request[key])) changedFields[key] = request[key];
+  }
+  const removedFields = Object.keys(base.request).filter((key) => key !== 'messages' && !Object.hasOwn(request, key));
+  const delta = { appendedMessages: request.messages.slice(previous.length), changedFields, removedFields };
+  if (Object.keys(replacedMessages).length) delta.replacedMessages = replacedMessages;
+  return JSON.stringify(delta).length < JSON.stringify(request).length ? delta : null;
+}
+
+function promptFor(packet, { agent, base } = {}) {
+  const delta = base ? continuation(base, packet.request) : null;
+  const lines = [
     'You are the receiving model for a Remits AI invocation. Produce ONE next assistant decision.',
     'The JSON packet below is the exact outgoing model request, including system instructions, messages,',
     'tool definitions, tool choice, and response-format requirements. Treat it as authoritative for this turn.',
@@ -77,16 +129,31 @@ function promptFor(packet) {
     'send you a new packet with the results in this SAME conversation. Never fabricate a tool result.',
     'Only call tools offered in THIS packet. Respect tool_choice and parallel_tool_calls.',
     'Earlier packets may have been pruned or corrected. Do not use omitted content as authoritative input.',
-    'Return ONLY one JSON object: {"content":"assistant reply or null","toolCalls":[{"name":"offered name","arguments":{}}]}.',
+    'If a decision you returned earlier is not reflected in this request, Remits did not accept or execute it.'
+  ];
+  if (agent === 'claude') {
+    lines.push('Deliver the decision by calling the StructuredOutput tool exactly once with',
+      '{"content":"assistant reply or null","toolCalls":[{"name":"offered name","arguments":{}}]}.',
+      'StructuredOutput is the Remits transport for this decision, not a workflow tool. Prose, markdown,',
+      'or fenced "tool call" examples outside StructuredOutput are discarded and never executed.');
+  } else {
+    lines.push('Return ONLY one JSON object: {"content":"assistant reply or null","toolCalls":[{"name":"offered name","arguments":{}}]}.');
+  }
+  lines.push(
     'Use actual JSON null for absent content and [] for no tool calls. If a response_format asks for JSON,',
     'put that formatted response as a JSON-encoded STRING in content, inside this transport envelope.',
     'If the requested reply is empty, return {"content":"","toolCalls":[]} rather than omitting the envelope.',
     'For a content/XML tool channel, put the required tool markup in content and leave toolCalls empty.',
-    `Remits sessionId: ${packet.sessionId}; requestId: ${packet.requestId}.`,
-    '<remits_request>',
-    JSON.stringify(packet.request),
-    '</remits_request>'
-  ].join('\n');
+    `Remits sessionId: ${packet.sessionId}; requestId: ${packet.requestId}.`);
+  const full = ['<remits_request>', JSON.stringify(packet.request), '</remits_request>'];
+  const continued = delta && [`This request CONTINUES request ${base.requestId}, already in this conversation. Reconstruct the exact`,
+    'outgoing request: take that request as you reconstructed it, replace the messages at each replacedMessages index',
+    '(0-based, if present), append appendedMessages, replace each changedFields entry, and drop removedFields.',
+    'Everything else in it is unchanged and still authoritative.',
+    '<remits_request_continuation>', JSON.stringify(delta), '</remits_request_continuation>'];
+  // A continuation exists only to shrink the turn; short histories are cheaper re-sent whole.
+  const chosen = continued && continued.join('\n').length < full.join('\n').length ? continued : full;
+  return [...lines, ...chosen].join('\n');
 }
 
 function parseDecision(text) {
@@ -94,6 +161,10 @@ function parseDecision(text) {
   let result;
   try { result = JSON.parse(clean); }
   catch (_) { throw new Error('Local agent did not return the decision JSON envelope'); }
+  return validateDecision(result);
+}
+
+function validateDecision(result) {
   if (!result || typeof result !== 'object' || Array.isArray(result)) throw new Error('Local agent decision must be an object');
   if (result.error) return { error: String(result.error).slice(0, 4000) };
   if (result.content != null && typeof result.content !== 'string') throw new Error('Decision content must be a string or null');
@@ -108,7 +179,9 @@ function parseDecision(text) {
 }
 
 // Use explicit native IDs, never --last/--continue. Each session has an empty, stable working directory.
-function nativeCommand(agent, nativeSessionId, model) {
+// Claude's decision is enforced natively: --json-schema offers only the synthetic StructuredOutput tool
+// (verified with --tools '' and --resume), validates it, and returns it as result.structured_output.
+function nativeCommand(agent, nativeSessionId, model, request = {}) {
   let args;
   if (agent === 'codex') {
     args = ['exec', '--sandbox', 'read-only', '--json', '--skip-git-repo-check'];
@@ -117,7 +190,8 @@ function nativeCommand(agent, nativeSessionId, model) {
     args.push('-');
   } else if (agent === 'claude') {
     args = ['-p', '--output-format', 'stream-json', '--verbose', '--tools', '',
-      '--strict-mcp-config', '--disable-slash-commands', '--setting-sources', ''];
+      '--strict-mcp-config', '--disable-slash-commands', '--setting-sources', '',
+      '--json-schema', JSON.stringify(decisionSchema(request))];
     if (nativeSessionId) args.push('--resume', nativeSessionId);
     if (model) args.push('--model', model);
   } else if (agent === 'gemini') {
@@ -136,6 +210,7 @@ function consumeEvent(agent, event, state) {
     identifier(id);
     if (state.nativeSessionId && state.nativeSessionId !== id) throw new Error('Native agent changed session ID; refusing to fork the Remits session');
     state.nativeSessionId = id;
+    state.started = true;
   }
   if (event.model) state.model = String(event.model);
   if (agent === 'codex') {
@@ -143,6 +218,16 @@ function consumeEvent(agent, event, state) {
     if (event.type === 'turn.completed') state.completed = true;
     if (event.type === 'turn.failed' || event.type === 'error') state.error = event.error?.message || event.message || 'Codex turn failed';
   } else if (agent === 'claude') {
+    if (event.type === 'system' && event.subtype === 'init') {
+      if (event.claude_code_version) state.version = String(event.claude_code_version).slice(0, 40);
+      if (Array.isArray(event.tools) && !event.tools.includes('StructuredOutput')) {
+        const error = new Error(`Claude Code ${state.version || ''} did not offer StructuredOutput for --json-schema; upgrade Claude Code. No decision was requested.`);
+        error.notStarted = true;
+        throw error;
+      }
+    }
+    // Native history was summarized: the next turn must not rely on an earlier packet being verbatim.
+    if (event.type === 'system' && event.subtype === 'compact_boundary') state.compacted = true;
     if (event.type === 'assistant') {
       if (event.message?.model) state.model = event.message.model;
       const content = (event.message?.content || []).filter((part) => part.type === 'text').map((part) => part.text).join('');
@@ -150,8 +235,16 @@ function consumeEvent(agent, event, state) {
     }
     if (event.type === 'result') {
       state.completed = true;
-      state.text = event.structured_output ? JSON.stringify(event.structured_output) : (event.result || state.text);
-      if (event.is_error || (event.subtype && event.subtype !== 'success')) state.error = event.result || (event.errors || []).join('; ') || event.subtype;
+      // Only the schema-validated structured result is a decision; result text is never parsed for one.
+      if (event.structured_output != null) state.decision = event.structured_output;
+      state.text = event.result || state.text;
+      state.outcome = { subtype: event.subtype, turns: event.num_turns, stop: event.stop_reason };
+      if (event.is_error || (event.subtype && event.subtype !== 'success')) {
+        state.error = (event.errors || []).join('; ') || (event.is_error && event.result) || event.subtype;
+        if (event.subtype === 'error_max_structured_output_retries') {
+          state.error = 'Claude exhausted its structured-output retries without a valid decision envelope';
+        }
+      }
     }
   } else if (agent === 'gemini') {
     if (event.type === 'message' && event.role === 'assistant') state.text = (state.text || '') + (event.content || '');
@@ -162,9 +255,14 @@ function consumeEvent(agent, event, state) {
   }
 }
 
-function runNative({ agent, nativeSessionId, model, cwd, packet, signal, onSession, onProcess }, spawnFn = spawn) {
+// Packet continuations are limited to adapters whose native history compaction is observable.
+const CONTINUATION_AGENTS = new Set(['claude']);
+
+// A rejection carries what the supervisor needs to settle the session: notStarted (no native turn
+// began, so nothing is uncertain) or completedTurn (the native turn settled; only its decision failed).
+function runNative({ agent, nativeSessionId, model, cwd, packet, base, signal, onSession, onProcess }, spawnFn = spawn) {
   assertTextRequest(packet.request);
-  const command = nativeCommand(agent, nativeSessionId, model);
+  const command = nativeCommand(agent, nativeSessionId, model, packet.request);
   return new Promise((resolve, reject) => {
     const env = { ...process.env };
     // Authentication for Remits stays in the supervisor. Native CLIs retain their own login/environment.
@@ -175,7 +273,7 @@ function runNative({ agent, nativeSessionId, model, cwd, packet, signal, onSessi
     const state = { nativeSessionId, text: '', completed: false };
     let bytes = 0, buffer = '', stderr = '', fatal, killTimer;
     const kill = (reason) => {
-      if (!fatal) fatal = new Error(reason);
+      if (!fatal) fatal = reason instanceof Error ? reason : new Error(reason);
       const send = (sig) => {
         try { process.platform === 'win32' ? child.kill(sig) : process.kill(-child.pid, sig); } catch (_) { /* exited */ }
       };
@@ -191,7 +289,7 @@ function runNative({ agent, nativeSessionId, model, cwd, packet, signal, onSessi
         const previous = state.nativeSessionId;
         consumeEvent(agent, event, state);
         if (state.nativeSessionId && state.nativeSessionId !== previous) onSession?.(state.nativeSessionId);
-      } catch (error) { kill(error.message); }
+      } catch (error) { kill(error); }
     };
     child.stdout.setEncoding('utf8');
     child.stderr.setEncoding('utf8');
@@ -214,22 +312,48 @@ function runNative({ agent, nativeSessionId, model, cwd, packet, signal, onSessi
       handleLine(buffer);
       clearTimeout(killTimer);
       try { onProcess?.(null); } catch (error) { fatal = error; }
-      if (fatal || code !== 0 || state.error || !state.completed || !state.nativeSessionId) {
-        reject(fatal || new Error(state.error || `Native ${agent} failed (exit ${code}; completed=${state.completed}; session=${!!state.nativeSessionId}). ${stderr}`));
+      const settled = !fatal && code === 0 && state.completed && !!state.nativeSessionId;
+      const fail = (error) => {
+        if (!state.started) error.notStarted = true;
+        if (settled) error.completedTurn = true;
+        reject(error);
+      };
+      if (!settled || state.error) {
+        const option = code !== 0 && /unknown option '?(--[\w-]+)/i.exec(stderr);
+        fail(fatal || new Error(option ? `Installed ${agent} CLI does not support ${option[1]}; upgrade it. No native turn ran.` :
+          state.error ? `Native ${agent} turn failed: ${String(state.error).slice(0, 1000)}${describe(state)}` :
+            `Native ${agent} failed (exit ${code}; completed=${state.completed}; session=${!!state.nativeSessionId}). ${stderr}`));
         return;
       }
-      try { resolve({ ...parseDecision(state.text), nativeSessionId: state.nativeSessionId, model: state.model || model || null }); }
-      catch (error) { reject(error); }
+      try {
+        let decision;
+        if (agent === 'claude') {
+          if (state.decision == null) {
+            throw new Error('Claude completed without a structured decision: StructuredOutput was not called, so its ' +
+              `${String(state.text || '').length}-character reply was neither parsed nor executed${describe(state)}`);
+          }
+          decision = validateDecision(state.decision);
+        } else decision = parseDecision(state.text);
+        resolve({ ...decision, nativeSessionId: state.nativeSessionId, model: state.model || model || null, compacted: !!state.compacted });
+      } catch (error) { fail(error); }
     });
     try {
       onProcess?.(child.pid);
       signal?.addEventListener('abort', onAbort, { once: true });
       if (signal?.aborted) onAbort();
-      child.stdin.end(promptFor(packet));
+      child.stdin.end(promptFor(packet, { agent, base: CONTINUATION_AGENTS.has(agent) ? base : null }));
     } catch (error) { kill(error.message); }
   });
 }
 
+// Bounded native diagnostics: identifiers and counts only, never packet or reply content.
+function describe(state) {
+  const parts = [state.version && 'native ' + state.version, state.model && 'model ' + state.model,
+    state.outcome?.subtype && 'result ' + state.outcome.subtype, state.outcome?.turns != null && 'turns ' + state.outcome.turns,
+    state.outcome?.stop && 'stop ' + state.outcome.stop].filter(Boolean);
+  return parts.length ? ` (${parts.join('; ')})` : '';
+}
+
 class Supervisor {
   constructor({ api, dir, worker, agent, model, log = console.error, run = runNative, clock = Date.now, onStop }) {
     Object.assign(this, { api, dir, worker, agent, model, log, run, clock, onStop });
@@ -310,23 +434,27 @@ class Supervisor {
       } else {
         const cwd = path.join(this.dir, 'workspaces', sessionId);
         mkdir(cwd);
+        const base = this.continuationBase(session);
+        const prior = { state: session.state, requestId: session.requestId, nativeSessionId: session.nativeSessionId };
         cached = { packet, state: 'running' };
         write(requestFile, cached);
         Object.assign(session, { state: 'running', requestId: id, updatedAt: this.clock() });
         write(sessionFile, session);
         const timeout = setTimeout(() => task.controller.abort(), Math.max(1, packet.expiresAt - this.clock()));
         try {
-          answer = await this.run({
-            agent: this.agent, nativeSessionId: session.nativeSessionId, model: this.model, cwd, packet,
+          const { compacted, ...decision } = await this.run({
+            agent: this.agent, nativeSessionId: session.nativeSessionId, model: this.model, cwd, packet, base,
             signal: task.controller.signal,
             onSession: (nativeSessionId) => { session.nativeSessionId = nativeSessionId; write(sessionFile, session); },
             onProcess: (pid) => { session.pid = pid; write(sessionFile, session); }
           });
-          session.nativeSessionId = answer.nativeSessionId;
-          session.state = 'ready';
+          answer = decision;
+          Object.assign(session, { nativeSessionId: answer.nativeSessionId, state: 'ready', refreshPacket: !!compacted });
           this.log(`Local AI ${id}: ${this.agent} session ${session.nativeSessionId} → Remits ${sessionId}`);
         } catch (error) {
-          session.state = 'uncertain';
+          if (error.notStarted) Object.assign(session, prior); // Nothing reached the native conversation.
+          else if (error.completedTurn) session.state = 'ready'; // Settled turn; its rejected decision is never a base.
+          else session.state = 'uncertain';
           answer = { error: error.message.slice(0, 4000), nativeSessionId: session.nativeSessionId };
         } finally { clearTimeout(timeout); }
         // Write the response first; after a crash it can be delivered without another inference.
@@ -352,6 +480,16 @@ class Supervisor {
     }
   }
 
+  // The previous packet may be sent as a prefix only when its decision was delivered from this same
+  // native conversation and native history has not been compacted since.
+  continuationBase(session) {
+    if (!session.nativeSessionId || !session.requestId || session.refreshPacket || session.state !== 'ready') return null;
+    const prior = read(path.join(this.dir, 'requests', identifier(session.requestId) + '.json'));
+    if (prior?.state !== 'delivered' || !prior.packet?.request || !prior.response || prior.response.error ||
+        prior.response.nativeSessionId !== session.nativeSessionId) return null;
+    return { requestId: session.requestId, request: prior.packet.request };
+  }
+
   async stop() {
     this.stopping = true;
     for (const task of this.active.values()) task.controller.abort();
@@ -434,7 +572,10 @@ async function command({ subcommand, flags, context, root, axios, Client, WebSoc
         webSocketFactory: () => new WebSocket(baseUrl.replace(/^http/, 'ws').replace(/\/+$/, '') + '/stomp'),
         reconnectDelay: 5000, heartbeatIncoming: 10000, heartbeatOutgoing: 10000,
         connectionTimeout: 15000, discardWebsocketOnCommFailure: true, debug: () => {},
-        connectHeaders: { 'x-remits-ws-label': 'remits-cli-ai', 'x-remits-user-id': String(session.user.id) },
+        // The STOMP connection has no HTTP session cookie. Use the same credential as polling;
+        // diagnostic user IDs are not authentication. STOMP resends these on every reconnect.
+        connectHeaders: { 'X-Auth-Token': session.token,
+          'x-remits-ws-label': 'remits-cli-ai', 'x-remits-user-id': String(session.user.id) },
         onConnect: () => {
           socket.subscribe('/topic/messages/' + topic, (message) => {
             try {
@@ -462,4 +603,4 @@ async function command({ subcommand, flags, context, root, axios, Client, WebSoc
 }
 
 module.exports = { command, help, Supervisor, runNative, nativeCommand, consumeEvent, promptFor, parseDecision,
-  assertTextRequest, stateDirectory, acquireLock, read, write, identifier };
+  validateDecision, decisionSchema, offeredTools, continuation, assertTextRequest, stateDirectory, acquireLock, read, write, identifier };

package/package.json

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

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

@@ -29,6 +29,13 @@ and a precise diagnosis.
 
 ### The three source layers + the compile cache
 
+CLI global Tools resolve staged edits in the Tool owner's account using the caller's user,
+git branch and workspace, even when `--as-account` selects another execution account.
+Stage the Tool in its owner repository and dependent components in their own repository with
+the same workspace. Check the Tool's `componentSource` and `componentSignature` separately
+from the Action's returned provenance. This requires the platform correction tracked as 68570;
+older builds use the committed global Tool when it is outside the execution account's inheritance chain.
+
 1. **CLI staging cache (Redis, 240-min TTL).** Branch + user + account scoped overrides written by
    `remits-cli components stage`. These shadow the layers below **only during CLI/test-mode execution**
    (see "When staged overrides apply" below).

package/skills/remits-cli/references/local-ai.md

@@ -18,7 +18,8 @@ remits-cli ai serve --agent codex --base-url http://localhost:8080 --account-id
 ```
 
 Use `claude`, `gemini`, or `manual` instead of `codex`. Native executables must be installed and logged
-in. `--model` selects the native model; the workflow's `model` remains its configured provider target.
+in. Claude decisions are enforced with Claude Code's `--json-schema` structured output; an installed
+Claude Code that lacks it fails each request with an "upgrade Claude Code" error before any native turn. `--model` selects the native model; the workflow's `model` remains its configured provider target.
 `--max-concurrent 1..16` controls concurrent Remits sessions; default 1. `--worker-id` selects a named
 worker. `--role` declares a role when the user's agent permissions require one. Workstream permission
 is `ai`.
@@ -88,8 +89,11 @@ supervisor observes release and exits. No automatic migration to a different wor
 
 Missed WebSocket notifications recover through authenticated polling. Finished decisions are saved
 before submission, so an HTTP retry does not repeat inference. If the supervisor died during inference,
-the native outcome is uncertain: inspect the native session and use a new Remits session rather than
-deleting the journal and accidentally replaying a tool decision. Never run competing supervisors with
+or a native turn was killed mid-way, the native outcome is uncertain: inspect the native session and use
+a new Remits session rather than deleting the journal and accidentally replaying a tool decision. A native
+turn that finished with an invalid decision (for Claude, a reply that never used structured output) fails
+that request only; the session stays usable and the next request re-sends the full packet. A native CLI
+that failed before starting a turn leaves the session as it was. Never run competing supervisors with
 the same worker ID.
 
 Local state is under `~/.remits-cli/ai/<scope hash>/`: `worker.json`, `sessions/`, `requests/`, and isolated

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

@@ -529,7 +529,7 @@ turns up a run that is consuming resources and should not finish — the case th
 # the usual path: you found the event in mcp_record_listing / mcp_object_activity
 remits-cli tool --account-id 21 --as-account 49 --target-account 49 --name mcp_run_action --data-mode prod --input '{"controlAction":"interrupt","eventId":19102,"reason":"runaway extraction, 45min"}'
 
-# or stop a run you started yourself (executionMode:'event' only)
+# or stop an event-backed or managed async run you started yourself
 remits-cli tool --account-id 21 --as-account 49 --target-account 49 --name mcp_run_action --data-mode prod --input '{"controlAction":"interrupt","actionRunId":"my-run-id"}'
 ```
 
@@ -542,7 +542,7 @@ Aliases `cancel` / `stop` / `kill` all work. What you need to know before using
 - **Work already committed is NOT rolled back.** This stops further work; it does not undo what has run.
 - **Only `PENDING`/`QUEUED`/`PROCESSING` can be interrupted.** A terminal event is reported back with its
   status rather than being silently reported as "interrupted".
-- **Event-scoped.** A `direct` or `async` run has no Event and cannot be stopped this way.
+- **Async runs also support cooperative stop** once the updated platform and System Account Tool 132 are deployed. `interruptRequested:true` means the stop was recorded; poll until the worker reports a terminal status. Legacy async runs without `runControlId`, and direct runs, cannot be stopped through this handle. An explicit server shutdown settles managed async runs as failed with `terminationReason:owner_shutdown`; inspect partial effects before any rerun.
 - Tenant-scoped: you cannot interrupt another account's event.
 - The response returns `previousStatus`, `eventStatus`, and `threadGroupingId`, so you can pivot straight
   into `mcp_performance_trace` / `mcp_system_logs` to see what it was doing when you stopped it.