@circuitwall/jarela 2.3.0 → 2.5.0

package/lib/agents/citation-checker.ts

@@ -85,17 +85,28 @@ const SOURCE_PRODUCING_TOOLS_RESULT = new Set([
   "web_search", "fetch_webpage", "web_fetch",
 ]);
 
-// Strip query/fragment for URLs and normalize backslashes for paths so a
-// citation that drops `?utm=...` or uses forward slashes on Windows still
-// matches the visited entry. Also fold `~/...` to the resolved home dir
-// so `~/Downloads/x` and `C:\Users\andre\Downloads\x` de-dupe.
+const TRACKING_PARAM_RE = /^(?:utm(?:_.*)?|fbclid|gclid|dclid|msclkid|mc_cid|mc_eid|igshid|ref_src)$/i;
+
+// Drop tracking params and in-page anchors for URLs and normalize
+// backslashes for paths so a citation that adds `?utm_source=...` or uses
+// forward slashes on Windows still matches the visited entry. Identifying
+// query params (Outlook `?ItemID=`, `watch?v=`) and hash routes (Gmail
+// `#all/<id>`) are kept verbatim: they are case-sensitive and are the only
+// thing that distinguishes two message permalinks. Also fold `~/...` to the
+// resolved home dir so `~/Downloads/x` and `C:\Users\andre\Downloads\x` de-dupe.
 export function normalizeSource(raw: string): string {
   const trimmed = raw.trim();
   if (!trimmed) return "";
   if (/^https?:\/\//i.test(trimmed)) {
     try {
       const u = new URL(trimmed);
-      return `${u.protocol}//${u.host}${u.pathname}`.replace(/\/+$/, "").toLowerCase();
+      const base = `${u.protocol}//${u.host}${u.pathname}`.replace(/\/+$/, "").toLowerCase();
+      const params = [...u.searchParams]
+        .filter(([key]) => !TRACKING_PARAM_RE.test(key))
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+      const query = params.length > 0 ? `?${new URLSearchParams(params).toString()}` : "";
+      const hashRoute = u.hash.includes("/") ? u.hash : "";
+      return base + query + hashRoute;
     } catch {
       return trimmed.toLowerCase();
     }
@@ -436,12 +447,9 @@ ${sent}`;
 export function parseCitationVerdict(text: string): CitationClaim[] | null {
   if (!text) return null;
   const stripped = text.replace(/```(?:json)?\s*/gi, "").replace(/```/g, "").trim();
-  const m = /\{[^]*"claims"[^]*\}/.exec(stripped);
-  if (!m) return null;
-  let parsed: unknown;
-  try { parsed = JSON.parse(m[0]); } catch { return null; }
-  if (!parsed || typeof parsed !== "object") return null;
-  const claimsRaw = (parsed as { claims?: unknown }).claims;
+  const parsed = findClaimsObject(stripped);
+  if (!parsed) return null;
+  const claimsRaw = parsed.claims;
   if (!Array.isArray(claimsRaw)) return null;
   const claims: CitationClaim[] = [];
   for (const item of claimsRaw) {
@@ -464,6 +472,43 @@ export function parseCitationVerdict(text: string): CitationClaim[] | null {
   return claims;
 }
 
+// Models often wrap the verdict in prose that itself contains braces, so a
+// single greedy `{...}` match can start or end in the wrong place. Try each
+// `{` as a start and parse the balanced object it opens (string-aware).
+function findClaimsObject(text: string): { claims?: unknown } | null {
+  for (let start = text.indexOf("{"); start !== -1; start = text.indexOf("{", start + 1)) {
+    const end = balancedObjectEnd(text, start);
+    if (end === -1) continue;
+    const candidate = text.slice(start, end + 1);
+    if (!candidate.includes('"claims"')) continue;
+    try {
+      const parsed: unknown = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && "claims" in parsed) return parsed as { claims?: unknown };
+    } catch { /* try the next opening brace */ }
+  }
+  return null;
+}
+
+function balancedObjectEnd(text: string, start: number): number {
+  let depth = 0;
+  let inString = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === "\\") i++;
+      else if (ch === '"') inString = false;
+    } else if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
 function collectStringsFromPayload(payload: unknown, out: Set<string>): void {
   if (!payload) return;
   if (typeof payload === "string") {

package/lib/agents/context-boundary.ts

@@ -3,12 +3,11 @@ import { kickBoundaryCompaction } from "@/lib/agents/warm-summary-background";
 
 // Every caller of moveThreadContextBoundary represents a user-initiated
 // boundary change (drag the line, the manual /compact command, or the agent's
-// compact_context tool acting on the user's say-so) — the
-// auto-detector's own commit (lib/agents/warm-summary-background.ts
-// commitBoundaryCompaction) calls setThreadContextPin directly instead, so
-// it never re-arms this lock. Suppresses the hot-turn-limit compaction in
-// lib/agents/run-thread.ts for the next N eligible turns so a manual
-// choice doesn't get silently re-moved on the very next turn.
+// compact_context tool acting on the user's say-so). Suppresses the
+// hot-turn-limit compaction in lib/agents/run-thread.ts for the next N
+// eligible turns so a manual choice doesn't get silently re-moved on the very
+// next turn. The auto-detector arms a shorter cooldown of its own
+// (hotTurnCooldownUntil) so it doesn't re-run on every turn either.
 // Counted in messages (~2 per turn: one user + one assistant row) since
 // that's what's already on the thread row — no extra query or per-turn
 // write needed to check it.

package/lib/agents/instruction-edits.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { applyInstructionEdits } from "./instruction-edits";
+
+function edit(base: string, edits: unknown): string {
+  const out = applyInstructionEdits(base, edits);
+  if (!out.ok) throw new Error(out.error);
+  return out.text;
+}
+
+describe("applyInstructionEdits validation", () => {
+  it("rejects a non-array and reports the failing index", () => {
+    expect(applyInstructionEdits("x", { op: "append" })).toEqual({ ok: false, error: "instructions_edits must be an array" });
+    expect(applyInstructionEdits("x", [{ op: "append", text: "a" }, null])).toEqual({ ok: false, error: "instructions_edits[1] must be an object" });
+    expect(applyInstructionEdits("x", [{}])).toEqual({ ok: false, error: "instructions_edits[0].op is required" });
+    expect(applyInstructionEdits("x", [{ op: "rewrite" }])).toEqual({ ok: false, error: "instructions_edits[0].op is not supported" });
+    expect(applyInstructionEdits("x", [{ op: "replace", find: "x" }])).toEqual({ ok: false, error: "instructions_edits[0].replace must be a string" });
+  });
+
+  it("fails the whole batch instead of applying a prefix of it", () => {
+    const out = applyInstructionEdits("keep", [{ op: "append", text: " more" }, { op: "remove" }]);
+    expect(out.ok).toBe(false);
+  });
+});
+
+describe("append / prepend", () => {
+  it("skips an if_missing append when the text is already present, honoring ignore_case", () => {
+    const out = applyInstructionEdits("Always cite sources.", [
+      { op: "append", text: "always CITE sources.", if_missing: true, ignore_case: true },
+      { op: "prepend", text: "Be brief. ", if_missing: true },
+    ]);
+    expect(out).toEqual({
+      ok: true,
+      text: "Be brief. Always cite sources.",
+      summary: [
+        { index: 0, op: "append", applied: false },
+        { index: 1, op: "prepend", applied: true },
+      ],
+    });
+  });
+});
+
+describe("replace / remove", () => {
+  it("treats find text literally, including regex metacharacters and $ patterns", () => {
+    expect(edit("cost is $5 (approx.)", [{ op: "replace", find: "$5 (approx.)", replace: "$$ & $&", ignore_case: true }]))
+      .toBe("cost is $$ & $&");
+    expect(edit("a.b a.b", [{ op: "replace", find: "a.b", replace: "$'", all: true }])).toBe("$' $'");
+  });
+
+  it("replaces only the first match unless all is set, and counts replacements", () => {
+    const out = applyInstructionEdits("Foo foo FOO", [
+      { op: "replace", find: "foo", replace: "bar", ignore_case: true },
+      { op: "remove", text: "FOO", all: true },
+    ]);
+    expect(out).toMatchObject({ ok: true, text: "bar foo ", summary: [{ replacements: 1 }, { removals: 1 }] });
+  });
+
+  it("is a no-op for an empty find string rather than inserting between every character", () => {
+    expect(edit("abc", [{ op: "replace", find: "", replace: "-", all: true }])).toBe("abc");
+  });
+});
+
+describe("dedupe_lines", () => {
+  it("removes repeated rules case-insensitively but keeps blank lines", () => {
+    const out = applyInstructionEdits("- Cite sources\n\n- cite sources \n- Be brief\n\n", [{ op: "dedupe_lines" }]);
+    expect(out).toMatchObject({ ok: true, text: "- Cite sources\n\n- Be brief\n\n", summary: [{ removed: 1 }] });
+  });
+
+  it("keeps the last occurrence when asked", () => {
+    expect(edit("a\nb\nA", [{ op: "dedupe_lines", keep: "last" }])).toBe("b\nA");
+  });
+
+  it("never removes code fence markers, fenced content, or horizontal rules", () => {
+    const base = [
+      "Rule one",
+      "```json",
+      "{ \"a\": 1 }",
+      "```",
+      "---",
+      "Example two:",
+      "```json",
+      "{ \"a\": 1 }",
+      "```",
+      "---",
+      "Rule one",
+    ].join("\n");
+    const expected = base.split("\n").slice(0, -1).join("\n");
+    expect(edit(base, [{ op: "dedupe_lines" }])).toBe(expected);
+  });
+
+  it("does not treat a fence line with an info string as the closing fence", () => {
+    const base = "```text\n```json\nx\nx\n```\n";
+    expect(edit(base, [{ op: "dedupe_lines" }])).toBe(base);
+  });
+  it("preserves CRLF line endings", () => {
+    expect(edit("a\r\nb\r\na\r\nc", [{ op: "dedupe_lines" }])).toBe("a\r\nb\r\nc");
+  });
+});
+
+describe("dedupe_paragraphs", () => {
+  it("removes a repeated paragraph and leaves the rest of the text byte-identical", () => {
+    const base = "# Rules\n\n  - indented item\n  - second\n\n\nAlways cite.\n\nalways cite.\n";
+    expect(edit(base, [{ op: "dedupe_paragraphs" }])).toBe("# Rules\n\n  - indented item\n  - second\n\n\nAlways cite.\n");
+  });
+
+  it("does not touch whitespace when there is nothing to remove", () => {
+    const base = "\n\nIntro\n\n\n\n    indented code\n";
+    const out = applyInstructionEdits(base, [{ op: "dedupe_paragraphs" }]);
+    expect(out).toMatchObject({ ok: true, text: base, summary: [{ removed: 0 }] });
+  });
+
+  it("respects trim: false by treating differently indented paragraphs as distinct", () => {
+    const base = "item\n\n  item";
+    expect(edit(base, [{ op: "dedupe_paragraphs", trim: false }])).toBe(base);
+    expect(edit(base, [{ op: "dedupe_paragraphs" }])).toBe("item");
+  });
+
+  it("keeps the last occurrence and drops the separator that belonged to the removed paragraph", () => {
+    expect(edit("A\n\nB\n\na", [{ op: "dedupe_paragraphs", keep: "last" }])).toBe("B\n\na");
+  });
+});

package/lib/agents/instruction-edits.ts

@@ -172,58 +172,81 @@ function containsText(source: string, needle: string, ignoreCase: boolean): bool
   return source.toLowerCase().includes(needle.toLowerCase());
 }
 
+const FENCE_RE = /^\s{0,3}(`{3,}|~{3,})/;
+const HORIZONTAL_RULE_RE = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+
+/**
+ * Drop duplicate segments from `parts`, which alternates content (even
+ * indexes) and the original separator that follows it (odd indexes).
+ * Separators are preserved verbatim, so only removed segments change the
+ * text. `keyOf` returns null for a segment that must always be kept.
+ */
+function dedupeSegments(
+  parts: readonly string[],
+  keyOf: (segmentIndex: number) => string | null,
+  keep: "first" | "last",
+): { text: string; removed: number } {
+  const contentIdx = parts.map((_, i) => i).filter((i) => i % 2 === 0);
+  const visit = keep === "first" ? contentIdx : [...contentIdx].reverse();
+  const seen = new Set<string>();
+  const dropped = new Set<number>();
+  for (const idx of visit) {
+    const key = keyOf(idx);
+    if (key === null) continue;
+    if (seen.has(key)) dropped.add(idx);
+    else seen.add(key);
+  }
+  if (dropped.size === 0) return { text: parts.join(""), removed: 0 };
+  let text = "";
+  let emitted = false;
+  for (const idx of contentIdx) {
+    if (dropped.has(idx)) continue;
+    if (emitted && idx > 0) text += parts[idx - 1];
+    text += parts[idx];
+    emitted = true;
+  }
+  return { text, removed: dropped.size };
+}
+
 function dedupeLines(
   source: string,
   opts: { trim: boolean; ignoreCase: boolean; skipBlank: boolean; keep: "first" | "last" },
 ): { text: string; removed: number } {
-  const lines = source.split(/\r?\n/);
-  const keyed = lines.map((line) => {
-    const normalized = opts.trim ? line.trim() : line;
-    return opts.ignoreCase ? normalized.toLowerCase() : normalized;
-  });
-
-  const keep = new Set<number>();
-  const visit = opts.keep === "first"
-    ? [...keyed.keys()]
-    : [...keyed.keys()].reverse();
-  const seen = new Set<string>();
-  for (const idx of visit) {
-    const key = keyed[idx];
-    if (opts.skipBlank && key.length === 0) {
-      keep.add(idx);
-      continue;
+  const parts = source.split(/(\r?\n)/);
+  // Fence markers, fenced code and horizontal rules repeat by design; a
+  // closing ``` is always a "duplicate" of the opening one.
+  const protectedIdx = new Set<number>();
+  let fence: string | null = null;
+  for (let i = 0; i < parts.length; i += 2) {
+    const marker = FENCE_RE.exec(parts[i])?.[1];
+    if (fence !== null) {
+      protectedIdx.add(i);
+      if (marker && marker[0] === fence[0] && marker.length >= fence.length && /^\s*[`~]+\s*$/.test(parts[i])) fence = null;
+    } else if (marker) {
+      protectedIdx.add(i);
+      fence = marker;
+    } else if (HORIZONTAL_RULE_RE.test(parts[i])) {
+      protectedIdx.add(i);
     }
-    if (seen.has(key)) continue;
-    seen.add(key);
-    keep.add(idx);
   }
-  const next = lines.filter((_, idx) => keep.has(idx));
-  return { text: next.join("\n"), removed: lines.length - next.length };
+  return dedupeSegments(parts, (i) => {
+    if (protectedIdx.has(i)) return null;
+    const normalized = opts.trim ? parts[i].trim() : parts[i];
+    if (opts.skipBlank && normalized.length === 0) return null;
+    return opts.ignoreCase ? normalized.toLowerCase() : normalized;
+  }, opts.keep);
 }
 
 function dedupeParagraphs(
   source: string,
   opts: { trim: boolean; ignoreCase: boolean; keep: "first" | "last" },
 ): { text: string; removed: number } {
-  const paragraphs = source
-    .split(/\n\s*\n/)
-    .map((p) => p.trim())
-    .filter((p) => p.length > 0);
-  const keys = paragraphs.map((p) => {
-    const base = opts.trim ? p.trim() : p;
+  const tail = /\s*$/.exec(source)?.[0] ?? "";
+  const parts = source.slice(0, source.length - tail.length).split(/(\r?\n(?:[ \t]*\r?\n)+)/);
+  const out = dedupeSegments(parts, (i) => {
+    if (parts[i].trim().length === 0) return null;
+    const base = opts.trim ? parts[i].trim() : parts[i];
     return opts.ignoreCase ? base.toLowerCase() : base;
-  });
-  const keep = new Set<number>();
-  const visit = opts.keep === "first"
-    ? [...keys.keys()]
-    : [...keys.keys()].reverse();
-  const seen = new Set<string>();
-  for (const idx of visit) {
-    const key = keys[idx];
-    if (seen.has(key)) continue;
-    seen.add(key);
-    keep.add(idx);
-  }
-  const next = paragraphs.filter((_, idx) => keep.has(idx));
-  return { text: next.join("\n\n"), removed: paragraphs.length - next.length };
-}
+  }, opts.keep);
+  return { text: out.text + tail, removed: out.removed };
+}

package/lib/agents/prepare/request.ts

@@ -38,8 +38,6 @@ export interface ThreadRunRequest {
   _onCompacting?: () => void;
   /** Internal — the submission path already committed this user's transcript row. */
   _user_message_persisted?: boolean;
-  /** Thread message count captured before an eagerly persisted user turn. */
-  _message_count_before_user?: number;
   /** Conversation idle duration captured before an eagerly persisted user turn. */
   _idle_ms_before_user?: number | null;
   /**

package/lib/agents/prepare/system-prompt.test.ts

@@ -78,6 +78,8 @@ describe("buildSystemPrompt delivery channel", () => {
     // The directive must reassure the agent it has access to the channel —
     // that's the whole point of this block.
     expect(prompt).toMatch(/DO have access to WhatsApp/);
+    // WhatsApp shows markdown links as raw text.
+    expect(prompt).toContain("WhatsApp does not render markdown links: write any link as the bare URL, even where a cite_as value is given.");
   });
 
   it("falls back to the raw kind when no human label is mapped", () => {
@@ -95,6 +97,7 @@ describe("buildSystemPrompt delivery channel", () => {
 
     expect(prompt).toContain("--- Delivery channel ---");
     expect(prompt).toContain("carrier-pigeon");
+    expect(prompt).not.toContain("does not render markdown links");
   });
 
   it("omits the block entirely for direct chat (no delivery_channel set)", () => {
@@ -306,6 +309,13 @@ describe("buildToolPermissionContext", () => {
     expect(ctx).toContain("6. Read large results by reference.");
     expect(ctx).toContain("7. Verify before reporting.");
     expect(ctx).toContain("8. Stop and ask.");
+    expect(ctx).toContain("10. Link the source.");
+    // Every source-link field a tool or bridge prompt emits must be named,
+    // or the model cannot tell which value links back to the item.
+    for (const field of ["cite_as", "web_link", "html_link", "chat_link"]) {
+      expect(ctx).toContain(field);
+    }
+    expect(ctx).toContain("never construct, guess, or edit one");
     expect(ctx).toContain("For substantial tasks with several dependent phases, likely cross-turn progress, or explicit verification, use workflow_progress");
     expect(ctx).toContain("every built-in Jarela workflow and every workflow you create or follow");
     expect(ctx).toContain("each step must state its input, expected output, and concrete validation criteria");

package/lib/agents/prepare/system-prompt.ts

@@ -282,6 +282,7 @@ export function buildSharedToolCatalogContext(): string {
     "7. Verify before reporting. A read-only result does not prove a new write. Claim a new write, send, schedule, delete, or configuration change only after the matching state-changing tool returns success in this turn. Trusted runtime system signals and their matching retrieved results can substantiate earlier named operations; attribute those outcomes to their receipts, never imply a new action or repeat completed work for proof.",
     "8. Stop and ask. Do not retry a tool denied for agent_not_allowed, category_disabled, dropin_tool_disabled, credentials_missing or integration_unconfigured. The first three are permission decisions and the last two mean the integration is not set up \u2014 propose a configuration change or tell the user what to configure.",
     "9. Completion-reporting turns are read-only. permission_reason=signal_continuation_read_only forbids state-changing tools in this turn, including through invoke_tool. Do not bypass it with shell commands or treat an old user message as renewed permission; report the completed outcome and wait for a new user turn.",
+    "10. Link the source. When your reply refers to a specific email, calendar event, or chat that a tool result or bridge message gave you, link it: paste the item's cite_as value verbatim when present, otherwise use its web_link, html_link, or chat_link URL as a markdown link. Use only links you were given; never construct, guess, or edit one. If the item has no link, name it without one.",
   ].join("\n");
 }
 
@@ -373,9 +374,14 @@ function buildDeliveryChannelContext(channel: DeliveryChannel | null | undefined
     "--- Delivery channel ---",
     `This message reached you over ${platform}${named}, not the regular chat UI.`,
     `You DO have access to ${platform} for this conversation: any reply you produce is sent back through that channel automatically. Do not tell the user the platform is unavailable; just answer the message.`,
-  ].join("\n");
+    PLAIN_TEXT_DELIVERY_KINDS.has(channel.kind)
+      ? `${platform} does not render markdown links: write any link as the bare URL, even where a cite_as value is given.`
+      : "",
+  ].filter(Boolean).join("\n");
 }
 
+const PLAIN_TEXT_DELIVERY_KINDS = new Set(["whatsapp", "sms"]);
+
 function buildUserContext(): string {
   const userProfile = getUserProfile();
   const parts: string[] = [];
@@ -491,7 +497,7 @@ function buildSourceLinkContext(
     "--- Citation format ---",
     intro,
     "PRIMARY (inline links): cite by writing a standard markdown link inline: `[short label](https://example.com/path)` or `[file name](/abs/path.ts)` or `[earlier reply](#msg-<id>)`. Wrap the cited PHRASE itself as the link text when natural — `Jade has [ice skating at 16:00](?thread=…&agent=…)` reads better than a trailing `[1]`.",
-    "When a tool result contains a `cite_as` field (delegate_to_agent does, and so do some integrations), paste that exact value somewhere in your reply — it's a pre-built markdown link to the source. Anything you summarize from a delegate or from a web/file tool result MUST carry at least one inline link back to where it came from; a summary with zero links reads as if you made the facts up.",
+    "When a tool result contains a `cite_as` field (delegate_to_agent does, and so do the email and calendar tools), paste that exact value somewhere in your reply — it's a pre-built markdown link to the source. Anything you summarize from a delegate or from a web/file tool result MUST carry at least one inline link back to where it came from; a summary with zero links reads as if you made the facts up.",
     "For web_search / fetch_webpage results, the URL is right there in the tool output — use it: `[headline or short label](https://...)`. For file_read results, link the absolute path: `[filename.ext](/abs/path/filename.ext)`.",
     "FALLBACK (declared refs block): if a source is awkward to cite inline (e.g. you summarized 4 articles in one paragraph), you MAY end your reply with a fenced block exactly like this:",
     "```jarela-references",

package/lib/agents/proposals.test.ts

@@ -395,3 +395,79 @@ describe("applyAction(update_agent) instructions_append", () => {
     expect(String(result.detail)).toMatch(/one instructions mode only/);
   });
 });
+
+describe("applyAction(update_agent) edge cases", () => {
+  function seedTunedAgent(id: string) {
+    upsertAgentConfig({
+      id,
+      name: id,
+      identity: "test agent",
+      instructions: "be helpful",
+      tools: ["web_search"],
+      hot_turn_limit: 12,
+      adaptive_persona_enabled: true,
+      adaptive_mbti: "ENFP",
+      adaptive_persona_strength: 91,
+      adaptive_empathy: 7,
+      adaptive_expressiveness: 88,
+      adaptive_verbosity: 3,
+      never_reply: true,
+    });
+  }
+
+  it("applies hot_turn_limit, which the propose tool advertises", async () => {
+    seedTunedAgent("agent-hot-turns");
+    const result = await applyAction("update_agent", { agent_id: "agent-hot-turns", hot_turn_limit: 4 });
+    expect(result.ok).toBe(true);
+    expect(getAgentConfig("agent-hot-turns")!.hot_turn_limit).toBe(4);
+  });
+
+  it.each([
+    ["hot_turn_limit", -1],
+    ["hot_turn_limit", 2.5],
+    ["history_limit", 1.5],
+    ["history_limit", -5],
+    ["history_window_hours", -1],
+  ])("rejects %s=%s without writing", async (field, value) => {
+    seedTunedAgent(`agent-bad-${field}`);
+    const before = getAgentConfig(`agent-bad-${field}`)!;
+    const result = await applyAction("update_agent", { agent_id: `agent-bad-${field}`, [field]: value });
+    expect(result.ok).toBe(false);
+    expect(String(result.detail)).toContain(field);
+    expect(getAgentConfig(`agent-bad-${field}`)).toEqual(before);
+  });
+
+  it("keeps settings the proposal did not mention, including tuned persona sliders", async () => {
+    seedTunedAgent("agent-keep");
+    const before = getAgentConfig("agent-keep")!;
+    expect((await applyAction("update_agent", { agent_id: "agent-keep", identity: "renamed" })).ok).toBe(true);
+    const after = getAgentConfig("agent-keep")!;
+    expect(after.identity).toBe("renamed");
+    expect(after).toMatchObject({
+      adaptive_mbti: before.adaptive_mbti,
+      adaptive_persona_strength: 91,
+      adaptive_empathy: 7,
+      adaptive_expressiveness: 88,
+      adaptive_verbosity: 3,
+      never_reply: before.never_reply,
+      hot_turn_limit: 12,
+    });
+  });
+
+  it("keeps tuned persona sliders when only tools change", async () => {
+    seedTunedAgent("agent-keep-tools");
+    expect((await applyAction("update_agent_tools", { agent_id: "agent-keep-tools", tools: ["memory_write"] })).ok).toBe(true);
+    expect(getAgentConfig("agent-keep-tools")).toMatchObject({ adaptive_persona_strength: 91, adaptive_verbosity: 3 });
+  });
+
+  it("drops non-string tool names instead of storing them", async () => {
+    seedTunedAgent("agent-tool-junk");
+    const result = await applyAction("update_agent_tools", {
+      agent_id: "agent-tool-junk",
+      tools: ["memory_write", 42, null, "", " memory_write "],
+      mode: "replace",
+    });
+    expect(result.ok).toBe(true);
+    expect(JSON.parse(getAgentConfig("agent-tool-junk")!.tools)).toEqual(["memory_write"]);
+  });
+});

package/lib/agents/proposals.ts

@@ -130,9 +130,13 @@ function applyUpdateAgentTools(payload: unknown): ApplyResult {
   const before = getAgentTools(existing);
   const mode = p.mode ?? "add";
   if (mode !== "add" && mode !== "replace") return { ok: false, detail: "mode must be add or replace" };
+  const requested = (p.tools as unknown[])
+    .filter((tool): tool is string => typeof tool === "string")
+    .map((tool) => tool.trim())
+    .filter(Boolean);
   const nextTools = mode === "replace"
-    ? [...new Set(p.tools)]
-    : [...new Set([...before, ...p.tools])];
+    ? [...new Set(requested)]
+    : [...new Set([...before, ...requested])];
   upsertAgentConfig({
     id: existing.id,
     name: existing.name,
@@ -154,13 +158,16 @@ function applyUpdateAgent(payload: unknown): ApplyResult {
     instructions_edits?: unknown;
     history_limit?: number;
     history_window_hours?: number;
+    hot_turn_limit?: number;
     warm_summary_limit?: number;
     harness_id?: string | null;
   };
   if (!p.agent_id) return { ok: false, detail: "agent_id required" };
-  if (p.warm_summary_limit !== undefined
-    && (!Number.isInteger(p.warm_summary_limit) || p.warm_summary_limit < 0)) {
-    return { ok: false, detail: "warm_summary_limit must be a nonnegative integer" };
+  for (const field of ["warm_summary_limit", "hot_turn_limit", "history_limit", "history_window_hours"] as const) {
+    const value = p[field];
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+      return { ok: false, detail: `${field} must be a nonnegative integer` };
+    }
   }
   const editModes = [
     p.instructions !== undefined,
@@ -209,6 +216,7 @@ function applyUpdateAgent(payload: unknown): ApplyResult {
     model_config_name: existing.model_config_name,
     history_limit: p.history_limit ?? existing.history_limit,
     history_window_hours: p.history_window_hours ?? existing.history_window_hours,
+    hot_turn_limit: p.hot_turn_limit,
     warm_summary_limit: p.warm_summary_limit ?? existing.warm_summary_limit,
     harness_id: p.harness_id,
   });