@commonlyai/cli 0.1.86 → 0.1.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.86",
+  "version": "0.1.88",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

package/src/commands/agent.js

@@ -127,6 +127,30 @@ export const deleteAgentToken = (name) => {
 // falls back to the attach hint).
 export const BOOTSTRAP_ADAPTER_DETECT_ORDER = ['claude', 'codex', 'pi'];
 
+// ── `agent run --adapter` against an existing token file (#2098) ────────────
+// The flag picks the CLI once, at first-run bootstrap; after that the token
+// file's adapter is what runs. A different `--adapter` used to be dropped
+// without a word, so "switch this agent to Codex" kept running Claude and read
+// as Codex misbehaving. Refuse instead, and name the way out for each path:
+// a foreground run re-bootstraps from the Connect page's env exports after the
+// local record is removed; a daemon-managed seat is switched through the
+// registry, which the daemon applies on its next pass.
+export const checkRunAdapterRequest = ({ record, requestedAdapter, tokenPath }) => {
+  const requested = String(requestedAdapter || '').trim().toLowerCase();
+  if (!requested) return { ok: true };
+  const bound = String(record?.adapter || '').trim().toLowerCase();
+  if (!bound || bound === requested) return { ok: true };
+  const name = record.agentName;
+  return {
+    ok: false,
+    message: [
+      `'${name}' is bound to the ${bound} adapter by its token file (${tokenPath}); --adapter ${requested} was not applied.`,
+      `To run it with ${requested} here: commonly agent detach ${name} --force, then re-run with the Connect-page env exports and --adapter ${requested}.`,
+      `A daemon-managed seat switches with: commonly agent config ${name} --adapter ${requested}`,
+    ].join('\n'),
+  };
+};
+
 export const bootstrapAgentRecordFromEnv = async ({
   name,
   env = process.env,
@@ -2690,7 +2714,7 @@ Docs:
     .command('run <name>')
     .description('Run the local-CLI wrapper loop for an attached agent')
     .option('--interval <ms>', 'Poll interval in ms', '5000')
-    .option('--adapter <name>', 'CLI to wrap on first-run bootstrap (claude|codex); ignored when a token file already exists')
+    .option('--adapter <name>', 'CLI to wrap on first-run bootstrap (claude|codex); an existing token file bound to a different adapter stops the run')
     .option('--cascade-cap <n>', `Consecutive agent-triggered turns allowed per pod (env ${CASCADE_ENV_VARS.cap}, default ${CASCADE_DEFAULTS.cap})`)
     .option('--cascade-grace <n>', `Extra turns allowed when this seat was directly addressed; 0 disables the grace (env ${CASCADE_ENV_VARS.addressedGrace}, default ${CASCADE_DEFAULTS.addressedGrace})`)
     .option('--cascade-reset <ms>', `Silence window that clears the streak (env ${CASCADE_ENV_VARS.resetMs}, default ${CASCADE_DEFAULTS.resetMs})`)
@@ -2722,6 +2746,14 @@ Docs:
         }
       }
 
+      const adapterRequest = checkRunAdapterRequest({
+        record, requestedAdapter: opts.adapter, tokenPath: tokenFile(name),
+      });
+      if (!adapterRequest.ok) {
+        console.error(`${stamp()} [${name}] ${adapterRequest.message}`);
+        process.exit(1);
+      }
+
       const adapter = getAdapter(record.adapter);
       if (!adapter) {
         console.error(`Unknown adapter '${record.adapter}' in token file. Known: ${listAdapterNames().join(', ')}`);

package/src/lib/enforcement.js

@@ -483,12 +483,53 @@ export const createClaimKeeper = (client, {
 
 // ── post-time length gate ───────────────────────────────────────────────────
 
+// A sentence ends at [.!?] followed by whitespace, except when what precedes
+// the whitespace is only a numbered list marker at the start of the line: in
+// "3. Run it once." the first period belongs to the marker, not a sentence.
+// Applied to one line at a time, so `^` is the line start.
+const SENTENCE_END = /(?<=[.!?])(?<!^[ \t]*\d{1,3}\.)\s+/;
+
+// Split one over-limit line at sentence boundaries, and a sentence that is
+// itself over the limit at word boundaries. A single over-limit word (a URL)
+// posts whole rather than being cut.
+const splitLineForChat = (line, limit) => {
+  const units = [];
+  let piece = '';
+  const flushPiece = () => {
+    if (piece.trim()) units.push(piece.trim());
+    piece = '';
+  };
+  for (const sentence of line.split(SENTENCE_END)) {
+    if (sentence.length > limit) {
+      flushPiece();
+      let run = '';
+      for (const word of sentence.split(/\s+/)) {
+        if (run && `${run} ${word}`.length > limit) {
+          units.push(run);
+          run = word;
+        } else {
+          run = run ? `${run} ${word}` : word;
+        }
+      }
+      if (run) units.push(run);
+    } else if (piece && `${piece} ${sentence}`.length > limit) {
+      flushPiece();
+      piece = sentence;
+    } else {
+      piece = piece ? `${piece} ${sentence}` : sentence;
+    }
+  }
+  flushPiece();
+  return units;
+};
+
 /**
  * Split chat text into tone-contract-sized messages without ever cutting
  * content. Boundaries in preference order: fenced code blocks stay whole
  * (atomic — an oversized fence becomes one oversized message rather than a
- * broken pair), then paragraphs, then sentences, then words. Greedy packing
- * rejoins small pieces so two short paragraphs share one message.
+ * broken pair), then paragraphs, then lines (a list item never leaves its
+ * marker), then sentences, then words. Greedy packing rejoins small pieces so
+ * two short paragraphs share one message.
  */
 export const splitForChat = (text, { limit = 400 } = {}) => {
   const trimmed = String(text || '').trim();
@@ -529,39 +570,39 @@ export const splitForChat = (text, { limit = 400 } = {}) => {
   }
   flushProse();
 
-  // Pass 2: split oversized prose blocks at sentence then word boundaries.
+  // Pass 2: split oversized prose blocks at line, then sentence, then word
+  // boundaries. Lines come first because a list is one paragraph block whose
+  // items are separated by single newlines: splitting it by sentence read a
+  // numbered marker ("3.") as a sentence end and packed it onto the previous
+  // piece, so a support reply posted one message ending in "3." and the next
+  // opening with step 3's body (hq-support, 2026-10-09). Lines pack greedily
+  // with single newlines, so a list stays a list inside a message; only a line
+  // that is itself over the limit goes on to sentences and words.
   const units = [];
   for (const block of blocks) {
     if (block.atomic || block.text.length <= limit) {
       units.push(block.text);
       continue;
     }
-    let piece = '';
-    const flushPiece = () => {
-      if (piece.trim()) units.push(piece.trim());
-      piece = '';
+    let group = '';
+    const flushGroup = () => {
+      if (group) units.push(group);
+      group = '';
     };
-    for (const sentence of block.text.split(/(?<=[.!?])\s+/)) {
-      if (sentence.length > limit) {
-        flushPiece();
-        let run = '';
-        for (const word of sentence.split(/\s+/)) {
-          if (run && `${run} ${word}`.length > limit) {
-            units.push(run);
-            run = word;
-          } else {
-            run = run ? `${run} ${word}` : word;
-          }
-        }
-        if (run) units.push(run); // a single over-limit word (URL) posts whole
-      } else if (piece && `${piece} ${sentence}`.length > limit) {
-        flushPiece();
-        piece = sentence;
+    for (const rawLine of block.text.split('\n')) {
+      const line = rawLine.trimEnd(); // keep a nested item's indentation
+      if (!line.trim()) continue;
+      if (line.length > limit) {
+        flushGroup();
+        units.push(...splitLineForChat(line, limit));
+      } else if (group && `${group}\n${line}`.length > limit) {
+        flushGroup();
+        group = line;
       } else {
-        piece = piece ? `${piece} ${sentence}` : sentence;
+        group = group ? `${group}\n${line}` : line;
       }
     }
-    flushPiece();
+    flushGroup();
   }
 
   // Pass 3: greedy packing back up to the limit.