clisbot 0.1.53-beta.3 → 0.1.53-beta.4

package/dist/main.js

@@ -84887,7 +84887,7 @@ function renderLoopsHelp(channel) {
     "  - if runtime is stopped, recurring loops activate on the next `clisbot start`",
     "  - global `cancel --all` clears the whole app; scoped `cancel --all` clears one routed session",
     `  - \`cancel --all ${LOOP_APP_FLAG}\` is accepted only with a scoped session target, matching \`/loop cancel --all ${LOOP_APP_FLAG}\``,
-    "  - one-shot count loops run synchronously in the CLI; durable one-shot prompts use `clisbot queues`",
+    "  - one-shot count loops reserve all iterations immediately as durable queue items for the routed session",
     "  - wall-clock loop timezone resolves from `--timezone`, route/topic, agent, bot, app timezone, then legacy defaults, then host",
     "  - calendar loops freeze the resolved effective timezone at creation time; if timing looks wrong, run `clisbot timezone get` first and inspect agent or route timezone only for scoped overrides"
   ].join(`
@@ -84924,7 +84924,8 @@ function renderLoopsCreateHelp(channel) {
     "  - create without `--sender` fails by design",
     "  - the `--sender` platform must match `--channel`",
     "  - recurring CLI-created loops persist creator metadata into the session store",
-    "  - CLI-created loop prompts inherit the normal clisbot prompt config unless `--progress <count>` is provided"
+    "  - CLI-created loop prompts inherit the normal clisbot prompt config unless `--progress <count>` is provided",
+    "  - count/times loops reserve their iterations immediately as durable queue items and do not create recurring loop records"
   ].join(`
 `);
 }
@@ -85047,7 +85048,6 @@ async function getScopedLoopCounts(params) {
 }
 
 // src/control/commands/loops-cli.ts
-var LOOP_BUSY_RETRY_MS = 250;
 var LOOP_CONFIRM_FLAG = "--confirm";
 var LOOP_PROGRESS_FLAG = "--progress";
 var LOOP_SENDER_FLAG = "--sender";
@@ -85190,52 +85190,37 @@ async function cancelScopedLoops(state, args, addressing) {
   }
   await cancelOneScopedLoop(state, context, sessionLoops, targetLoopId);
 }
-async function waitForSessionIdle(agentService, target) {
-  while (true) {
-    try {
-      const runtime = await agentService.getSessionRuntime(target);
-      if (runtime.state !== "running") {
-        return;
-      }
-    } catch {
-      return;
-    }
-    await sleep(LOOP_BUSY_RETRY_MS);
-  }
+function createCountLoopQueueItem(params) {
+  return createStoredQueueItem({
+    promptText: params.promptText,
+    protectedControlMutationRule: resolveProtectedControlMutationRule(params.state, params.request.context.sessionTarget.agentId, params.request.creator),
+    promptSummary: summarizeLoopPrompt(params.request.resolvedPrompt.text, params.request.resolvedPrompt.maintenancePrompt),
+    createdBy: params.request.creator.providerId,
+    sender: params.request.creator,
+    surfaceBinding: buildStoredSurfaceBinding({
+      ...params.request.context.identity,
+      botId: params.request.context.botId
+    })
+  });
 }
-async function executeCountLoop(params) {
-  const agentService = new AgentService(params.state.loadedConfig);
-  const builtPrompt = params.context.buildLoopPromptText(params.promptText, params.progressMessages == null ? undefined : {
-    maxProgressMessagesOverride: params.progressMessages
+async function createCountLoopQueueItems(state, request, count) {
+  const context = request.deliveryContext ?? request.context;
+  const builtPrompt = context.buildLoopPromptText(request.resolvedPrompt.text, request.progressMessages == null ? undefined : {
+    maxProgressMessagesOverride: request.progressMessages
   });
+  for (let index = 0;index < count; index += 1) {
+    await state.sessionState.setQueuedItem(request.resolvedTarget, createCountLoopQueueItem({
+      request,
+      state,
+      promptText: builtPrompt
+    }));
+  }
   console.log(renderLoopStartedMessage({
     mode: "times",
-    count: params.count,
-    maintenancePrompt: params.maintenancePrompt
+    count,
+    maintenancePrompt: request.resolvedPrompt.maintenancePrompt
   }));
-  try {
-    for (let index = 0;index < params.count; index += 1) {
-      while (true) {
-        await waitForSessionIdle(agentService, params.context.sessionTarget);
-        try {
-          await agentService.enqueuePrompt(params.context.sessionTarget, builtPrompt, {
-            onUpdate: () => {
-              return;
-            }
-          }).result;
-          break;
-        } catch (error) {
-          if (!(error instanceof ActiveRunInProgressError)) {
-            throw error;
-          }
-          await sleep(LOOP_BUSY_RETRY_MS);
-        }
-      }
-    }
-  } finally {
-    await agentService.stop();
-  }
-  console.log(`Completed ${params.count} iteration${params.count === 1 ? "" : "s"}.`);
+  console.log(`Queued ${count} iteration${count === 1 ? "" : "s"} for \`${context.sessionTarget.sessionKey}\`.`);
 }
 function stripConfirmFlag(args) {
   return args.filter((arg) => arg !== LOOP_CONFIRM_FLAG);
@@ -85444,9 +85429,10 @@ function buildRecurringLoopCreateBase(state, request) {
     runtimeRunning: runtimeStatus.running
   }));
 }
-function buildRecurringLoopPromptMetadata(request) {
+function buildRecurringLoopPromptMetadata(state, request) {
   return {
     promptText: request.resolvedPrompt.text,
+    protectedControlMutationRule: resolveProtectedControlMutationRule(state, request.context.sessionTarget.agentId, request.creator),
     promptSummary: summarizeLoopPrompt(request.resolvedPrompt.text, request.resolvedPrompt.maintenancePrompt),
     promptSource: request.resolvedPrompt.maintenancePrompt ? "LOOP.md" : "custom",
     progressMessages: request.progressMessages,
@@ -85457,6 +85443,14 @@ function buildRecurringLoopPromptMetadata(request) {
     surfaceBinding: buildLoopSurfaceBinding2(request)
   };
 }
+function resolveProtectedControlMutationRule(state, agentId, sender) {
+  const auth = resolvePrincipalAuth({
+    config: state.loadedConfig.raw,
+    agentId,
+    principal: sender.senderId
+  });
+  return auth.mayManageProtectedResources ? undefined : DEFAULT_PROTECTED_CONTROL_RULE;
+}
 function buildRecurringLoopFirstRunNote(mode, runtimeRunning) {
   if (!runtimeRunning) {
     return "Runtime is not running, so this loop activates on the next `clisbot start`.";
@@ -85471,7 +85465,7 @@ async function createCalendarLoop(base) {
   if (parsed.mode !== "calendar") {
     return false;
   }
-  const metadata = buildRecurringLoopPromptMetadata(base.request);
+  const metadata = buildRecurringLoopPromptMetadata(base.state, base.request);
   const timezone = resolveConfigTimezone({
     config: base.state.loadedConfig.raw,
     agentId: base.request.context.sessionTarget.agentId,
@@ -85549,7 +85543,7 @@ async function createIntervalLoop(base) {
     return;
   }
   const validation = requireValidIntervalLoop(parsed);
-  const metadata = buildRecurringLoopPromptMetadata(base.request);
+  const metadata = buildRecurringLoopPromptMetadata(base.state, base.request);
   const loop = createStoredIntervalLoop({
     ...metadata,
     intervalMs: parsed.intervalMs,
@@ -85585,14 +85579,7 @@ async function createRecurringLoop(state, request) {
 async function createLoop(state, rawArgs, options = {}) {
   const request = await resolveLoopCreateRequest(state, rawArgs, options.explicitCreateSubcommand ?? false);
   if (request.parsed.mode === "times") {
-    await executeCountLoop({
-      state,
-      context: request.deliveryContext ?? request.context,
-      promptText: request.resolvedPrompt.text,
-      count: request.parsed.count,
-      maintenancePrompt: request.resolvedPrompt.maintenancePrompt,
-      progressMessages: request.progressMessages
-    });
+    await createCountLoopQueueItems(state, request, request.parsed.count);
     return;
   }
   if (request.parsed.mode === "calendar" && !request.confirm && !await hasSuccessfulCalendarLoop(state)) {
@@ -86182,7 +86169,7 @@ function buildQueueSurfaceBinding(context) {
     botId: context.botId
   });
 }
-function resolveProtectedControlMutationRule(state, agentId, sender) {
+function resolveProtectedControlMutationRule2(state, agentId, sender) {
   const auth = resolvePrincipalAuth({
     config: state.loadedConfig.raw,
     agentId,
@@ -86193,7 +86180,7 @@ function resolveProtectedControlMutationRule(state, agentId, sender) {
 function createQueueItemForContext(params) {
   return createStoredQueueItem({
     promptText: params.promptText,
-    protectedControlMutationRule: resolveProtectedControlMutationRule(params.state, params.context.sessionTarget.agentId, params.sender),
+    protectedControlMutationRule: resolveProtectedControlMutationRule2(params.state, params.context.sessionTarget.agentId, params.sender),
     promptSummary: params.promptText,
     createdBy: params.sender.providerId,
     sender: params.sender,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clisbot",
-  "version": "0.1.53-beta.3",
+  "version": "0.1.53-beta.4",
   "private": false,
   "description": "Chat surfaces for durable AI coding agents running in tmux",
   "license": "MIT",