clisbot 0.1.22 → 0.1.26

package/README.md

@@ -111,6 +111,8 @@ bun install
 bun run start --cli codex --bot-type personal --telegram-bot-token <your-telegram-bot-token> --persist
 ```
 
+Repo-local `bun run start|stop|restart|status|logs|init|pairing` is pinned by `.env` to `CLISBOT_HOME=~/.clisbot-dev`, so local testing does not accidentally reuse your main `~/.clisbot` runtime.
+
 First conversation path:
 
 - send a DM to the bot in Slack or Telegram

package/config/clisbot.json.template

@@ -8,7 +8,7 @@
   },
   "session": {
     "mainKey": "main",
-    "dmScope": "main",
+    "dmScope": "per-channel-peer",
     "identityLinks": {},
     "storePath": "~/.clisbot/state/sessions.json"
   },
@@ -154,11 +154,15 @@
       "maxActiveLoops": 10,
       "defaultTimezone": "UTC"
     },
-    "runtimeMonitor": {
-      "restartBackoff": {
-        "stages": [
-          {
-            "delayMinutes": 15,
+      "runtimeMonitor": {
+        "restartBackoff": {
+          "fastRetry": {
+            "delaySeconds": 10,
+            "maxRestarts": 3
+          },
+          "stages": [
+            {
+              "delayMinutes": 15,
             "maxRestarts": 4
           },
           {
@@ -290,4 +294,4 @@
       }
     }
   }
-}
+}

package/dist/main.js

@@ -59932,7 +59932,7 @@ var sessionDmScopeSchema = exports_external.enum([
 ]);
 var sessionConfigSchema = exports_external.object({
   mainKey: exports_external.string().min(1).default("main"),
-  dmScope: sessionDmScopeSchema.default("main"),
+  dmScope: sessionDmScopeSchema.default("per-channel-peer"),
   identityLinks: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).default({}),
   storePath: exports_external.string().default("~/.clisbot/state/sessions.json")
 });
@@ -60250,7 +60250,15 @@ var controlRuntimeMonitorRestartStageSchema = exports_external.object({
   delayMinutes: exports_external.number().int().positive().default(15),
   maxRestarts: exports_external.number().int().positive().default(4)
 });
+var controlRuntimeMonitorFastRetrySchema = exports_external.object({
+  delaySeconds: exports_external.number().int().positive().default(10),
+  maxRestarts: exports_external.number().int().min(0).default(3)
+});
 var controlRuntimeMonitorRestartBackoffSchema = exports_external.object({
+  fastRetry: controlRuntimeMonitorFastRetrySchema.default({
+    delaySeconds: 10,
+    maxRestarts: 3
+  }),
   stages: exports_external.array(controlRuntimeMonitorRestartStageSchema).min(1).default([
     {
       delayMinutes: 15,
@@ -60268,6 +60276,10 @@ var controlRuntimeMonitorOwnerAlertsSchema = exports_external.object({
 });
 var controlRuntimeMonitorSchema = exports_external.object({
   restartBackoff: controlRuntimeMonitorRestartBackoffSchema.default({
+    fastRetry: {
+      delaySeconds: 10,
+      maxRestarts: 3
+    },
     stages: [
       {
         delayMinutes: 15,
@@ -60328,7 +60340,7 @@ var clisbotConfigSchema = exports_external.object({
   }),
   session: sessionConfigSchema.default({
     mainKey: "main",
-    dmScope: "main",
+    dmScope: "per-channel-peer",
     identityLinks: {},
     storePath: "~/.clisbot/state/sessions.json"
   }),
@@ -60367,6 +60379,10 @@ var clisbotConfigSchema = exports_external.object({
     },
     runtimeMonitor: {
       restartBackoff: {
+        fastRetry: {
+          delaySeconds: 10,
+          maxRestarts: 3
+        },
         stages: [
           {
             delayMinutes: 15,
@@ -60581,7 +60597,7 @@ function renderDefaultConfigTemplate(options = {}) {
     },
     session: {
       mainKey: "main",
-      dmScope: "main",
+      dmScope: "per-channel-peer",
       identityLinks: {},
       storePath: sessionStorePath
     },
@@ -60691,6 +60707,10 @@ function renderDefaultConfigTemplate(options = {}) {
       },
       runtimeMonitor: {
         restartBackoff: {
+          fastRetry: {
+            delaySeconds: 10,
+            maxRestarts: 3
+          },
           stages: [
             {
               delayMinutes: 15,
@@ -61731,8 +61751,8 @@ class RuntimeHealthStore {
 
 // src/control/runtime-process.ts
 import { execFileSync, spawn as spawn3 } from "node:child_process";
-import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { dirname as dirname13, join as join11 } from "node:path";
 import { kill as kill2 } from "node:process";
 
 // src/control/clisbot-wrapper.ts
@@ -62719,43 +62739,151 @@ function hasActiveRuntime(entry) {
 }
 
 // src/channels/agent-prompt.ts
-function buildAgentPromptText(params) {
-  if (!params.config.enabled) {
-    return params.text;
-  }
-  const systemBlock = renderAgentPromptInstruction(params);
-  return `<system>
-${systemBlock}
+var CONFIGURATION_GUIDANCE = "When the user asks to change clisbot configuration, use clisbot CLI commands; see `clisbot --help`, `clisbot channels --help`, or `clisbot auth --help` for details.";
+var BASE_TEMPLATE = `<system>
+[{{timestamp}}] {{identity_summary}}
+
+You are operating inside clisbot.
+{{delivery_intro}}
+{{reply_command}}
+{{reply_rules}}
+${CONFIGURATION_GUIDANCE}{{protected_control_suffix}}
+</system>
+
+<user>
+{{message_body}}
+</user>`;
+var STEERING_TEMPLATE = `<system>
+A new user message arrived while you were still working.
+Adjust your current work if needed and continue.{{protected_control_suffix}}
 </system>
 
 <user>
-${params.text}
+{{message_body}}
 </user>`;
+var DELIVERY_INTRO = "To send a user-visible {{progress_phrase}}final reply, use the following CLI command:";
+var DELIVERY_INTRO_CAPTURE_PANE = "channel auto-delivery remains enabled for this conversation; do not send user-facing progress updates or the final response with clisbot message send";
+var REPLY_COMMAND = `{{reply_command_base}}
+  --final{{progress_flag_suffix}} \\
+  --message "$(cat <<\\__CLISBOT_MESSAGE__
+<user-facing reply>
+__CLISBOT_MESSAGE__
+)" \\
+  [--media /absolute/path/to/file]`;
+var REPLY_RULES = `When replying to the user:
+- put the user-facing message inside the --message body of that command
+{{progress_rules_block}}- {{final_rule_line}}`;
+var PROGRESS_PHRASE = "progress update or ";
+var EMPTY_PROGRESS_PHRASE = "";
+var PROGRESS_FLAG_SUFFIX = "|progress";
+var EMPTY_PROGRESS_FLAG_SUFFIX = "";
+var PROGRESS_RULES_BLOCK = `- use that command to send progress updates and the final reply back to the conversation
+- send at most {{max_progress_messages}} progress updates
+- keep progress updates short and meaningful
+- do not send progress updates for trivial internal steps
+`;
+var FINAL_ONLY_RULES_BLOCK = `- use that command only for the final user-facing reply
+- do not send user-facing progress updates for this conversation
+`;
+var FINAL_RULE_REQUIRED = "send exactly 1 final user-facing response";
+var FINAL_RULE_OPTIONAL = "final response is optional";
+var EMPTY_REPLY_COMMAND = "";
+var EMPTY_REPLY_RULES = "";
+var SLACK_REPLY_COMMAND_BASE = `{{command}} message send \\
+  --channel slack \\
+{{account_clause}}  --target channel:{{channel_id}} \\
+{{thread_clause}}`;
+var TELEGRAM_REPLY_COMMAND_BASE = `{{command}} message send \\
+  --channel telegram \\
+{{account_clause}}  --target {{chat_id}} \\
+{{thread_clause}}`;
+var ACCOUNT_CLAUSE = "  --account {{account_id}} \\\n";
+var EMPTY_ACCOUNT_CLAUSE = "";
+var SLACK_THREAD_CLAUSE = "  --thread-id {{thread_ts}} \\\n";
+var TELEGRAM_THREAD_CLAUSE = "  --thread-id {{topic_id}} \\\n";
+var EMPTY_THREAD_CLAUSE = "";
+function buildAgentPromptText(params) {
+  return buildChannelPromptText({
+    ...params,
+    mode: "message"
+  });
 }
-function renderAgentPromptInstruction(params) {
-  const messageToolMode = (params.responseMode ?? "message-tool") === "message-tool";
-  const progressAllowed = messageToolMode && (params.streaming ?? "off") === "off";
-  const lines = [
-    `[${renderPromptTimestamp()}] ${renderIdentitySummary(params.identity)}`,
-    "",
-    "You are operating inside clisbot.",
-    messageToolMode ? progressAllowed ? "To send a user-visible progress update or final reply, use the following CLI command:" : "To send the final user-visible reply, use the following CLI command:" : "channel auto-delivery remains enabled for this conversation; do not send user-facing progress updates or the final response with clisbot message send"
-  ];
-  if (messageToolMode) {
-    const replyCommand = buildReplyCommand({
-      command: getClisbotPromptCommand(),
-      identity: params.identity
+function buildSteeringPromptText(params) {
+  return buildChannelPromptText({
+    text: params.text,
+    mode: "steer",
+    protectedControlMutationRule: params.protectedControlMutationRule
+  });
+}
+function buildChannelPromptText(params) {
+  if (params.mode === "message" && !params.config?.enabled) {
+    return params.text;
+  }
+  if (params.mode === "steer") {
+    return renderTemplate(STEERING_TEMPLATE, {
+      message_body: params.text,
+      protected_control_suffix: renderProtectedControlSuffix(params.protectedControlMutationRule)
     });
-    lines.push(replyCommand, "When replying to the user:", "- put the user-facing message inside the --message body of that command", progressAllowed ? "- use that command to send progress updates and the final reply back to the conversation" : "- use that command only for the final user-facing reply", ...progressAllowed ? [`- send at most ${params.config.maxProgressMessages} progress updates`] : ["- do not send user-facing progress updates for this conversation"], params.config.requireFinalResponse ? "- send exactly 1 final user-facing response" : "- final response is optional", ...progressAllowed ? [
-      "- keep progress updates short and meaningful",
-      "- do not send progress updates for trivial internal steps"
-    ] : []);
   }
-  if (params.protectedControlMutationRule) {
-    lines.push("", params.protectedControlMutationRule);
+  const promptParts = renderMessagePromptParts({
+    identity: params.identity,
+    config: params.config,
+    responseMode: params.responseMode,
+    streaming: params.streaming
+  });
+  return renderTemplate(BASE_TEMPLATE, {
+    timestamp: renderPromptTimestamp(),
+    identity_summary: renderIdentitySummary(params.identity),
+    delivery_intro: promptParts.deliveryIntro,
+    reply_command: promptParts.replyCommand,
+    reply_rules: promptParts.replyRules,
+    protected_control_suffix: renderProtectedControlSuffix(params.protectedControlMutationRule),
+    message_body: params.text
+  });
+}
+function renderMessagePromptParts(params) {
+  const messageToolMode = (params.responseMode ?? "message-tool") === "message-tool";
+  if (!messageToolMode) {
+    return {
+      deliveryIntro: DELIVERY_INTRO_CAPTURE_PANE,
+      replyCommand: EMPTY_REPLY_COMMAND,
+      replyRules: EMPTY_REPLY_RULES
+    };
   }
-  return lines.join(`
-`);
+  const allowProgress = (params.streaming ?? "off") === "off";
+  const progressPhrase = allowProgress ? PROGRESS_PHRASE : EMPTY_PROGRESS_PHRASE;
+  const progressFlagSuffix = allowProgress ? PROGRESS_FLAG_SUFFIX : EMPTY_PROGRESS_FLAG_SUFFIX;
+  const progressRulesBlock = allowProgress ? PROGRESS_RULES_BLOCK : FINAL_ONLY_RULES_BLOCK;
+  const finalRuleLine = params.config.requireFinalResponse ? FINAL_RULE_REQUIRED : FINAL_RULE_OPTIONAL;
+  return {
+    deliveryIntro: renderTemplate(DELIVERY_INTRO, {
+      progress_phrase: progressPhrase
+    }),
+    replyCommand: renderTemplate(REPLY_COMMAND, {
+      reply_command_base: buildReplyCommandBase({
+        command: getClisbotPromptCommand(),
+        identity: params.identity
+      }).trimEnd(),
+      progress_flag_suffix: progressFlagSuffix
+    }),
+    replyRules: renderTemplate(REPLY_RULES, {
+      progress_rules_block: renderTemplate(progressRulesBlock, {
+        max_progress_messages: String(params.config.maxProgressMessages)
+      }),
+      final_rule_line: finalRuleLine
+    })
+  };
+}
+function renderProtectedControlSuffix(rule) {
+  if (!rule) {
+    return "";
+  }
+  return `
+
+${rule}`;
+}
+function renderTemplate(template, values) {
+  return template.replaceAll(/\{\{([a-zA-Z0-9_]+)\}\}/g, (_, key) => values[key] ?? "");
 }
 function renderPromptTimestamp() {
   const date = new Date;
@@ -62821,42 +62949,29 @@ function renderNamedValue(label, name, id) {
   const value = renderLabeledTarget(name, id);
   return value ? `${label} ${value}` : "";
 }
-function buildReplyCommand(params) {
-  const lines = [`${params.command} message send \\`];
+function buildReplyCommandBase(params) {
   if (params.identity.platform === "slack") {
-    lines.push("  --channel slack \\");
-    if (params.identity.accountId) {
-      lines.push(`  --account ${params.identity.accountId} \\`);
-    }
-    lines.push(`  --target channel:${params.identity.channelId ?? ""} \\`);
-    if (params.identity.threadTs) {
-      lines.push(`  --thread-id ${params.identity.threadTs} \\`);
-    }
-    lines.push("  --final \\");
-    lines.push('  --message "$(cat <<\\__CLISBOT_MESSAGE__');
-    lines.push("<user-facing reply>");
-    lines.push("__CLISBOT_MESSAGE__");
-    lines.push(')" \\');
-    lines.push("  [--media /absolute/path/to/file]");
-    return lines.join(`
-`);
-  }
-  lines.push("  --channel telegram \\");
-  if (params.identity.accountId) {
-    lines.push(`  --account ${params.identity.accountId} \\`);
+    return renderTemplate(SLACK_REPLY_COMMAND_BASE, {
+      command: params.command,
+      account_clause: params.identity.accountId ? renderTemplate(ACCOUNT_CLAUSE, {
+        account_id: params.identity.accountId
+      }) : EMPTY_ACCOUNT_CLAUSE,
+      channel_id: params.identity.channelId ?? "",
+      thread_clause: params.identity.threadTs ? renderTemplate(SLACK_THREAD_CLAUSE, {
+        thread_ts: params.identity.threadTs
+      }) : EMPTY_THREAD_CLAUSE
+    });
   }
-  lines.push(`  --target ${params.identity.chatId ?? ""} \\`);
-  if (params.identity.topicId) {
-    lines.push(`  --thread-id ${params.identity.topicId} \\`);
-  }
-  lines.push("  --final \\");
-  lines.push('  --message "$(cat <<\\__CLISBOT_MESSAGE__');
-  lines.push("<user-facing reply>");
-  lines.push("__CLISBOT_MESSAGE__");
-  lines.push(')" \\');
-  lines.push("  [--media /absolute/path/to/file]");
-  return lines.join(`
-`);
+  return renderTemplate(TELEGRAM_REPLY_COMMAND_BASE, {
+    command: params.command,
+    account_clause: params.identity.accountId ? renderTemplate(ACCOUNT_CLAUSE, {
+      account_id: params.identity.accountId
+    }) : EMPTY_ACCOUNT_CLAUSE,
+    chat_id: params.identity.chatId ?? "",
+    thread_clause: params.identity.topicId ? renderTemplate(TELEGRAM_THREAD_CLAUSE, {
+      topic_id: params.identity.topicId
+    }) : EMPTY_THREAD_CLAUSE
+  });
 }
 
 // src/channels/surface-notifications.ts
@@ -63940,6 +64055,36 @@ function renderInteractionBody(params) {
   }
   return truncateTail(completedBody, params.maxChars);
 }
+function normalizeLeadingStatusLine(line) {
+  return line.trim().replace(/^[_*`\s]+|[_*`\s]+$/g, "");
+}
+function startsWithExplicitErrorLabel(body) {
+  const firstLine = body.split(`
+`).map((line) => normalizeLeadingStatusLine(line)).find((line) => line.length > 0);
+  if (!firstLine) {
+    return false;
+  }
+  return /^(error|failed|failure|denied|forbidden)(?::|\.)/i.test(firstLine);
+}
+function shouldInlineErrorPrefix(body) {
+  return !body.includes(`
+`) && !body.includes("```");
+}
+function renderErrorInteractionBody(body, footer) {
+  const trimmedBody = body.trim();
+  if (!trimmedBody) {
+    return footer;
+  }
+  if (startsWithExplicitErrorLabel(trimmedBody)) {
+    return trimmedBody;
+  }
+  if (shouldInlineErrorPrefix(trimmedBody)) {
+    return `Error: ${trimmedBody}`;
+  }
+  return `${trimmedBody}
+
+${footer}`;
+}
 function renderSlackInteraction(params) {
   const body = renderInteractionBody(params);
   if (params.status === "queued") {
@@ -63967,9 +64112,7 @@ _Timed out waiting for more output._` : "_Timed out waiting for visible output._
 _${note}_` : `_${note}_`;
   }
   if (params.status === "error") {
-    return body ? `${body}
-
-_Error._` : "_Error._";
+    return renderErrorInteractionBody(body, "_Error._");
   }
   return body || "_Completed with no new visible output._";
 }
@@ -64000,9 +64143,7 @@ Timed out waiting for more output.` : "Timed out waiting for visible output.";
 ${note}` : note;
   }
   if (params.status === "error") {
-    return body ? `${body}
-
-Error.` : "Error.";
+    return renderErrorInteractionBody(body, "Error.");
   }
   return body || "Completed with no new visible output.";
 }
@@ -64936,15 +65077,19 @@ class RunnerService {
 }
 
 // src/agents/run-recovery.ts
+var MID_RUN_RECOVERY_MAX_ATTEMPTS = 2;
+var MID_RUN_RECOVERY_CONTINUE_PROMPT = "continue exactly where you left off";
 function mergeRunSnapshot(snapshotPrefix, snapshot) {
   return appendInteractionText(snapshotPrefix, snapshot);
 }
-function buildRunRecoveryNote(kind) {
+function buildRunRecoveryNote(kind, params) {
   if (kind === "resume-attempt") {
-    return "Runner session was lost. Attempting recovery 1/2 by reopening the same conversation context.";
+    const attempt = params?.attempt ?? 1;
+    const maxAttempts = params?.maxAttempts ?? MID_RUN_RECOVERY_MAX_ATTEMPTS;
+    return `Runner session was lost. Attempting recovery ${attempt}/${maxAttempts} by reopening the same conversation context.`;
   }
   if (kind === "resume-success") {
-    return "Recovery succeeded. Continuing the current run.";
+    return "Recovery succeeded. Asking the runner to continue exactly where it left off.";
   }
   if (kind === "fresh-attempt") {
     return "The previous runner session could not be resumed. Opening a fresh runner session 2/2 without replaying your prompt.";
@@ -65416,10 +65561,13 @@ class SessionService {
       agentId: run.resolved.agentId,
       sessionKey: run.resolved.sessionKey
     };
+    const recoveryAttempt = params.recoveryAttempt ?? 1;
     const snapshotPrefix = run.latestUpdate.snapshot;
-    const previousFullSnapshot = run.latestUpdate.fullSnapshot;
     const detachedAlready = run.latestUpdate.status === "detached";
-    await this.notifyRecoveryStep(run, buildRunRecoveryNote("resume-attempt"));
+    await this.notifyRecoveryStep(run, buildRunRecoveryNote("resume-attempt", {
+      attempt: recoveryAttempt,
+      maxAttempts: MID_RUN_RECOVERY_MAX_ATTEMPTS
+    }));
     try {
       const recovered = await this.runnerSessions.reopenRunContext(target, params.timingContext);
       const currentRun = this.activeRuns.get(sessionKey);
@@ -65438,15 +65586,22 @@ class SessionService {
       });
       await this.notifyRunObservers(currentRun, currentRun.latestUpdate);
       this.startRunMonitor(sessionKey, {
-        prompt: undefined,
-        initialSnapshot: previousFullSnapshot,
+        prompt: MID_RUN_RECOVERY_CONTINUE_PROMPT,
+        initialSnapshot: recovered.initialSnapshot,
         startedAt: currentRun.startedAt,
         detachedAlready,
         timingContext: params.timingContext,
-        snapshotPrefix
+        snapshotPrefix,
+        recoveryAttempt
       });
       return true;
-    } catch {
+    } catch (reopenError) {
+      if (recoveryAttempt < MID_RUN_RECOVERY_MAX_ATTEMPTS && this.runnerSessions.canRecoverMidRun(reopenError)) {
+        return await this.recoverLostMidRun(sessionKey, {
+          timingContext: params.timingContext,
+          recoveryAttempt: recoveryAttempt + 1
+        }, reopenError);
+      }
       const currentRun = this.activeRuns.get(sessionKey);
       if (!currentRun) {
         return true;
@@ -65552,7 +65707,10 @@ class SessionService {
           }
         });
       } catch (error) {
-        if (await this.recoverLostMidRun(sessionKey, { timingContext: params.timingContext }, error)) {
+        if (await this.recoverLostMidRun(sessionKey, {
+          timingContext: params.timingContext,
+          recoveryAttempt: (params.recoveryAttempt ?? 0) + 1
+        }, error)) {
           return;
         }
         await this.failActiveRun(sessionKey, await this.runnerSessions.mapRunError(error, run.resolved.sessionName, run.latestUpdate.fullSnapshot));
@@ -66877,25 +67035,6 @@ function buildChannelObserverId(identity) {
     identity.topicId ?? ""
   ].join(":");
 }
-function buildSteeringMessage(text, protectedControlMutationRule) {
-  const systemLines = [
-    "A new user message arrived while you were still working.",
-    "Adjust your current work if needed and continue."
-  ];
-  if (protectedControlMutationRule) {
-    systemLines.push("", protectedControlMutationRule);
-  }
-  return [
-    "<system>",
-    ...systemLines,
-    "</system>",
-    "",
-    "<user>",
-    text,
-    "</user>"
-  ].join(`
-`);
-}
 function renderQueuedMessagesList(items) {
   if (items.length === 0) {
     return "Queue is empty.";
@@ -67943,7 +68082,10 @@ ${escapeCodeFence(shellResult.output)}
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
     }
-    await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringMessage(explicitSteerMessage, params.protectedControlMutationRule));
+    await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringPromptText({
+      text: explicitSteerMessage,
+      protectedControlMutationRule: params.protectedControlMutationRule
+    }));
     await params.postText("Steered.");
     await params.agentService.recordConversationReply(params.sessionTarget);
     return {
@@ -67952,7 +68094,10 @@ ${escapeCodeFence(shellResult.output)}
   }
   if (!forceQueuedDelivery && params.route.additionalMessageMode === "steer") {
     if (sessionBusy && canSteerActiveRun) {
-      await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringMessage(params.text, params.protectedControlMutationRule));
+      await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringPromptText({
+        text: params.text,
+        protectedControlMutationRule: params.protectedControlMutationRule
+      }));
       return {
         processingIndicatorLifecycle: "active-run"
       };
@@ -68126,6 +68271,43 @@ function resolveChannelAuth(params) {
 
 // src/auth/owner-claim.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+import { statSync as statSync3 } from "node:fs";
+
+// src/control/config-reload-suppression.ts
+var suppressedReloads = new Map;
+var MTIME_MATCH_EPSILON_MS = 1;
+function normalizeConfigPath(configPath) {
+  return configPath.trim();
+}
+function suppressConfigReload(configPath, mtimeMs) {
+  const normalizedPath = normalizeConfigPath(configPath);
+  if (!normalizedPath || !Number.isFinite(mtimeMs)) {
+    return;
+  }
+  const existing = suppressedReloads.get(normalizedPath) ?? [];
+  existing.push(mtimeMs);
+  suppressedReloads.set(normalizedPath, existing);
+}
+function consumeSuppressedConfigReload(configPath, mtimeMs) {
+  const normalizedPath = normalizeConfigPath(configPath);
+  if (!normalizedPath || !Number.isFinite(mtimeMs)) {
+    return false;
+  }
+  const existing = suppressedReloads.get(normalizedPath);
+  if (!existing || existing.length === 0) {
+    return false;
+  }
+  const next = existing.filter((candidate) => Math.abs(candidate - mtimeMs) > MTIME_MATCH_EPSILON_MS);
+  const matched = next.length !== existing.length;
+  if (next.length === 0) {
+    suppressedReloads.delete(normalizedPath);
+  } else {
+    suppressedReloads.set(normalizedPath, next);
+  }
+  return matched;
+}
+
+// src/auth/owner-claim.ts
 var OWNER_CLAIM_RUNTIME_STARTED_AT_MS = Date.now();
 var CONFIG_LOCK_OPTIONS = {
   retries: {
@@ -68221,6 +68403,7 @@ async function claimFirstOwnerFromDirectMessage(params) {
     }
     freshConfig.app.auth.roles.owner.users = [...currentOwners, principal];
     await writeEditableConfig(expandedPath, freshConfig);
+    suppressConfigReload(expandedPath, statSync3(expandedPath).mtimeMs);
     syncOwnerUsers(params.config, freshConfig);
     ownerClaimRuntimeState.closed = true;
     console.log(`clisbot auto-claimed first owner ${principal}`);
@@ -68726,6 +68909,14 @@ function stripBotMention(text, botUserId) {
   }
   return text.replaceAll(`<@${botUserId}>`, "").replaceAll(/<@[^>]+>/g, "").trim();
 }
+function resolveSlackDirectReplyThreadTs(params) {
+  const resolvedThreadTs = (params.resolvedThreadTs ?? "").trim();
+  if (resolvedThreadTs) {
+    return resolvedThreadTs;
+  }
+  const messageTs = (params.messageTs ?? "").trim();
+  return messageTs || undefined;
+}
 
 // src/channels/slack/reactions.ts
 function normalizeSlackReactionName(value) {
@@ -69501,6 +69692,10 @@ class SlackSocketService {
         await this.processedEventsStore.markCompleted(eventId);
         return;
       }
+      const directReplyThreadTs = resolveSlackDirectReplyThreadTs({
+        messageTs,
+        resolvedThreadTs: await this.resolveThreadTs(event)
+      });
       let ownerClaimed = false;
       let ownerPrincipal;
       try {
@@ -69518,6 +69713,7 @@ class SlackSocketService {
         try {
           await postSlackText(this.app.client, {
             channel: channelId,
+            threadTs: directReplyThreadTs,
             text: renderFirstOwnerClaimMessage({
               principal: ownerPrincipal,
               ownerClaimWindowMinutes: this.loadedConfig.raw.app.auth.ownerClaimWindowMinutes
@@ -69548,6 +69744,7 @@ class SlackSocketService {
               try {
                 await postSlackText(this.app.client, {
                   channel: channelId,
+                  threadTs: directReplyThreadTs,
                   text: buildPairingReply({
                     channel: "slack",
                     idLine: `Your Slack user id: ${directUserId}`,
@@ -71123,6 +71320,7 @@ class TelegramPollingService {
         try {
           await callTelegramApi(this.accountConfig.botToken, "sendMessage", {
             chat_id: message.chat.id,
+            ...message.message_id != null ? { reply_to_message_id: message.message_id } : {},
             text: renderFirstOwnerClaimMessage({
               principal: ownerPrincipal,
               ownerClaimWindowMinutes: this.loadedConfig.raw.app.auth.ownerClaimWindowMinutes
@@ -71809,19 +72007,33 @@ function summarizeExit(params) {
   return `code ${params.code ?? 0}`;
 }
 function getRestartPlan(config, restartNumber) {
-  let completedRestarts = 0;
-  const totalRestarts = config.stages.reduce((sum, stage) => sum + stage.maxRestarts, 0);
+  const fastRetryMaxRestarts = config.fastRetry.maxRestarts;
+  const totalRestarts = fastRetryMaxRestarts + config.stages.reduce((sum, stage) => sum + stage.maxRestarts, 0);
+  if (restartNumber >= 1 && restartNumber <= fastRetryMaxRestarts) {
+    return {
+      mode: "fast-retry",
+      stageIndex: -1,
+      delayMs: config.fastRetry.delaySeconds * 1000,
+      restartAttemptInStage: restartNumber,
+      restartsRemaining: totalRestarts - restartNumber,
+      totalRestarts,
+      stageMaxRestarts: fastRetryMaxRestarts
+    };
+  }
+  let completedRestarts = fastRetryMaxRestarts;
   for (let index = 0;index < config.stages.length; index += 1) {
     const stage = config.stages[index];
     const stageStart = completedRestarts + 1;
     const stageEnd = completedRestarts + stage.maxRestarts;
     if (restartNumber >= stageStart && restartNumber <= stageEnd) {
       return {
+        mode: "backoff",
         stageIndex: index,
-        delayMinutes: stage.delayMinutes,
+        delayMs: stage.delayMinutes * 60000,
         restartAttemptInStage: restartNumber - completedRestarts,
         restartsRemaining: totalRestarts - restartNumber,
-        totalRestarts
+        totalRestarts,
+        stageMaxRestarts: stage.maxRestarts
       };
     }
     completedRestarts = stageEnd;
@@ -71955,7 +72167,7 @@ function renderBackoffAlertMessage(params) {
     `next restart: ${params.nextRestartAt}`,
     `restart: ${params.restartNumber}/${params.totalRestarts}`,
     `stage: ${params.stageIndex + 1}/${params.config.restartBackoff.stages.length}`,
-    `stage attempt: ${params.restartAttemptInStage}/${params.config.restartBackoff.stages[params.stageIndex]?.maxRestarts ?? params.restartAttemptInStage}`
+    `stage attempt: ${params.restartAttemptInStage}/${params.stageMaxRestarts}`
   ].join(`
 `);
 }
@@ -72048,20 +72260,23 @@ class RuntimeMonitor {
         }
         restartNumber = nextRestartNumber;
         totalRestarts = plan.totalRestarts;
-        const nextRestartAt = new Date(this.dependencies.now() + plan.delayMinutes * 60000).toISOString();
-        await this.maybeSendAlert("backoff", monitorConfig, renderBackoffAlertMessage({
-          config: monitorConfig,
-          restartNumber,
-          stageIndex: plan.stageIndex,
-          restartAttemptInStage: plan.restartAttemptInStage,
-          totalRestarts,
-          nextRestartAt,
-          exit: {
-            code: exit.code,
-            signal: exit.signal,
-            at: exitAt
-          }
-        }));
+        const nextRestartAt = new Date(this.dependencies.now() + plan.delayMs).toISOString();
+        if (plan.mode === "backoff") {
+          await this.maybeSendAlert("backoff", monitorConfig, renderBackoffAlertMessage({
+            config: monitorConfig,
+            restartNumber,
+            stageIndex: plan.stageIndex,
+            restartAttemptInStage: plan.restartAttemptInStage,
+            stageMaxRestarts: plan.stageMaxRestarts,
+            totalRestarts,
+            nextRestartAt,
+            exit: {
+              code: exit.code,
+              signal: exit.signal,
+              at: exitAt
+            }
+          }));
+        }
         await this.writeState({
           phase: "backoff",
           runtimePid: undefined,
@@ -72071,6 +72286,7 @@ class RuntimeMonitor {
             at: exitAt
           },
           restart: {
+            mode: plan.mode,
             stageIndex: plan.stageIndex,
             restartNumber,
             restartAttemptInStage: plan.restartAttemptInStage,
@@ -72078,7 +72294,7 @@ class RuntimeMonitor {
             nextRestartAt
           }
         });
-        await this.sleepWithStop(plan.delayMinutes * 60000);
+        await this.sleepWithStop(plan.delayMs);
       }
     } finally {
       await this.stopActiveChild();
@@ -72239,17 +72455,87 @@ var PROCESS_POLL_INTERVAL_MS = 100;
 function resolveConfigPath(configPath) {
   return expandHomePath(configPath ?? process.env.CLISBOT_CONFIG_PATH ?? getDefaultConfigPath());
 }
-function resolvePidPath(pidPath) {
-  return expandHomePath(pidPath ?? process.env.CLISBOT_PID_PATH ?? getDefaultRuntimePidPath());
+function deriveRuntimeSiblingPath(configPath, filename) {
+  if (!configPath) {
+    return null;
+  }
+  return join11(dirname13(expandHomePath(configPath)), "state", filename);
 }
-function resolveLogPath(logPath) {
-  return expandHomePath(logPath ?? process.env.CLISBOT_LOG_PATH ?? getDefaultRuntimeLogPath());
+function resolvePidPath(pidPath, configPath, options = {}) {
+  if (pidPath) {
+    return expandHomePath(pidPath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "clisbot.pid");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_PID_PATH) {
+    return expandHomePath(process.env.CLISBOT_PID_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "clisbot.pid");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimePidPath());
 }
-function resolveMonitorStatePath(monitorStatePath) {
-  return expandHomePath(monitorStatePath ?? process.env.CLISBOT_RUNTIME_MONITOR_STATE_PATH ?? getDefaultRuntimeMonitorStatePath());
+function resolveLogPath(logPath, configPath, options = {}) {
+  if (logPath) {
+    return expandHomePath(logPath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "clisbot.log");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_LOG_PATH) {
+    return expandHomePath(process.env.CLISBOT_LOG_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "clisbot.log");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimeLogPath());
 }
-function resolveRuntimeCredentialsPath(runtimeCredentialsPath) {
-  return expandHomePath(runtimeCredentialsPath ?? process.env.CLISBOT_RUNTIME_CREDENTIALS_PATH ?? getDefaultRuntimeCredentialsPath());
+function resolveMonitorStatePath(monitorStatePath, configPath, options = {}) {
+  if (monitorStatePath) {
+    return expandHomePath(monitorStatePath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "clisbot-monitor.json");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_RUNTIME_MONITOR_STATE_PATH) {
+    return expandHomePath(process.env.CLISBOT_RUNTIME_MONITOR_STATE_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "clisbot-monitor.json");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimeMonitorStatePath());
+}
+function resolveRuntimeCredentialsPath(runtimeCredentialsPath, configPath, options = {}) {
+  if (runtimeCredentialsPath) {
+    return expandHomePath(runtimeCredentialsPath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "runtime-credentials.json");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_RUNTIME_CREDENTIALS_PATH) {
+    return expandHomePath(process.env.CLISBOT_RUNTIME_CREDENTIALS_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "runtime-credentials.json");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimeCredentialsPath());
 }
 
 class StartDetachedRuntimeError extends Error {
@@ -72326,10 +72612,14 @@ async function ensureConfigFile(configPath, options = {}) {
   };
 }
 async function startDetachedRuntime(params) {
-  const pidPath = resolvePidPath(params.pidPath);
-  const logPath = resolveLogPath(params.logPath);
-  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath);
-  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath);
+  const configPath = resolveConfigPath(params.configPath);
+  const preferConfigSibling = params.configPath != null;
+  const pidPath = resolvePidPath(params.pidPath, configPath, { preferConfigSibling });
+  const logPath = resolveLogPath(params.logPath, configPath, { preferConfigSibling });
+  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath, configPath, {
+    preferConfigSibling
+  });
+  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath, configPath, { preferConfigSibling });
   const existingPid = await readRuntimePid(pidPath);
   const existingMonitorState = await readRuntimeMonitorState(monitorStatePath);
   if (existingPid && isProcessRunning(existingPid)) {
@@ -72337,7 +72627,7 @@ async function startDetachedRuntime(params) {
       alreadyRunning: true,
       createdConfig: false,
       pid: existingPid,
-      configPath: resolveConfigPath(params.configPath),
+      configPath,
       logPath
     };
   }
@@ -72402,9 +72692,13 @@ async function startDetachedRuntime(params) {
   };
 }
 async function stopDetachedRuntime(params, dependencies = {}) {
-  const pidPath = resolvePidPath(params.pidPath);
-  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath);
-  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath);
+  const configPath = resolveConfigPath(params.configPath);
+  const preferConfigSibling = params.configPath != null;
+  const pidPath = resolvePidPath(params.pidPath, configPath, { preferConfigSibling });
+  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath, configPath, {
+    preferConfigSibling
+  });
+  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath, configPath, { preferConfigSibling });
   const existingPid = await readRuntimePid(pidPath);
   const monitorState = await readRuntimeMonitorState(monitorStatePath);
   let stopped = false;
@@ -72445,7 +72739,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
   }
   rmSync3(pidPath, { force: true });
   removeRuntimeCredentials(runtimeCredentialsPath);
-  await disableExpiredMemAccountsInConfig(params.configPath);
+  await disableExpiredMemAccountsInConfig(configPath);
   if (monitorState) {
     await writeRuntimeMonitorState(monitorStatePath, {
       ...monitorState,
@@ -72456,7 +72750,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
     });
   }
   if (params.hard) {
-    const socketPath = await resolveTmuxSocketPath(params.configPath);
+    const socketPath = await resolveTmuxSocketPath(configPath);
     const tmux = new TmuxClient(socketPath);
     try {
       await tmux.killServer();
@@ -72489,9 +72783,12 @@ function removeRuntimePid(pidPath) {
 }
 async function getRuntimeStatus(params = {}) {
   const configPath = resolveConfigPath(params.configPath);
-  const pidPath = resolvePidPath(params.pidPath);
-  const logPath = resolveLogPath(params.logPath);
-  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath);
+  const preferConfigSibling = params.configPath != null;
+  const pidPath = resolvePidPath(params.pidPath, configPath, { preferConfigSibling });
+  const logPath = resolveLogPath(params.logPath, configPath, { preferConfigSibling });
+  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath, configPath, {
+    preferConfigSibling
+  });
   const pid = await readRuntimePid(pidPath);
   const liveness = pid ? getProcessLiveness(pid) : "missing";
   const monitorState = await readRuntimeMonitorState(monitorStatePath);
@@ -72508,6 +72805,7 @@ async function getRuntimeStatus(params = {}) {
     runtimePid: monitorState?.runtimePid && getProcessLiveness(monitorState.runtimePid) === "running" ? monitorState.runtimePid : undefined,
     nextRestartAt: monitorState?.restart?.nextRestartAt,
     restartNumber: monitorState?.restart?.restartNumber,
+    restartMode: monitorState?.restart?.mode,
     restartStageIndex: monitorState?.restart?.stageIndex,
     stopReason: monitorState?.stopReason
   };
@@ -72545,7 +72843,7 @@ function getLogSize(logPath) {
     return 0;
   }
   try {
-    return statSync3(logPath).size;
+    return statSync4(logPath).size;
   } catch {
     return 0;
   }
@@ -75086,7 +75384,7 @@ async function start(args = []) {
 }
 
 // src/control/runtime-supervisor.ts
-import { statSync as statSync4, watch } from "node:fs";
+import { statSync as statSync5, watch } from "node:fs";
 import { basename as basename4, dirname as dirname15 } from "node:path";
 
 // src/channels/processed-events-store.ts
@@ -75249,12 +75547,22 @@ class RuntimeSupervisor {
     let nextRuntime;
     try {
       const loadedConfig = await this.dependencies.loadConfig(this.configPath);
+      const configMtimeMs = statSync5(loadedConfig.configPath).mtimeMs;
+      if (reason === "watch" && consumeSuppressedConfigReload(loadedConfig.configPath, configMtimeMs)) {
+        await this.reconcileConfigWatcher(loadedConfig);
+        await this.dependencies.runtimeHealthStore.setReload({
+          status: "success",
+          reason,
+          configMtimeMs
+        });
+        return;
+      }
       nextRuntime = await this.createRuntime(loadedConfig);
       await this.reconcileConfigWatcher(loadedConfig);
       await this.dependencies.runtimeHealthStore.setReload({
         status: "success",
         reason,
-        configMtimeMs: statSync4(loadedConfig.configPath).mtimeMs
+        configMtimeMs
       });
       this.activeRuntime = nextRuntime;
       if (previousRuntime) {
@@ -75596,6 +75904,9 @@ async function printStatusSummary() {
   if (runtimeStatus.restartNumber) {
     console.log(`restart attempt: ${runtimeStatus.restartNumber}`);
   }
+  if (runtimeStatus.restartMode) {
+    console.log(`restart mode: ${runtimeStatus.restartMode}`);
+  }
   if (runtimeStatus.restartStageIndex != null && runtimeStatus.restartStageIndex >= 0) {
     console.log(`restart stage: ${runtimeStatus.restartStageIndex + 1}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clisbot",
-  "version": "0.1.22",
+  "version": "0.1.26",
   "private": false,
   "description": "Chat surfaces for durable AI coding agents running in tmux",
   "license": "MIT",
@@ -29,14 +29,14 @@
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build ./src/main.ts --target=node --outfile ./dist/main.js",
     "dev": "bun --watch run src/main.ts serve-foreground",
-    "start": "bun run src/main.ts start",
-    "restart": "bun run src/main.ts restart",
-    "stop": "bun run src/main.ts stop",
-    "status": "bun run src/main.ts status",
-    "logs": "bun run src/main.ts logs",
-    "init": "bun run src/main.ts init",
+    "start": "bash ./scripts/run-dev-cli.sh start",
+    "restart": "bash ./scripts/run-dev-cli.sh restart",
+    "stop": "bash ./scripts/run-dev-cli.sh stop",
+    "status": "bash ./scripts/run-dev-cli.sh status",
+    "logs": "bash ./scripts/run-dev-cli.sh logs",
+    "init": "bash ./scripts/run-dev-cli.sh init",
     "print-config-path": "bun run src/main.ts print-config-path",
-    "pairing": "bun run src/main.ts pairing",
+    "pairing": "bash ./scripts/run-dev-cli.sh pairing",
     "typecheck": "bunx tsc --noEmit",
     "test": "bun test",
     "prepack": "bun run build",