@commonlyai/cli 0.1.32 → 0.1.35

package/README.md

@@ -24,4 +24,6 @@ Requires Node 20+. No build step.
 node --experimental-vm-modules node_modules/.bin/jest --no-coverage
 ```
 
-70 tests as of 2026-04-15.
+Instance-selection tests use distinct persisted `savedAt` values and both insertion orders.
+Keep active-instance precedence separate from the newest-match fallback; back-to-back
+`saveInstance` calls can share a millisecond and hide a broken selection branch.

package/package.json

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

package/src/commands/agent.js

@@ -50,6 +50,7 @@ import {
   createClaimHandicap,
   createClaimKeeper,
   deliverChatReply,
+  frameDecisionForkRule,
   peerHoldsFrame,
   resolveCascadeSettings,
 } from '../lib/enforcement.js';
@@ -694,6 +695,18 @@ const extractPrompt = (event) => {
       'Only post a concise pod update if a human needs it; otherwise return NO_REPLY.',
     ].join('\n');
   }
+  if (event.type === 'decision.ruled') {
+    if (!p.decisionId || !p.pick || !p.ruledAt) return null;
+    const ruler = p.ruledBy?.username || 'A human';
+    return [
+      '[Decision ruled]',
+      `${ruler} chose: ${String(p.pick)}`,
+      `Decision: ${String(p.decisionId)}`,
+      `Ruled at: ${String(p.ruledAt)}`,
+      '',
+      'Continue with this ruling. Post a concise update only if it materially helps the pod; otherwise return NO_REPLY.',
+    ].join('\n');
+  }
   return null;
 };
 
@@ -1050,7 +1063,7 @@ export const performRun = ({
     const memoryLongTerm = await readLongTerm(client, { onError });
 
     log(`[${event.type}] spawning ${adapter.name}`);
-    const result = await adapter.spawn(prompt, {
+    const result = await adapter.spawn(frameDecisionForkRule(prompt), {
       sessionId,
       cwd: agentCwd,
       env: process.env,

package/src/lib/daemon-supervisor.js

@@ -87,12 +87,33 @@ export const createDaemonSupervisor = ({
     }
   };
 
+  // The server-declared runtime config carries the owner's model choice; the
+  // adapter reads it from the token record's environment (claude: --model).
+  const environmentFor = (row) => (
+    row.runtime?.model ? { model: String(row.runtime.model) } : null
+  );
+
   // Ensure ~/.commonly/tokens/<name>.json exists so `agent run` can boot.
   // The mint refuses to clobber an existing token (409 token_exists); the
   // binding to THIS machine is the owner's explicit takeover choice (D3), so
   // that refusal is answered with rotate:true — loudly.
+  // Returns 'ready' | 'changed' (record updated — the seat must restart to
+  // load it) | false.
   const ensureToken = async (row) => {
-    if (loadToken(row.agentName)) return true;
+    const existing = loadToken(row.agentName);
+    if (existing) {
+      // A model changed in the UI reaches the seat here: update the record,
+      // and let the caller restart the child (`agent run` reads its record
+      // once at boot). A row with NO declared model leaves the record alone —
+      // never strip an operator's hand-set environment.
+      const wanted = environmentFor(row);
+      if (wanted && existing.environment?.model !== wanted.model) {
+        saveToken(row.agentName, { ...existing, environment: { ...(existing.environment || {}), ...wanted } });
+        log(`[${row.agentName}] model changed to ${wanted.model} — restarting the seat to load it`);
+        return 'changed';
+      }
+      return 'ready';
+    }
     const body = { agentName: row.agentName, instanceId: row.instanceId };
     let minted;
     try {
@@ -120,6 +141,7 @@ export const createDaemonSupervisor = ({
       log(`[${row.agentName}] no usable CLI adapter on this machine — install claude or codex, or attach manually`);
       return false;
     }
+    const environment = environmentFor(row);
     saveToken(row.agentName, {
       agentName: row.agentName,
       instanceId: row.instanceId,
@@ -127,9 +149,10 @@ export const createDaemonSupervisor = ({
       instanceUrl: record.instanceUrl,
       podId: row.podIds?.[0] || null,
       adapter,
+      ...(environment ? { environment } : {}),
     });
-    log(`[${row.agentName}] provisioned runtime token (adapter: ${adapter})`);
-    return true;
+    log(`[${row.agentName}] provisioned runtime token (adapter: ${adapter}${environment ? `, model: ${environment.model}` : ''})`);
+    return 'ready';
   };
 
   const tick = async () => {
@@ -180,9 +203,14 @@ export const createDaemonSupervisor = ({
         seats.set(key, seat);
       }
       seat.desired = true;
-      if (!seat.child && !seat.backoffTimer) {
-        // eslint-disable-next-line no-await-in-loop
-        if (await ensureToken(row)) startChild(seat);
+      // eslint-disable-next-line no-await-in-loop
+      const ready = await ensureToken(row);
+      if (ready === 'changed' && seat.child) {
+        // desired stays true, so the exit handler respawns with the updated
+        // record — the restart path IS the D6 path, no second spawner.
+        seat.child.kill('SIGTERM');
+      } else if (ready && !seat.child && !seat.backoffTimer) {
+        startChild(seat);
       }
     }
 

package/src/lib/enforcement.js

@@ -28,6 +28,20 @@ export const CLAIMABLE_EVENT_TYPES = new Set([
   'dm.message',
 ]);
 
+// A decision card is the durable path for a real human choice. This lives in
+// wrapper enforcement, rather than only in the MCP tool description, because
+// a task-shaped prompt can otherwise make an agent phrase the same fork as a
+// prose @ask. The rule is framing, not a classifier: the agent still judges
+// whether the work genuinely cannot continue without a human ruling.
+export const DECISION_FORK_FRAME = [
+  '[Decision forks]',
+  'If you are blocked on a genuine fork that needs a human choice, call commonly_request_decision; do not post a prose @ask.',
+  'Use it only when you cannot safely continue before a ruling. Give 2–4 concrete options and mark one recommendation.',
+  'Use ordinary pod messages for status, factual questions, and coordination that do not require a human choice.',
+].join('\n');
+
+export const frameDecisionForkRule = (prompt) => `${DECISION_FORK_FRAME}\n\n${prompt}`;
+
 // ── trigger classification ──────────────────────────────────────────────────
 
 /**