@circuitwall/jarela 2.3.0 → 2.4.0

package/.next/standalone/docs/adoption/changesets.json

@@ -304,6 +304,55 @@
           "required_removed": []
         }
       ]
+    },
+    {
+      "version": "2.4.0",
+      "previous_version": "2.3.0",
+      "date": "2026-10-16",
+      "hints": [
+        "If an agent's instructions or skills tell it not to include links or URLs in replies, decide whether it should now cite sources with the provided `cite_as` and chat links.",
+        "If you listed `localhost` or `127.0.0.1` in the proxy bypass list only to reach local services, you can remove them; loopback is always direct now."
+      ],
+      "commits": [
+        "fix(core): keep proxy loopback direct, unicode fact keys, agent tuning",
+        "fix(agents): avoid repeated compaction from bridge rows and topic pins",
+        "fix(core): keep per-chat backlog, permalink refs and code fences",
+        "fix(core): fix edge cases in edits, paging, bridges and pricing",
+        "feat(integrations): add source permalinks to mail, calendar, chats"
+      ],
+      "prompts": [
+        {
+          "id": "static.agent.tool-usage-sop",
+          "source": "lib/agents/prepare/system-prompt.ts",
+          "change": "changed",
+          "added_lines": [
+            "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 …"
+          ],
+          "removed_lines": [],
+          "omitted_lines": 0
+        },
+        {
+          "id": "system.Delivery channel",
+          "source": "lib/agents/prepare/system-prompt.ts",
+          "change": "changed",
+          "added_lines": [
+            "WhatsApp does not render markdown links: write any link as the bare URL, even where a cite_as value is given."
+          ],
+          "removed_lines": [],
+          "omitted_lines": 0
+        },
+        {
+          "id": "system.Tool usage SOP",
+          "source": "lib/agents/prepare/system-prompt.ts",
+          "change": "changed",
+          "added_lines": [
+            "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 …"
+          ],
+          "removed_lines": [],
+          "omitted_lines": 0
+        }
+      ],
+      "tools": []
     }
   ]
 }

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@circuitwall/jarela",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Jarela — local chat interface for LangGraph agents (multi-provider, single-process, SQLite-backed).",
   "license": "Apache-2.0",
   "author": "Andrew Ge Wu",

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-10-16
+
+### Added
+
+- **Link answers back to the source: Gmail, Outlook mail and calendar, and Google Calendar results carry a web link and a ready-made `cite_as` markdown link, and WhatsApp 1:1 bridge messages carry a `wa.me` chat link, so agents can point you at the exact email, event or chat. Group chats and single WhatsApp messages have no public link. Replies delivered to WhatsApp use bare URLs.**
+
+### Fixed
+
+- **Stop bridge-heavy threads from showing "Compacting" and running an empty compaction on every turn, and stop topic detection from re-running every turn after a hot-turn-limit pass.**
+- **Always send localhost traffic (Ollama, the WhatsApp bridge, Jarela's own API) directly when an HTTP proxy is configured, accept IPv6 proxy hosts, and reject manual proxy hosts that include a scheme, port, path or credentials.**
+- **Replay each WhatsApp chat's offline backlog separately so one active chat no longer causes others to lose messages, and keep known chat names when a contact sends a blank name.**
+- **Keep tuned persona sliders when an approved proposal or tool edit updates an agent, apply `hot_turn_limit` from proposals, reject negative or fractional limits, and drop blank or duplicate tool names.**
+- **Save facts about non-Latin subjects under their own memory keys instead of colliding, and stop replacing a fact from deleting an unrelated one.**
+- **Keep distinct Outlook and Gmail links as separate citations, keep closing code fences and horizontal rules when deduplicating instruction lines, and fix fuzzy edits on CRLF files and paged reads that split multi-byte characters.**
+
+### Adoption
+
+- If an agent's instructions or skills tell it not to include links or URLs in replies, decide whether it should now cite sources with the provided `cite_as` and chat links.
+- If you listed `localhost` or `127.0.0.1` in the proxy bypass list only to reach local services, you can remove them; loopback is always direct now.
 ## [2.3.0] - 2026-10-16
 
 ### Added

package/app/api/v1/threads/[thread_id]/run/route.ts

@@ -189,7 +189,6 @@ export async function POST(req: NextRequest, { params }: Params) {
           _pinned_model_config_name: pinnedModelConfigName,
           _onCompacting: () => broadcast(active, { type: "status", data: { phase: "compacting", label: "Compacting earlier messages…" } }),
           _user_message_persisted: true,
-          _message_count_before_user: admittedTurn.messageCountBefore,
           _idle_ms_before_user: admittedTurn.idleMsBefore,
         });
         prepDurationMs = Date.now() - prepStartedAt;

package/components/chat/MessageBubble.tsx

@@ -849,6 +849,18 @@ function BridgeMessageCard({ ctx, activity }: {
           {activity.occurrence_count > 1 ? ` · ${activity.occurrence_count} checks` : ""}
         </span>
       ) : null}
+      {ctx.chatLink ? (
+        <a
+          href={ctx.chatLink}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="inline-flex items-center gap-1 px-1.5 py-0.5 rounded-full bg-white/15 hover:bg-white/25 text-[9.5px] shrink-0"
+          title={`Open this chat (${ctx.chatLink})`}
+        >
+          <ExternalLink size={9} />
+          open chat
+        </a>
+      ) : null}
     </>
   );
   const sections: Array<{ label: string; content: ReactNode; defaultOpen?: boolean; hint?: string }> = [

package/components/integrations/NetworkSection.tsx

@@ -243,12 +243,12 @@ export function NetworkSection() {
             {mode !== "off" && (
               <>
                 <label className="block text-xs text-fg-subtle">
-                  No proxy (comma-separated, optional)
+                  No proxy (comma-separated, optional; localhost is always direct)
                   <input
                     type="text"
                     value={noProxy}
                     onChange={(e) => setNoProxy(e.target.value)}
-                    placeholder="localhost,127.0.0.1,.internal"
+                    placeholder=".internal,corp.example"
                     className="mt-1 w-full px-2 py-1.5 text-sm rounded border border-border bg-surface-3 text-fg font-mono"
                   />
                 </label>

package/lib/agents/citation-checker.test.ts

@@ -27,11 +27,27 @@ afterAll(() => {
 });
 
 describe("normalizeSource", () => {
-  it("lowercases + strips query/fragment + trailing slash on URLs", () => {
-    expect(normalizeSource("HTTPS://Example.com/Docs/?x=1#a")).toBe("https://example.com/docs");
+  it("lowercases + strips tracking params, page anchors and trailing slash on URLs", () => {
+    expect(normalizeSource("HTTPS://Example.com/Docs/?utm_source=x&fbclid=y#a")).toBe("https://example.com/docs");
     expect(normalizeSource("https://a.io/p/")).toBe("https://a.io/p");
   });
 
+  it("keeps the query and hash route that identify a message permalink", () => {
+    const a = normalizeSource("https://outlook.office365.com/owa/?ItemID=AAMk%2BA%3D&exvsurl=1&viewmodel=ReadMessageItem");
+    const b = normalizeSource("https://outlook.office365.com/owa/?ItemID=AAMk%2BB%3D&exvsurl=1&viewmodel=ReadMessageItem");
+    expect(a).not.toBe(b);
+    // Base64 item ids are case-sensitive; folding case would merge distinct messages.
+    expect(a).toContain("ItemID=AAMk%2BA%3D");
+    expect(normalizeSource("https://mail.google.com/mail/u/0/#all/18c2f0a1b2c3d4e5"))
+      .toBe("https://mail.google.com/mail/u/0#all/18c2f0a1b2c3d4e5");
+    expect(normalizeSource("https://www.youtube.com/watch?v=dQw4w9WgXcQ&utm_medium=share"))
+      .toBe("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
+  });
+
+  it("treats the same permalink with reordered params as one source", () => {
+    expect(normalizeSource("https://x.test/r?b=2&a=1")).toBe(normalizeSource("https://x.test/r?a=1&b=2&utm_campaign=z"));
+  });
+
   it("normalises backslashes and trailing slashes on paths", () => {
     expect(normalizeSource("docs\\Adr\\README.md")).toBe("docs/adr/readme.md");
     expect(normalizeSource("lib/agents/")).toBe("lib/agents");
@@ -137,6 +153,18 @@ describe("parseCitationVerdict", () => {
     expect(out).toEqual([{ text: "a", marker: null, link: null, verified: false, reason: "no link", impact: "med" }]);
   });
 
+  it("finds the verdict when the model wraps it in prose that also contains braces", () => {
+    const verdict = '{"claims":[{"text":"rate is 5%","marker":1,"verified":true,"reason":"in [1]","impact":"high"}]}';
+    const expected = [{ text: "rate is 5%", marker: 1, link: null, verified: true, reason: "in [1]", impact: "high" }];
+    expect(parseCitationVerdict(`Checked the {draft} reply. ${verdict}`)).toEqual(expected);
+    expect(parseCitationVerdict(`${verdict}\nNote: ignored the {code} block.`)).toEqual(expected);
+  });
+
+  it("keeps braces that belong to a claim string", () => {
+    const out = parseCitationVerdict('{"claims":[{"text":"set {a: 1} in config","verified":false,"reason":"} unmatched"}]}');
+    expect(out?.[0].text).toBe("set {a: 1} in config");
+    expect(out?.[0].reason).toBe("} unmatched");
+  });
   it("returns null on malformed JSON", () => {
     expect(parseCitationVerdict("{not json")).toBeNull();
   });
@@ -299,6 +327,16 @@ describe("mergeDeclaredReferences", () => {
     ]);
   });
 
+  it("keeps two declared emails that differ only by their permalink id", () => {
+    const out = mergeDeclaredReferences([], [
+      { label: "Invoice mail", href: "https://mail.google.com/mail/u/0/#all/18c2f0a1b2c3d4e5" },
+      { label: "Contract mail", href: "https://mail.google.com/mail/u/0/#all/18c2f0a1b2c3ffff" },
+      { label: "Board invite", href: "https://outlook.office365.com/owa/?ItemID=AAMk%2BA%3D&exvsurl=1" },
+      { label: "Offsite invite", href: "https://outlook.office365.com/owa/?ItemID=AAMk%2BB%3D&exvsurl=1" },
+    ]);
+    expect(out.map((e) => e.label)).toEqual(["Invoice mail", "Contract mail", "Board invite", "Offsite invite"]);
+  });
+
   it("returns a copy of the manifest unchanged when there are no declared refs", () => {
     const manifest = [{ n: 1, label: "x", href: "x" }];
     expect(mergeDeclaredReferences(manifest, [])).toEqual(manifest);

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",