Merge branch 'main' into commands-list-clean

src/auto-reply/chunk.test.ts

@@ -25,6 +25,45 @@ function expectFencesBalanced(chunks: string[]) {
   }
 }
 
+type ChunkCase = {
+  name: string;
+  text: string;
+  limit: number;
+  expected: string[];
+};
+
+function runChunkCases(
+  chunker: (text: string, limit: number) => string[],
+  cases: ChunkCase[],
+) {
+  for (const { name, text, limit, expected } of cases) {
+    it(name, () => {
+      expect(chunker(text, limit)).toEqual(expected);
+    });
+  }
+}
+
+const parentheticalCases: ChunkCase[] = [
+  {
+    name: "keeps parenthetical phrases together",
+    text: "Heads up now (Though now I'm curious)ok",
+    limit: 35,
+    expected: ["Heads up now", "(Though now I'm curious)ok"],
+  },
+  {
+    name: "handles nested parentheses",
+    text: "Hello (outer (inner) end) world",
+    limit: 26,
+    expected: ["Hello (outer (inner) end)", "world"],
+  },
+  {
+    name: "ignores unmatched closing parentheses",
+    text: "Hello) world (ok)",
+    limit: 12,
+    expected: ["Hello)", "world (ok)"],
+  },
+];
+
 describe("chunkText", () => {
   it("keeps multi-line text in one chunk when under limit", () => {
     const text = "Line one\n\nLine two\n\nLine three";
@@ -68,11 +107,7 @@ describe("chunkText", () => {
     expect(chunks).toEqual(["Supercalif", "ragilistic", "expialidoc", "ious"]);
   });
 
-  it("keeps parenthetical phrases together", () => {
-    const text = "Heads up now (Though now I'm curious)ok";
-    const chunks = chunkText(text, 35);
-    expect(chunks).toEqual(["Heads up now", "(Though now I'm curious)ok"]);
-  });
+  runChunkCases(chunkText, [parentheticalCases[0]]);
 });
 
 describe("resolveTextChunkLimit", () => {
@@ -191,17 +226,7 @@ describe("chunkMarkdownText", () => {
     }
   });
 
-  it("keeps parenthetical phrases together", () => {
-    const text = "Heads up now (Though now I'm curious)ok";
-    const chunks = chunkMarkdownText(text, 35);
-    expect(chunks).toEqual(["Heads up now", "(Though now I'm curious)ok"]);
-  });
-
-  it("handles nested parentheses", () => {
-    const text = "Hello (outer (inner) end) world";
-    const chunks = chunkMarkdownText(text, 26);
-    expect(chunks).toEqual(["Hello (outer (inner) end)", "world"]);
-  });
+  runChunkCases(chunkMarkdownText, parentheticalCases);
 
   it("hard-breaks when a parenthetical exceeds the limit", () => {
     const text = `(${"a".repeat(80)})`;
@@ -209,10 +234,4 @@ describe("chunkMarkdownText", () => {
     expect(chunks[0]?.length).toBe(20);
     expect(chunks.join("")).toBe(text);
   });
-
-  it("ignores unmatched closing parentheses", () => {
-    const text = "Hello) world (ok)";
-    const chunks = chunkMarkdownText(text, 12);
-    expect(chunks).toEqual(["Hello)", "world (ok)"]);
-  });
 });

src/auto-reply/chunk.ts

@@ -91,23 +91,7 @@ export function chunkText(text: string, limit: number): string[] {
     const window = remaining.slice(0, limit);
 
     // 1) Prefer a newline break inside the window (outside parentheses).
-    let lastNewline = -1;
-    let lastWhitespace = -1;
-    let depth = 0;
-    for (let i = 0; i < window.length; i++) {
-      const char = window[i];
-      if (char === "(") {
-        depth += 1;
-        continue;
-      }
-      if (char === ")" && depth > 0) {
-        depth -= 1;
-        continue;
-      }
-      if (depth !== 0) continue;
-      if (char === "\n") lastNewline = i;
-      else if (/\s/.test(char)) lastWhitespace = i;
-    }
+    const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(window);
 
     // 2) Otherwise prefer the last whitespace (word boundary) inside the window.
     let breakIdx = lastNewline > 0 ? lastNewline : lastWhitespace;
@@ -243,12 +227,26 @@ function pickSafeBreakIndex(
   window: string,
   spans: ReturnType<typeof parseFenceSpans>,
 ): number {
+  const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(
+    window,
+    (index) => isSafeFenceBreak(spans, index),
+  );
+
+  if (lastNewline > 0) return lastNewline;
+  if (lastWhitespace > 0) return lastWhitespace;
+  return -1;
+}
+
+function scanParenAwareBreakpoints(
+  window: string,
+  isAllowed: (index: number) => boolean = () => true,
+): { lastNewline: number; lastWhitespace: number } {
   let lastNewline = -1;
   let lastWhitespace = -1;
   let depth = 0;
 
   for (let i = 0; i < window.length; i++) {
-    if (!isSafeFenceBreak(spans, i)) continue;
+    if (!isAllowed(i)) continue;
     const char = window[i];
     if (char === "(") {
       depth += 1;
@@ -263,7 +261,5 @@ function pickSafeBreakIndex(
     else if (/\s/.test(char)) lastWhitespace = i;
   }
 
-  if (lastNewline > 0) return lastNewline;
-  if (lastWhitespace > 0) return lastWhitespace;
-  return -1;
+  return { lastNewline, lastWhitespace };
 }

src/auto-reply/model.test.ts

@@ -107,6 +107,12 @@ describe("extractModelDirective", () => {
   });
 
   describe("edge cases", () => {
+    it("preserves spacing when /model is followed by a path segment", () => {
+      const result = extractModelDirective("thats not /model gpt-5/tmp/hello");
+      expect(result.hasDirective).toBe(true);
+      expect(result.cleaned).toBe("thats not /hello");
+    });
+
     it("handles alias with special regex characters", () => {
       const result = extractModelDirective("/test.alias", {
         aliases: ["test.alias"],

src/auto-reply/model.ts

@@ -42,7 +42,7 @@ export function extractModelDirective(
   }
 
   const cleaned = match
-    ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+    ? body.replace(match[0], " ").replace(/\s+/g, " ").trim()
     : body.trim();
 
   return {

src/auto-reply/reply.directive.parse.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 
+import { extractStatusDirective } from "./reply/directives.js";
 import {
   extractElevatedDirective,
   extractQueueDirective,
@@ -119,6 +120,30 @@ describe("directive parsing", () => {
     expect(res.cleaned).toBe("please now");
   });
 
+  it("preserves spacing when stripping think directives before paths", () => {
+    const res = extractThinkDirective("thats not /think high/tmp/hello");
+    expect(res.hasDirective).toBe(true);
+    expect(res.cleaned).toBe("thats not /tmp/hello");
+  });
+
+  it("preserves spacing when stripping verbose directives before paths", () => {
+    const res = extractVerboseDirective("thats not /verbose on/tmp/hello");
+    expect(res.hasDirective).toBe(true);
+    expect(res.cleaned).toBe("thats not /tmp/hello");
+  });
+
+  it("preserves spacing when stripping reasoning directives before paths", () => {
+    const res = extractReasoningDirective("thats not /reasoning on/tmp/hello");
+    expect(res.hasDirective).toBe(true);
+    expect(res.cleaned).toBe("thats not /tmp/hello");
+  });
+
+  it("preserves spacing when stripping status directives before paths", () => {
+    const res = extractStatusDirective("thats not /status:/tmp/hello");
+    expect(res.hasDirective).toBe(true);
+    expect(res.cleaned).toBe("thats not /tmp/hello");
+  });
+
   it("parses queue options and modes", () => {
     const res = extractQueueDirective(
       "please /queue steer+backlog debounce:2s cap:5 drop:summarize now",

src/auto-reply/reply.triggers.test.ts

@@ -340,6 +340,132 @@ describe("trigger handling", () => {
     });
   });
 
+  it("ignores elevated directive in groups when not mentioned", async () => {
+    await withTempHome(async (home) => {
+      vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
+        payloads: [{ text: "ok" }],
+        meta: {
+          durationMs: 1,
+          agentMeta: { sessionId: "s", provider: "p", model: "m" },
+        },
+      });
+      const cfg = {
+        agent: {
+          model: "anthropic/claude-opus-4-5",
+          workspace: join(home, "clawd"),
+          elevated: {
+            allowFrom: { whatsapp: ["+1000"] },
+          },
+        },
+        whatsapp: {
+          allowFrom: ["+1000"],
+          groups: { "*": { requireMention: false } },
+        },
+        session: { store: join(home, "sessions.json") },
+      };
+
+      const res = await getReplyFromConfig(
+        {
+          Body: "/elevated on",
+          From: "group:123@g.us",
+          To: "whatsapp:+2000",
+          Provider: "whatsapp",
+          SenderE164: "+1000",
+          ChatType: "group",
+          WasMentioned: false,
+        },
+        {},
+        cfg,
+      );
+      const text = Array.isArray(res) ? res[0]?.text : res?.text;
+      expect(text).toBe("ok");
+      expect(text).not.toContain("Elevated mode enabled");
+    });
+  });
+
+  it("allows elevated directive in groups when mentioned", async () => {
+    await withTempHome(async (home) => {
+      const cfg = {
+        agent: {
+          model: "anthropic/claude-opus-4-5",
+          workspace: join(home, "clawd"),
+          elevated: {
+            allowFrom: { whatsapp: ["+1000"] },
+          },
+        },
+        whatsapp: {
+          allowFrom: ["+1000"],
+          groups: { "*": { requireMention: true } },
+        },
+        session: { store: join(home, "sessions.json") },
+      };
+
+      const res = await getReplyFromConfig(
+        {
+          Body: "/elevated on",
+          From: "group:123@g.us",
+          To: "whatsapp:+2000",
+          Provider: "whatsapp",
+          SenderE164: "+1000",
+          ChatType: "group",
+          WasMentioned: true,
+        },
+        {},
+        cfg,
+      );
+      const text = Array.isArray(res) ? res[0]?.text : res?.text;
+      expect(text).toContain("Elevated mode enabled");
+
+      const storeRaw = await fs.readFile(cfg.session.store, "utf-8");
+      const store = JSON.parse(storeRaw) as Record<
+        string,
+        { elevatedLevel?: string }
+      >;
+      expect(store["agent:main:whatsapp:group:123@g.us"]?.elevatedLevel).toBe(
+        "on",
+      );
+    });
+  });
+
+  it("allows elevated directive in direct chats without mentions", async () => {
+    await withTempHome(async (home) => {
+      const cfg = {
+        agent: {
+          model: "anthropic/claude-opus-4-5",
+          workspace: join(home, "clawd"),
+          elevated: {
+            allowFrom: { whatsapp: ["+1000"] },
+          },
+        },
+        whatsapp: {
+          allowFrom: ["+1000"],
+        },
+        session: { store: join(home, "sessions.json") },
+      };
+
+      const res = await getReplyFromConfig(
+        {
+          Body: "/elevated on",
+          From: "+1000",
+          To: "+2000",
+          Provider: "whatsapp",
+          SenderE164: "+1000",
+        },
+        {},
+        cfg,
+      );
+      const text = Array.isArray(res) ? res[0]?.text : res?.text;
+      expect(text).toContain("Elevated mode enabled");
+
+      const storeRaw = await fs.readFile(cfg.session.store, "utf-8");
+      const store = JSON.parse(storeRaw) as Record<
+        string,
+        { elevatedLevel?: string }
+      >;
+      expect(store[MAIN_SESSION_KEY]?.elevatedLevel).toBe("on");
+    });
+  });
+
   it("ignores inline elevated directive for unapproved sender", async () => {
     await withTempHome(async (home) => {
       vi.mocked(runEmbeddedPiAgent).mockResolvedValue({

src/auto-reply/reply.ts

@@ -329,8 +329,10 @@ export async function getReplyFromConfig(
     .map((entry) => entry.alias?.trim())
     .filter((alias): alias is string => Boolean(alias))
     .filter((alias) => !reservedCommands.has(alias.toLowerCase()));
+  const disableElevatedInGroup = isGroup && ctx.WasMentioned !== true;
   let parsedDirectives = parseInlineDirectives(rawBody, {
     modelAliases: configuredAliases,
+    disableElevated: disableElevatedInGroup,
   });
   const hasDirective =
     parsedDirectives.hasThinkDirective ||
@@ -342,7 +344,9 @@ export async function getReplyFromConfig(
     parsedDirectives.hasQueueDirective;
   if (hasDirective) {
     const stripped = stripStructuralPrefixes(parsedDirectives.cleaned);
-    const noMentions = isGroup ? stripMentions(stripped, ctx, cfg) : stripped;
+    const noMentions = isGroup
+      ? stripMentions(stripped, ctx, cfg, agentId)
+      : stripped;
     if (noMentions.trim().length > 0) {
       parsedDirectives = clearInlineDirectives(parsedDirectives.cleaned);
     }
@@ -467,6 +471,7 @@ export async function getReplyFromConfig(
       cleanedBody: directives.cleaned,
       ctx,
       cfg,
+      agentId,
       isGroup,
     })
   ) {
@@ -549,6 +554,7 @@ export async function getReplyFromConfig(
   const command = buildCommandContext({
     ctx,
     cfg,
+    agentId,
     sessionKey,
     isGroup,
     triggerBodyNormalized,
@@ -579,6 +585,7 @@ export async function getReplyFromConfig(
     ctx,
     cfg,
     command,
+    agentId,
     directives,
     sessionEntry,
     sessionStore,

src/auto-reply/reply/commands.ts

@@ -126,11 +126,12 @@ function extractCompactInstructions(params: {
   rawBody?: string;
   ctx: MsgContext;
   cfg: ClawdbotConfig;
+  agentId?: string;
   isGroup: boolean;
 }): string | undefined {
   const raw = stripStructuralPrefixes(params.rawBody ?? "");
   const stripped = params.isGroup
-    ? stripMentions(raw, params.ctx, params.cfg)
+    ? stripMentions(raw, params.ctx, params.cfg, params.agentId)
     : raw;
   const trimmed = stripped.trim();
   if (!trimmed) return undefined;
@@ -145,12 +146,14 @@ function extractCompactInstructions(params: {
 export function buildCommandContext(params: {
   ctx: MsgContext;
   cfg: ClawdbotConfig;
+  agentId?: string;
   sessionKey?: string;
   isGroup: boolean;
   triggerBodyNormalized: string;
   commandAuthorized: boolean;
 }): CommandContext {
-  const { ctx, cfg, sessionKey, isGroup, triggerBodyNormalized } = params;
+  const { ctx, cfg, agentId, sessionKey, isGroup, triggerBodyNormalized } =
+    params;
   const auth = resolveCommandAuthorization({
     ctx,
     cfg,
@@ -162,7 +165,9 @@ export function buildCommandContext(params: {
     sessionKey ?? (auth.from || undefined) ?? (auth.to || undefined);
   const rawBodyNormalized = triggerBodyNormalized;
   const commandBodyNormalized = normalizeCommandBody(
-    isGroup ? stripMentions(rawBodyNormalized, ctx, cfg) : rawBodyNormalized,
+    isGroup
+      ? stripMentions(rawBodyNormalized, ctx, cfg, agentId)
+      : rawBodyNormalized,
   );
 
   return {
@@ -207,6 +212,7 @@ export async function handleCommands(params: {
   ctx: MsgContext;
   cfg: ClawdbotConfig;
   command: CommandContext;
+  agentId?: string;
   directives: InlineDirectives;
   sessionEntry?: SessionEntry;
   sessionStore?: Record<string, SessionEntry>;
@@ -542,6 +548,7 @@ export async function handleCommands(params: {
       rawBody: ctx.Body,
       ctx,
       cfg,
+      agentId: params.agentId,
       isGroup,
     });
     const result = await compactEmbeddedPiSession({

src/auto-reply/reply/directive-handling.ts

@@ -184,7 +184,7 @@ export type InlineDirectives = {
 
 export function parseInlineDirectives(
   body: string,
-  options?: { modelAliases?: string[] },
+  options?: { modelAliases?: string[]; disableElevated?: boolean },
 ): InlineDirectives {
   const {
     cleaned: thinkCleaned,
@@ -209,7 +209,14 @@ export function parseInlineDirectives(
     elevatedLevel,
     rawLevel: rawElevatedLevel,
     hasDirective: hasElevatedDirective,
-  } = extractElevatedDirective(reasoningCleaned);
+  } = options?.disableElevated
+    ? {
+        cleaned: reasoningCleaned,
+        elevatedLevel: undefined,
+        rawLevel: undefined,
+        hasDirective: false,
+      }
+    : extractElevatedDirective(reasoningCleaned);
   const { cleaned: statusCleaned, hasDirective: hasStatusDirective } =
     extractStatusDirective(elevatedCleaned);
   const {
@@ -272,9 +279,10 @@ export function isDirectiveOnly(params: {
   cleanedBody: string;
   ctx: MsgContext;
   cfg: ClawdbotConfig;
+  agentId?: string;
   isGroup: boolean;
 }): boolean {
-  const { directives, cleanedBody, ctx, cfg, isGroup } = params;
+  const { directives, cleanedBody, ctx, cfg, agentId, isGroup } = params;
   if (
     !directives.hasThinkDirective &&
     !directives.hasVerboseDirective &&
@@ -285,7 +293,9 @@ export function isDirectiveOnly(params: {
   )
     return false;
   const stripped = stripStructuralPrefixes(cleanedBody ?? "");
-  const noMentions = isGroup ? stripMentions(stripped, ctx, cfg) : stripped;
+  const noMentions = isGroup
+    ? stripMentions(stripped, ctx, cfg, agentId)
+    : stripped;
   return noMentions.length === 0;
 }
 

src/auto-reply/reply/directives.ts

@@ -56,6 +56,7 @@ const extractLevelDirective = <T>(
   const level = normalize(rawLevel);
   const cleaned = body
     .slice(0, match.start)
+    .concat(" ")
     .concat(body.slice(match.end))
     .replace(/\s+/g, " ")
     .trim();
@@ -76,7 +77,7 @@ const extractSimpleDirective = (
     new RegExp(`(?:^|\\s)\\/(?:${namePattern})(?=$|\\s|:)(?:\\s*:\\s*)?`, "i"),
   );
   const cleaned = match
-    ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+    ? body.replace(match[0], " ").replace(/\s+/g, " ").trim()
     : body.trim();
   return {
     cleaned,

src/auto-reply/reply/mentions.test.ts

@@ -27,4 +27,20 @@ describe("mention helpers", () => {
     });
     expect(matchesMentionPatterns("CLAWD: hi", regexes)).toBe(true);
   });
+
+  it("uses per-agent mention patterns when configured", () => {
+    const regexes = buildMentionRegexes(
+      {
+        routing: {
+          groupChat: { mentionPatterns: ["\\bglobal\\b"] },
+          agents: {
+            work: { mentionPatterns: ["\\bworkbot\\b"] },
+          },
+        },
+      },
+      "work",
+    );
+    expect(matchesMentionPatterns("workbot: hi", regexes)).toBe(true);
+    expect(matchesMentionPatterns("global: hi", regexes)).toBe(false);
+  });
 });

src/auto-reply/reply/mentions.ts

@@ -1,8 +1,23 @@
 import type { ClawdbotConfig } from "../../config/config.js";
 import type { MsgContext } from "../templating.js";
 
-export function buildMentionRegexes(cfg: ClawdbotConfig | undefined): RegExp[] {
-  const patterns = cfg?.routing?.groupChat?.mentionPatterns ?? [];
+function resolveMentionPatterns(
+  cfg: ClawdbotConfig | undefined,
+  agentId?: string,
+): string[] {
+  if (!cfg) return [];
+  const agentConfig = agentId ? cfg.routing?.agents?.[agentId] : undefined;
+  if (agentConfig && Object.hasOwn(agentConfig, "mentionPatterns")) {
+    return agentConfig.mentionPatterns ?? [];
+  }
+  return cfg.routing?.groupChat?.mentionPatterns ?? [];
+}
+
+export function buildMentionRegexes(
+  cfg: ClawdbotConfig | undefined,
+  agentId?: string,
+): RegExp[] {
+  const patterns = resolveMentionPatterns(cfg, agentId);
   return patterns
     .map((pattern) => {
       try {
@@ -48,9 +63,10 @@ export function stripMentions(
   text: string,
   ctx: MsgContext,
   cfg: ClawdbotConfig | undefined,
+  agentId?: string,
 ): string {
   let result = text;
-  const patterns = cfg?.routing?.groupChat?.mentionPatterns ?? [];
+  const patterns = resolveMentionPatterns(cfg, agentId);
   for (const p of patterns) {
     try {
       const re = new RegExp(p, "gi");

src/auto-reply/reply/queue.ts

@@ -271,8 +271,9 @@ export function extractQueueDirective(body?: string): {
   const argsStart = start + "/queue".length;
   const args = body.slice(argsStart);
   const parsed = parseQueueDirectiveArgs(args);
-  const cleanedRaw =
-    body.slice(0, start) + body.slice(argsStart + parsed.consumed);
+  const cleanedRaw = `${body.slice(0, start)} ${body.slice(
+    argsStart + parsed.consumed,
+  )}`;
   const cleaned = cleanedRaw.replace(/\s+/g, " ").trim();
   return {
     cleaned,

src/auto-reply/reply/session.ts

@@ -136,7 +136,7 @@ export async function initSessionState(params: {
   // web inbox before we get here. They prevented reset triggers like "/new"
   // from matching, so strip structural wrappers when checking for resets.
   const strippedForReset = isGroup
-    ? stripMentions(triggerBodyNormalized, ctx, cfg)
+    ? stripMentions(triggerBodyNormalized, ctx, cfg, agentId)
     : triggerBodyNormalized;
   for (const trigger of resetTriggers) {
     if (!trigger) continue;