From 60cb7f6dd18cd627b9de883cc162ad3c510cada5 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 00:33:16 -0400
Subject: [PATCH 01/10] feat: copy shareable thread links that paste as context
 cards

---
 .../src/lib/composerContextClipboard.test.ts  | 30 ++++++++
 .../src/lib/composerContextClipboard.ts       | 11 +--
 .../composerInlineTokenPaste.test.ts          | 67 ++++++++++++++++++
 .../components/composerInlineTokenPaste.ts    | 14 +++-
 .../promptLinks/HostedPromptLinkLanding.tsx   |  8 ++-
 docs/user/composer.md                         |  4 +-
 .../src/threadReference.test.ts               |  6 +-
 .../client-runtime/src/threadReference.ts     | 11 ++-
 packages/shared/package.json                  |  4 ++
 .../shared/src/composerContextClipboard.ts    | 51 ++++++++++++++
 packages/shared/src/promptLinks.test.ts       |  1 +
 packages/shared/src/promptLinks.ts            |  4 +-
 packages/shared/src/threadDeepLinks.test.ts   | 69 +++++++++++++++++++
 packages/shared/src/threadDeepLinks.ts        | 34 +++++++++
 14 files changed, 295 insertions(+), 19 deletions(-)
 create mode 100644 apps/web/src/components/composerInlineTokenPaste.test.ts
 create mode 100644 packages/shared/src/threadDeepLinks.test.ts
 create mode 100644 packages/shared/src/threadDeepLinks.ts

diff --git a/apps/mobile/src/lib/composerContextClipboard.test.ts b/apps/mobile/src/lib/composerContextClipboard.test.ts
index afabd7afb550c..72a4a970336ef 100644
--- a/apps/mobile/src/lib/composerContextClipboard.test.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.test.ts
@@ -331,3 +331,33 @@ describe("mobile context clipboard imports", () => {
     ).toEqual(result!.context.records.map((record) => record.contextId));
   });
 });
+
+describe("public thread URL paste", () => {
+  it("imports a plain link without rich clipboard metadata", async () => {
+    const result = await importComposerContextClipboard(
+      { text: "https://app.t3.codes/destination/local-thread", fragment: "", html: "" },
+      0,
+      new AbortController().signal,
+      0,
+      EnvironmentId.make("destination"),
+    );
+    expect(result?.context.records).toMatchObject([
+      { kind: "thread", environmentId: "destination", threadId: "local-thread" },
+    ]);
+    expect(collectComposerContextReferences(result!.text)).toHaveLength(1);
+  });
+  it("imports an app link from a machine the destination links to", async () => {
+    const result = await importComposerContextClipboard(
+      { text: "t3code://threads/source/foreign-thread", fragment: "", html: "" },
+      0,
+      new AbortController().signal,
+      0,
+      EnvironmentId.make("destination"),
+      new Map([[EnvironmentId.make("source"), "Source"]]),
+    );
+    expect(result?.context.records).toMatchObject([
+      { kind: "thread", environmentId: "source", threadId: "foreign-thread" },
+    ]);
+    expect(result?.skippedThreads).toEqual([]);
+  });
+});
diff --git a/apps/mobile/src/lib/composerContextClipboard.ts b/apps/mobile/src/lib/composerContextClipboard.ts
index e7c7201840569..f62b2998b8317 100644
--- a/apps/mobile/src/lib/composerContextClipboard.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.ts
@@ -10,6 +10,7 @@ import {
 } from "@t3tools/contracts";
 import {
   decodeComposerContextClipboardHtml,
+  normalizeThreadClipboard,
   decodeComposerContextFragment,
   encodeComposerContextFragment,
 } from "@t3tools/shared/composerContextClipboard";
@@ -70,11 +71,13 @@ export async function importComposerContextClipboard(
   /** The machines the destination links to, whose threads its agent can read too. */
   linkedEnvironments: ReadonlyMap<EnvironmentId, string> = new Map(),
 ) {
-  const fragment =
-    decodeComposerContextFragment(input.fragment) ?? decodeComposerContextClipboardHtml(input.html);
+  const { text, fragment } = normalizeThreadClipboard(
+    input.text,
+    decodeComposerContextFragment(input.fragment) ?? decodeComposerContextClipboardHtml(input.html),
+  );
   if (!fragment) return null;
-  const selected = referencedComposerContext(input.text, { version: 1, records: fragment.records });
-  const imported = reidentifyComposerContext(input.text, selected?.records ?? [], uuidv4);
+  const selected = referencedComposerContext(text, { version: 1, records: fragment.records });
+  const imported = reidentifyComposerContext(text, selected?.records ?? [], uuidv4);
   const skippedThreads =
     destinationEnvironmentId === undefined
       ? []
diff --git a/apps/web/src/components/composerInlineTokenPaste.test.ts b/apps/web/src/components/composerInlineTokenPaste.test.ts
new file mode 100644
index 0000000000000..91453d4cfdb0c
--- /dev/null
+++ b/apps/web/src/components/composerInlineTokenPaste.test.ts
@@ -0,0 +1,67 @@
+import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+import {
+  COMPOSER_CONTEXT_CLIPBOARD_MIME,
+  encodeComposerContextFragment,
+} from "@t3tools/shared/composerContextClipboard";
+import {
+  collectComposerContextReferences,
+  formatComposerContextReference,
+  threadContextRecord,
+} from "@t3tools/shared/composerContextReferences";
+import { threadDeepLink } from "@t3tools/shared/threadDeepLinks";
+import { importPastedComposerText, readPastedComposerContext } from "./composerInlineTokenPaste";
+const ref = { environmentId: EnvironmentId.make("env"), threadId: ThreadId.make("thread") };
+const record = threadContextRecord(ref, "Fix login");
+function clipboard(text: string, rich = false) {
+  return {
+    getData: (type: string) =>
+      type === "text/plain"
+        ? text
+        : rich && type === COMPOSER_CONTEXT_CLIPBOARD_MIME
+          ? encodeComposerContextFragment({
+              version: 1,
+              source: { environmentId: ref.environmentId },
+              records: [record],
+            })!
+          : "",
+  };
+}
+describe("pasted thread deep links", () => {
+  it("imports a copied thread card while the plain clipboard stays a public URL", () => {
+    const data = clipboard(threadDeepLink(ref), true);
+    const fragment = readPastedComposerContext(data)!;
+    expect(fragment.records).toEqual([record]);
+    const result = importPastedComposerText(
+      data,
+      (f) => new Map(f.records.map((r) => [r.contextId, r.contextId])),
+    );
+    expect(result).toBe(formatComposerContextReference(record));
+    expect(data.getData("text/plain")).toBe("https://app.t3.codes/env/thread");
+  });
+  it("imports public URLs after clipboard metadata has been stripped", () => {
+    const data = clipboard(threadDeepLink(ref));
+    const result = importPastedComposerText(
+      data,
+      (f) => new Map(f.records.map((r) => [r.contextId, "imported-thread"])),
+    );
+    expect(collectComposerContextReferences(result)).toMatchObject([
+      { contextId: "imported-thread", kind: "thread" },
+    ]);
+  });
+  it("keeps raw URLs when there is no importer or the machine cannot read the thread", () => {
+    const data = clipboard(threadDeepLink(ref));
+    expect(importPastedComposerText(data)).toBe(threadDeepLink(ref));
+    expect(importPastedComposerText(data, () => new Map())).toBe(threadDeepLink(ref));
+  });
+  it("preserves legacy context reference paste", () => {
+    const data = clipboard(formatComposerContextReference(record), true);
+    expect(readPastedComposerContext(data)?.records).toEqual([record]);
+    expect(
+      importPastedComposerText(
+        data,
+        (f) => new Map(f.records.map((r) => [r.contextId, r.contextId])),
+      ),
+    ).toBe(formatComposerContextReference(record));
+  });
+});
diff --git a/apps/web/src/components/composerInlineTokenPaste.ts b/apps/web/src/components/composerInlineTokenPaste.ts
index 32722ad6a9571..155c650bde779 100644
--- a/apps/web/src/components/composerInlineTokenPaste.ts
+++ b/apps/web/src/components/composerInlineTokenPaste.ts
@@ -1,6 +1,7 @@
 import { ComposerContextId } from "@t3tools/contracts";
 import type { ComposerContextClipboardFragment } from "@t3tools/contracts";
 import {
+  normalizeThreadClipboard,
   COMPOSER_CONTEXT_CLIPBOARD_MIME,
   decodeComposerContextFragment,
   decodeComposerContextClipboardHtml,
@@ -13,10 +14,14 @@ import {
 export function readPastedComposerContext(
   clipboardData: Pick<DataTransfer, "getData">,
 ): ComposerContextClipboardFragment | null {
-  const pastedText = clipboardData.getData("text/plain");
-  const decodedFragment =
+  const rawText = clipboardData.getData("text/plain");
+  const decoded =
     decodeComposerContextFragment(clipboardData.getData(COMPOSER_CONTEXT_CLIPBOARD_MIME)) ??
     decodeComposerContextClipboardHtml(clipboardData.getData("text/html"));
+  const { text: pastedText, fragment: decodedFragment } = normalizeThreadClipboard(
+    rawText,
+    decoded,
+  );
   if (decodedFragment === null) return null;
   const pastedIds = new Set<string>(
     collectComposerContextReferences(pastedText).map((occurrence) => occurrence.contextId),
@@ -43,10 +48,13 @@ export function importPastedComposerText(
     fragment: ComposerContextClipboardFragment,
   ) => ReadonlyMap<string, string>,
 ): string {
-  const pastedText = clipboardData.getData("text/plain");
+  const rawText = clipboardData.getData("text/plain");
   const fragment = importContextFragment ? readPastedComposerContext(clipboardData) : null;
   const rewrittenIds =
     fragment && fragment.records.length > 0 ? importContextFragment!(fragment) : null;
+  const pastedText = rewrittenIds
+    ? normalizeThreadClipboard(rawText, fragment, rewrittenIds).text
+    : rawText;
   const text =
     rewrittenIds && rewrittenIds.size > 0
       ? replaceComposerContextReferences(pastedText, (occurrence) => {
diff --git a/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx b/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
index 24facbea1911f..77c6d1f5c90ab 100644
--- a/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
+++ b/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
@@ -123,8 +123,12 @@ function HostedPromptLinkLanding({
   return (
     <StandalonePage>
       <StandalonePageHeader
-        title="Open this prompt"
-        description="It opens as a draft. Nothing runs until you press Send."
+        title={prompt === null ? "Open this thread" : "Open this prompt"}
+        description={
+          prompt === null
+            ? "Choose where to open your thread."
+            : "It opens as a draft. Nothing runs until you press Send."
+        }
       />
       {prompt !== null && prompt.hiddenCharacters > 0 ? (
         <Alert className="mt-5" variant="error">
diff --git a/docs/user/composer.md b/docs/user/composer.md
index 714572dfd5005..286bc1d952bbc 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -285,7 +285,9 @@ Another thread can be context too. Type `@` followed by part of its title to pic
 the same server, or from a machine it links to while the Linked environments beta is on; those
 show the machine's name. On web and desktop you can also drag a thread out of the sidebar and
 drop it on the composer; a multi-selection drops together. On any client, **Copy thread** puts a
-thread on the clipboard that pastes into a composer as its chip. The chip shows the thread's
+plain thread URL on the clipboard. Paste it into a composer to attach the thread as a chip, or
+share it elsewhere to open the thread in a browser, desktop, or mobile app. Opening the link
+requires access to the thread's environment. The chip shows the thread's
 current title and opens it when selected. Your prompt only carries a reference: the agent reads the thread's
 history on demand, so attaching a long thread costs nothing until the agent looks. Attaching a
 thread does not change it, and the agent cannot send messages to it unless you ask.
diff --git a/packages/client-runtime/src/threadReference.test.ts b/packages/client-runtime/src/threadReference.test.ts
index 9fa3245df5754..334303d61f60d 100644
--- a/packages/client-runtime/src/threadReference.test.ts
+++ b/packages/client-runtime/src/threadReference.test.ts
@@ -1,5 +1,6 @@
 import { EnvironmentId, ThreadId, type ThreadPullRequestLink } from "@t3tools/contracts";
 import {
+  normalizeThreadClipboard,
   decodeComposerContextFragment,
   encodeComposerContextFragment,
 } from "@t3tools/shared/composerContextClipboard";
@@ -82,6 +83,7 @@ describe("resolveThreadReferenceCopyTarget", () => {
 
     expect(target).toMatchObject({
       kind: "thread",
+      value: "https://app.t3.codes/env-1/thread-1",
       description: "Fix the login flow",
       successTitle: "Thread copied",
     });
@@ -99,7 +101,9 @@ describe("resolveThreadReferenceCopyTarget", () => {
       ],
     });
     // A paste keeps only the records its plain text references.
-    expect(collectComposerContextReferences(target!.value)).toEqual([
+    expect(
+      collectComposerContextReferences(normalizeThreadClipboard(target!.value, pasted).text),
+    ).toEqual([
       expect.objectContaining({
         kind: "thread",
         contextId: pasted!.records[0]!.contextId,
diff --git a/packages/client-runtime/src/threadReference.ts b/packages/client-runtime/src/threadReference.ts
index 94f68202a62cf..60c4cc8f94b78 100644
--- a/packages/client-runtime/src/threadReference.ts
+++ b/packages/client-runtime/src/threadReference.ts
@@ -3,16 +3,15 @@ import type {
   ScopedThreadRef,
   ThreadPullRequestLink,
 } from "@t3tools/contracts";
-import {
-  formatComposerContextReference,
-  threadContextRecord,
-} from "@t3tools/shared/composerContextReferences";
+import { threadContextRecord } from "@t3tools/shared/composerContextReferences";
+
+import { threadDeepLink } from "@t3tools/shared/threadDeepLinks";
 
 import { resolveThreadCurrentPullRequestLink } from "./threadPullRequests.ts";
 
 export interface ThreadReferenceCopyTarget {
   readonly kind: "pull-request" | "thread";
-  /** The plain text: a PR URL, or a thread chip's reference link. */
+  /** The plain text: a PR URL or a public thread deep link. */
   readonly value: string;
   /** What a toast or palette row shows for the copy. */
   readonly description: string;
@@ -31,7 +30,7 @@ export function threadChipCopyTarget(
   const record = threadContextRecord(threadRef, title);
   return {
     kind: "thread",
-    value: formatComposerContextReference(record),
+    value: threadDeepLink(threadRef),
     description: record.title,
     fragment: { version: 1, source: { environmentId: threadRef.environmentId }, records: [record] },
     clipboardTarget: "thread",
diff --git a/packages/shared/package.json b/packages/shared/package.json
index e3d0b2ce57cf7..94ac832151099 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -514,6 +514,10 @@
     "./cloneUrl": {
       "types": "./src/cloneUrl.ts",
       "import": "./src/cloneUrl.ts"
+    },
+    "./threadDeepLinks": {
+      "types": "./src/threadDeepLinks.ts",
+      "import": "./src/threadDeepLinks.ts"
     }
   },
   "scripts": {
diff --git a/packages/shared/src/composerContextClipboard.ts b/packages/shared/src/composerContextClipboard.ts
index 6036795a780cb..9411142cc7b13 100644
--- a/packages/shared/src/composerContextClipboard.ts
+++ b/packages/shared/src/composerContextClipboard.ts
@@ -5,8 +5,59 @@ import {
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 
+import {
+  formatComposerContextReference,
+  threadContextRecord,
+  toKindScopedComposerContextId,
+} from "./composerContextReferences.ts";
+import { parseThreadDeepLink } from "./threadDeepLinks.ts";
+
 export { COMPOSER_CONTEXT_CLIPBOARD_MIME };
 
+/** Normalize public URLs before filtering clipboard records, including plain-text-only pastes. */
+export function normalizeThreadClipboard(
+  text: string,
+  fragment: ComposerContextClipboardFragment | null,
+  acceptedIds?: ReadonlyMap<string, string>,
+) {
+  const records = [...(fragment?.records ?? [])];
+  let source = fragment?.source;
+  // Skip code spans/fences and consume Markdown links as a unit to avoid nesting references.
+  const normalized = text.replace(
+    /(`{3,}|~{3,})[\s\S]*?(?:\1|$)|(`+)[^\n]*?\2|\[([^\]\n]*)\]\((https:\/\/app\.t3\.codes\/[^\s)]+|t3code(?:-dev|-preview)?:\/\/threads\/[^\s)]+)\)|<?(?:https:\/\/app\.t3\.codes\/|t3code(?:-dev|-preview)?:\/\/threads\/)[^\s<>`]+>?/g,
+    (value, fence, span, label, href) => {
+      if (fence || span) return value;
+      const ref = parseThreadDeepLink(href ?? value.replace(/^<|>$/g, ""));
+      if (!ref) return value;
+      const existing = records.find(
+        (record) =>
+          record.kind === "thread" &&
+          !("payload" in record) &&
+          record.environmentId === ref.environmentId &&
+          record.threadId === ref.threadId,
+      );
+      let record = existing ?? threadContextRecord(ref, label || ref.threadId);
+      if (!existing && records.some((candidate) => candidate.contextId === record.contextId)) {
+        record = {
+          ...record,
+          contextId: toKindScopedComposerContextId(
+            "thread",
+            ref.environmentId + "/" + ref.threadId,
+          ),
+        };
+      }
+      if (acceptedIds && !acceptedIds.has(record.contextId)) return value;
+      if (!existing) records.push(record);
+      source ??= { environmentId: ref.environmentId };
+      return formatComposerContextReference(record);
+    },
+  );
+  return {
+    text: normalized,
+    fragment: source ? { version: 1 as const, source, records } : fragment,
+  };
+}
+
 const MAX_FRAGMENT_CHARS = 16_000_000;
 const decodeFragment = Schema.decodeUnknownOption(ComposerContextClipboardFragment);
 
diff --git a/packages/shared/src/promptLinks.test.ts b/packages/shared/src/promptLinks.test.ts
index afc5644f9ac3d..7530e626067d7 100644
--- a/packages/shared/src/promptLinks.test.ts
+++ b/packages/shared/src/promptLinks.test.ts
@@ -111,6 +111,7 @@ describe("link round trips", () => {
     expect(promptLinkAppPath("https://app.t3.codes/env-1/thread-1?prompt=go")).toBe(
       "/env-1/thread-1?prompt=go",
     );
+    expect(promptLinkAppPath("https://app.t3.codes/env-1/thread-1")).toBe("/env-1/thread-1");
     expect(promptLinkAppPath("https://app.t3.codes/settings/general")).toBeNull();
     expect(promptLinkAppPath("https://evil.test/new?prompt=hi")).toBeNull();
     expect(promptLinkAppPath("t3code://app/index.html")).toBeNull();
diff --git a/packages/shared/src/promptLinks.ts b/packages/shared/src/promptLinks.ts
index adff0135bfc02..8a24e77490037 100644
--- a/packages/shared/src/promptLinks.ts
+++ b/packages/shared/src/promptLinks.ts
@@ -182,7 +182,7 @@ export function buildNewThreadLink(input: {
 }
 
 const APP_SCHEME = /^t3code(?:-[a-z]+)?:$/;
-const THREAD_PATH = /^\/([^/]+)\/([^/]+)\/?$/;
+const THREAD_PATH = /^\/(?!settings\/|projects\/|draft\/)([^/]+)\/([^/]+)\/?$/;
 
 export function promptLinkAppPath(
   value: string,
@@ -199,7 +199,7 @@ export function promptLinkAppPath(
   }
   if (!URL.canParse(hostedAppUrl) || url.origin !== new URL(hostedAppUrl).origin) return null;
   if (url.pathname === "/new") return `/new${url.search}`;
-  const thread = url.searchParams.has("prompt") ? THREAD_PATH.exec(url.pathname) : null;
+  const thread = THREAD_PATH.exec(url.pathname);
   return thread ? `/${thread[1]}/${thread[2]}${url.search}` : null;
 }
 
diff --git a/packages/shared/src/threadDeepLinks.test.ts b/packages/shared/src/threadDeepLinks.test.ts
new file mode 100644
index 0000000000000..49713881e5d7e
--- /dev/null
+++ b/packages/shared/src/threadDeepLinks.test.ts
@@ -0,0 +1,69 @@
+import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+import { threadDeepLink, parseThreadDeepLink } from "./threadDeepLinks.ts";
+import { normalizeThreadClipboard } from "./composerContextClipboard.ts";
+import {
+  collectComposerContextReferences,
+  threadContextRecord,
+} from "./composerContextReferences.ts";
+const ref = { environmentId: EnvironmentId.make("env-1"), threadId: ThreadId.make("thread:1%2F") };
+
+describe("public thread links", () => {
+  it("round-trips encoded ids without losing literal escapes", () => {
+    expect(parseThreadDeepLink(threadDeepLink(ref))).toEqual(ref);
+    expect(parseThreadDeepLink("t3code://threads/env-1/thread%3A1%252F")).toEqual(ref);
+  });
+  it.each([
+    "https://evil.test/env/thread",
+    "https://app.t3.codes/settings/general",
+    "https://app.t3.codes/projects/p",
+    "https://app.t3.codes/draft/d",
+    "t3code://threads/env/thread?token=secret",
+    "https://app.t3.codes/env/%ZZ",
+  ])("ignores unrelated or malformed URLs: %s", (value) => {
+    expect(parseThreadDeepLink(value)).toBeNull();
+  });
+  it("turns plain URLs into cards without clipboard metadata", () => {
+    const result = normalizeThreadClipboard("See " + threadDeepLink(ref), null);
+    expect(result.fragment?.records).toEqual([threadContextRecord(ref, ref.threadId)]);
+    expect(collectComposerContextReferences(result.text)).toHaveLength(1);
+  });
+  it("keeps copied titles and deduplicates repeated links", () => {
+    const record = threadContextRecord(ref, "Fix login");
+    const result = normalizeThreadClipboard(threadDeepLink(ref) + " " + threadDeepLink(ref), {
+      version: 1,
+      source: { environmentId: ref.environmentId },
+      records: [record],
+    });
+    expect(result.fragment?.records).toEqual([record]);
+    expect(collectComposerContextReferences(result.text).map((r) => r.label)).toEqual([
+      "Fix login",
+      "Fix login",
+    ]);
+  });
+  it("leaves code examples literal and supports app links and Markdown wrappers", () => {
+    const value = threadDeepLink(ref);
+    const result = normalizeThreadClipboard(
+      "`" + value + "` [Work](" + value + ") <t3code://threads/env-2/thread-2>",
+      null,
+    );
+    expect(result.text.startsWith("`" + value + "`")).toBe(true);
+    expect(collectComposerContextReferences(result.text).map((r) => r.label)).toEqual([
+      "Work",
+      "thread-2",
+    ]);
+  });
+});
+
+it("keeps identical thread ids on different machines distinct", () => {
+  const result = normalizeThreadClipboard(
+    "https://app.t3.codes/one/thread https://app.t3.codes/two/thread",
+    null,
+  );
+  const records = result.fragment!.records;
+  expect(records).toHaveLength(2);
+  expect(new Set(records.map((record) => record.contextId)).size).toBe(2);
+  expect(collectComposerContextReferences(result.text).map((record) => record.contextId)).toEqual(
+    records.map((record) => record.contextId),
+  );
+});
diff --git a/packages/shared/src/threadDeepLinks.ts b/packages/shared/src/threadDeepLinks.ts
new file mode 100644
index 0000000000000..7cf3358f5cdf6
--- /dev/null
+++ b/packages/shared/src/threadDeepLinks.ts
@@ -0,0 +1,34 @@
+import { EnvironmentId, ThreadId, type ScopedThreadRef } from "@t3tools/contracts";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { DEFAULT_HOSTED_APP_URL } from "./connectAuth.ts";
+
+const decodeEnvironmentId = Schema.decodeOption(EnvironmentId);
+const decodeThreadId = Schema.decodeOption(ThreadId);
+
+export function threadDeepLink(ref: ScopedThreadRef): string {
+  return new URL(
+    `/${encodeURIComponent(ref.environmentId)}/${encodeURIComponent(ref.threadId)}`,
+    DEFAULT_HOSTED_APP_URL,
+  ).href;
+}
+
+/** Public thread addresses carry identity only; connecting still requires authorization. */
+export function parseThreadDeepLink(value: string): ScopedThreadRef | null {
+  try {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash) return null;
+    const web = url.origin === DEFAULT_HOSTED_APP_URL;
+    const app =
+      ["t3code:", "t3code-dev:", "t3code-preview:"].includes(url.protocol) &&
+      url.host === "threads";
+    if (!web && !app) return null;
+    const match = /^\/(?!settings\/|projects\/|draft\/)([^/]+)\/([^/]+)\/?$/.exec(url.pathname);
+    if (!match) return null;
+    const environmentId = Option.getOrNull(decodeEnvironmentId(decodeURIComponent(match[1]!)));
+    const threadId = Option.getOrNull(decodeThreadId(decodeURIComponent(match[2]!)));
+    return environmentId === null || threadId === null ? null : { environmentId, threadId };
+  } catch {
+    return null;
+  }
+}

From cbb60412fd1920257a55ea40ac4aea68a52a6f96 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 01:18:10 -0400
Subject: [PATCH 02/10] fix: address thread deep-link review across client
 paste paths

---
 .../t3composereditor/T3ComposerEditorView.kt  |  9 +++
 .../t3composereditor/ComposerPasteTest.kt     | 25 ++++++++
 .../ios/T3ComposerEditorView.swift            |  5 +-
 .../src/lib/composerContextClipboard.test.ts  | 13 ++++
 .../src/lib/composerContextClipboard.ts       | 19 +++++-
 apps/mobile/src/lib/copyThreadReference.ts    | 15 +----
 apps/web/src/components/chat/ChatComposer.tsx |  4 +-
 .../chat/useComposerContextImport.ts          |  1 +
 .../composerInlineTokenPaste.test.ts          | 13 +++-
 .../components/composerInlineTokenPaste.ts    | 11 ++++
 .../desktop/DesktopWebLinkCoordinator.tsx     | 19 +++++-
 .../promptLinks/HostedPromptLinkLanding.tsx   |  9 +++
 .../promptLinks/hostedThreadLink.test.ts      | 19 ++++++
 .../promptLinks/hostedThreadLink.ts           | 12 ++++
 apps/web/src/lib/copyThreadReference.ts       | 12 +---
 .../src/threadReference.test.ts               | 33 ++--------
 .../client-runtime/src/threadReference.ts     |  9 +--
 .../shared/src/composerContextClipboard.ts    | 61 ++++++++++++-------
 packages/shared/src/promptLinks.ts            | 10 +--
 packages/shared/src/threadDeepLinks.test.ts   | 31 ++++++++++
 packages/shared/src/threadDeepLinks.ts        | 24 ++++++--
 21 files changed, 254 insertions(+), 100 deletions(-)
 create mode 100644 apps/web/src/components/promptLinks/hostedThreadLink.test.ts
 create mode 100644 apps/web/src/components/promptLinks/hostedThreadLink.ts

diff --git a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
index ecc37df17c993..58432aedb346b 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
@@ -701,6 +701,15 @@ internal class SelectionAwareEditText(context: Context) : EditText(context) {
       pasteContextListener?.invoke(payload)
       return true
     }
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
+    val clip = clipboard?.primaryClip
+    val plainText = clip?.plainText()
+    if (plainText != null && (plainText.contains("app.t3.codes/") || plainText.contains("://threads/"))) {
+      if (!pasteInterceptedText(clip)) {
+        pasteContextListener?.invoke(payload + ("text" to plainText))
+      }
+      return true
+    }
     return pasteImagesOrInterceptedText()
   }
 
diff --git a/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt b/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
index ca15fb2b1ba19..fc7ac85e276c0 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
@@ -169,4 +169,29 @@ class ComposerPasteTest {
     assertEquals("unchanged", editor.text.toString())
     assertNull(intercepted)
   }
+
+  @Test
+  fun regularPasteSendsPlainThreadUrlsToTheContextImporter() {
+    for (url in listOf("https://app.t3.codes/environment/thread", "t3code://threads/environment/thread")) {
+      clipboard.setPrimaryClip(ClipData.newPlainText("test", url))
+      editor.setText("before")
+      editor.setSelection(6)
+      var payload: Map<String, String>? = null
+      editor.pasteContextListener = { payload = it }
+      assertTrue(editor.onTextContextMenuItem(android.R.id.paste))
+      assertEquals(url, payload?.get("text"))
+      assertEquals("before", editor.text.toString())
+    }
+  }
+
+  @Test
+  fun incidentalThreadUrlsDoNotBypassLargeTextFolding() {
+    val text = "log line\n".repeat(5000) + "https://app.t3.codes/environment/thread"
+    clipboard.setPrimaryClip(ClipData.newPlainText("test", text))
+    editor.pasteContextListener = { error("Large logs must use the text folding path") }
+    var intercepted: String? = null
+    editor.pasteTextListener = { value, _, _ -> intercepted = value }
+    assertTrue(editor.onTextContextMenuItem(android.R.id.paste))
+    assertEquals(text, intercepted)
+  }
 }
diff --git a/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift b/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift
index f54f75caf5f50..8aca4ee96bbe7 100644
--- a/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift
+++ b/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift
@@ -201,7 +201,10 @@ private final class ComposerTextView: UITextView {
     }
     let pasteboard = UIPasteboard.general
     let context = T3ComposerClipboard.read()
-    if !context["fragment", default: ""].isEmpty || context["html", default: ""].contains("data-t3-context-fragment=") {
+    let text = context["text", default: ""]
+    let hasThreadLink = text.contains("app.t3.codes/") || text.contains("://threads/")
+    if !context["fragment", default: ""].isEmpty || context["html", default: ""].contains("data-t3-context-fragment=") ||
+       (!pasteboard.hasImages && !bypassTextPasteInterception && hasThreadLink && !shouldInterceptTextPaste(text)) {
       onPasteContext?(context)
       return
     }
diff --git a/apps/mobile/src/lib/composerContextClipboard.test.ts b/apps/mobile/src/lib/composerContextClipboard.test.ts
index 72a4a970336ef..4f0db7c9e9e02 100644
--- a/apps/mobile/src/lib/composerContextClipboard.test.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.test.ts
@@ -361,3 +361,16 @@ describe("public thread URL paste", () => {
     expect(result?.skippedThreads).toEqual([]);
   });
 });
+
+it("preserves a public URL when the destination cannot read its environment", async () => {
+  const text = "See https://app.t3.codes/unknown/thread";
+  const result = await importComposerContextClipboard(
+    { text, fragment: "", html: "" },
+    0,
+    new AbortController().signal,
+    0,
+    EnvironmentId.make("destination"),
+  );
+  expect(result?.text).toBe(text);
+  expect(result?.context.records).toEqual([]);
+});
diff --git a/apps/mobile/src/lib/composerContextClipboard.ts b/apps/mobile/src/lib/composerContextClipboard.ts
index f62b2998b8317..5f37779e82bc7 100644
--- a/apps/mobile/src/lib/composerContextClipboard.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.ts
@@ -71,11 +71,28 @@ export async function importComposerContextClipboard(
   /** The machines the destination links to, whose threads its agent can read too. */
   linkedEnvironments: ReadonlyMap<EnvironmentId, string> = new Map(),
 ) {
-  const { text, fragment } = normalizeThreadClipboard(
+  const normalized = normalizeThreadClipboard(
     input.text,
     decodeComposerContextFragment(input.fragment) ?? decodeComposerContextClipboardHtml(input.html),
   );
+  const fragment = normalized.fragment;
   if (!fragment) return null;
+  const outside =
+    destinationEnvironmentId === undefined
+      ? []
+      : threadContextsOutsideEnvironment({
+          text: normalized.text,
+          records: fragment.records,
+          environmentId: destinationEnvironmentId,
+          linkedEnvironments,
+        });
+  const outsideIds = new Set(outside.map((record) => record.contextId));
+  const accepted = new Map(
+    fragment.records
+      .filter((record) => !outsideIds.has(record.contextId))
+      .map((record) => [record.contextId, record.contextId]),
+  );
+  const text = normalizeThreadClipboard(input.text, fragment, accepted).text;
   const selected = referencedComposerContext(text, { version: 1, records: fragment.records });
   const imported = reidentifyComposerContext(text, selected?.records ?? [], uuidv4);
   const skippedThreads =
diff --git a/apps/mobile/src/lib/copyThreadReference.ts b/apps/mobile/src/lib/copyThreadReference.ts
index f3921fb2605a7..35ba714b9721f 100644
--- a/apps/mobile/src/lib/copyThreadReference.ts
+++ b/apps/mobile/src/lib/copyThreadReference.ts
@@ -1,19 +1,6 @@
 import type { ThreadReferenceCopyTarget } from "@t3tools/client-runtime/thread-reference";
-import * as Haptics from "expo-haptics";
-
-import { writeComposerContextClipboard } from "./composerContextClipboard";
 import { tryCopyTextWithHaptic } from "./copyTextWithHaptic";
 
-/** Resolves false, after logging why, when the clipboard write fails. */
 export async function copyThreadReference(target: ThreadReferenceCopyTarget): Promise<boolean> {
-  if (!target.fragment)
-    return tryCopyTextWithHaptic(target.value, { target: target.clipboardTarget });
-  try {
-    await writeComposerContextClipboard(target.value, target.fragment);
-  } catch (error) {
-    console.error(`Failed to copy ${target.clipboardTarget} to the clipboard.`, error);
-    return false;
-  }
-  void Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light).catch(() => {});
-  return true;
+  return tryCopyTextWithHaptic(target.value, { target: target.clipboardTarget });
 }
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index c4963ad73ba3a..bf594eac3deaf 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -9,7 +9,7 @@ import {
 import { isLocalEnvironmentDisabled } from "../../localEnvironment";
 import { usePrimaryEnvironmentId } from "../../state/environments";
 import { useRightPanelStore } from "~/rightPanelStore";
-import { importPastedComposerText, readPastedComposerContext } from "../composerInlineTokenPaste";
+import { importPastedComposerText, isComposerContextPaste } from "../composerInlineTokenPaste";
 import {
   questionAttachmentDraftId,
   trackOpenQuestionAttachmentDraft,
@@ -2503,7 +2503,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       return;
     }
 
-    if ((readPastedComposerContext(event.clipboardData)?.records.length ?? 0) > 0) return;
+    if (isComposerContextPaste(event.clipboardData)) return;
     if (!foldPastedText(plainText, bypassAutoAttachment)) {
       return;
     }
diff --git a/apps/web/src/components/chat/useComposerContextImport.ts b/apps/web/src/components/chat/useComposerContextImport.ts
index 74e97a5076d7d..de56d0bd530e3 100644
--- a/apps/web/src/components/chat/useComposerContextImport.ts
+++ b/apps/web/src/components/chat/useComposerContextImport.ts
@@ -350,6 +350,7 @@ export function useComposerContextImport(input: {
         if (record.kind === "preview-annotation" && record.screenshotContextId) {
           skippedDependentAttachmentIds.add(record.screenshotContextId);
         }
+        if (record.kind === "thread") rewritten.set(record.contextId, record.contextId);
         continue;
       }
       const conflicts = existing !== undefined;
diff --git a/apps/web/src/components/composerInlineTokenPaste.test.ts b/apps/web/src/components/composerInlineTokenPaste.test.ts
index 91453d4cfdb0c..16ea3df49872a 100644
--- a/apps/web/src/components/composerInlineTokenPaste.test.ts
+++ b/apps/web/src/components/composerInlineTokenPaste.test.ts
@@ -10,7 +10,11 @@ import {
   threadContextRecord,
 } from "@t3tools/shared/composerContextReferences";
 import { threadDeepLink } from "@t3tools/shared/threadDeepLinks";
-import { importPastedComposerText, readPastedComposerContext } from "./composerInlineTokenPaste";
+import {
+  importPastedComposerText,
+  readPastedComposerContext,
+  isComposerContextPaste,
+} from "./composerInlineTokenPaste";
 const ref = { environmentId: EnvironmentId.make("env"), threadId: ThreadId.make("thread") };
 const record = threadContextRecord(ref, "Fix login");
 function clipboard(text: string, rich = false) {
@@ -65,3 +69,10 @@ describe("pasted thread deep links", () => {
     ).toBe(formatComposerContextReference(record));
   });
 });
+
+it("allows large logs with an incidental thread URL to fold", () => {
+  expect(isComposerContextPaste(clipboard("log line\n".repeat(10000) + threadDeepLink(ref)))).toBe(
+    false,
+  );
+  expect(isComposerContextPaste(clipboard(threadDeepLink(ref)))).toBe(true);
+});
diff --git a/apps/web/src/components/composerInlineTokenPaste.ts b/apps/web/src/components/composerInlineTokenPaste.ts
index 155c650bde779..c3bf3f489a2af 100644
--- a/apps/web/src/components/composerInlineTokenPaste.ts
+++ b/apps/web/src/components/composerInlineTokenPaste.ts
@@ -1,3 +1,4 @@
+import { parseThreadDeepLink } from "@t3tools/shared/threadDeepLinks";
 import { ComposerContextId } from "@t3tools/contracts";
 import type { ComposerContextClipboardFragment } from "@t3tools/contracts";
 import {
@@ -70,3 +71,13 @@ export function importPastedComposerText(
       : pastedText;
   return text;
 }
+
+export function isComposerContextPaste(clipboardData: Pick<DataTransfer, "getData">): boolean {
+  if (
+    decodeComposerContextFragment(clipboardData.getData(COMPOSER_CONTEXT_CLIPBOARD_MIME)) ||
+    decodeComposerContextClipboardHtml(clipboardData.getData("text/html"))
+  )
+    return true;
+  const text = clipboardData.getData("text/plain").trim();
+  return text.length > 0 && text.split(/\s+/).every((value) => parseThreadDeepLink(value) !== null);
+}
diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
index ddd892d02bd12..3e3889b6b6ead 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
@@ -5,6 +5,7 @@ import {
 } from "@t3tools/client-runtime/state/runtime";
 import type { EnvironmentId, ScopedThreadRef } from "@t3tools/contracts";
 import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
+import { parseThreadDeepLink, threadDeepLink } from "@t3tools/shared/threadDeepLinks";
 import { promptLinkAppPath } from "@t3tools/shared/promptLinks";
 import { readPairingAppLink, resolveRemotePairingTarget } from "@t3tools/shared/remote";
 import { useRouter } from "@tanstack/react-router";
@@ -28,7 +29,11 @@ import { appAtomRegistry } from "../../rpc/atomRegistry";
 import { resolveThreadRouteTarget } from "../../threadRoutes";
 import { assetEnvironment } from "../../state/assets";
 import { readProject, readThreadShell } from "../../state/entities";
-import { useEnvironmentHttpBaseUrl, usePrimaryEnvironment } from "../../state/environments";
+import {
+  useEnvironments,
+  useEnvironmentHttpBaseUrl,
+  usePrimaryEnvironment,
+} from "../../state/environments";
 import { previewEnvironment } from "../../state/preview";
 import { allReachableShellsLiveAtom } from "../../state/shell";
 import { useAtomCommand } from "../../state/use-atom-command";
@@ -81,6 +86,7 @@ function threadShowingBrowser(
 export function DesktopWebLinkCoordinator() {
   const router = useRouter();
   const primaryEnvironment = usePrimaryEnvironment();
+  const { environments } = useEnvironments();
   const openPullRequestsInApp = useClientSettings((settings) => settings.pullRequestLinksOpenInApp);
   const openChangeRequest = useOpenChangeRequestLink();
   const { scratchEnvironmentId, openScratchProject } = useScratchProject();
@@ -207,10 +213,19 @@ export function DesktopWebLinkCoordinator() {
       return;
     }
     const appPath = promptLinkAppPath(url);
-    if (appPath !== null) {
+    const bareThread = parseThreadDeepLink(url);
+    if (
+      appPath !== null &&
+      (bareThread === null ||
+        environments.some((e) => e.environmentId === bareThread.environmentId))
+    ) {
       await router.navigate({ href: appPath });
       return;
     }
+    if (bareThread !== null) {
+      await openInBrowser(threadDeepLink(bareThread));
+      return;
+    }
     const routeParams = router.state.matches.at(-1)?.params ?? {};
     const routeTarget = resolveThreadRouteTarget(routeParams);
     const activeThreadRef = routeTarget?.kind === "server" ? routeTarget.threadRef : undefined;
diff --git a/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx b/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
index 77c6d1f5c90ab..5ada3f3120dca 100644
--- a/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
+++ b/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
@@ -19,6 +19,8 @@ import { Button } from "../ui/button";
 import { Checkbox } from "../ui/checkbox";
 import { StandalonePage, StandalonePageHeader } from "../ui/standalone-page";
 
+import { hostedThreadLinkAction } from "./hostedThreadLink";
+
 const OPENER_STORAGE_KEY = "t3code:prompt-link-opener";
 const Opener = Schema.NullOr(Schema.Literals(["app", "browser"]));
 
@@ -69,6 +71,13 @@ export function useHostedPromptLinkLanding(enabled: boolean): ReactNode | null {
       ? promptLinkAppPath(new URL(href, window.location.origin).href, window.location.origin)
       : null;
   if (appPath === null || continuedHref === href) return null;
+  const threadAction = hostedThreadLinkAction(
+    appPath,
+    isReady,
+    environments.map((e) => e.environmentId),
+  );
+  if (threadAction === "wait") return <></>;
+  if (threadAction === "continue") return null;
   const canContinue = isReady && environments.length > 0;
   if (opener === "browser") {
     if (canContinue) return null;
diff --git a/apps/web/src/components/promptLinks/hostedThreadLink.test.ts b/apps/web/src/components/promptLinks/hostedThreadLink.test.ts
new file mode 100644
index 0000000000000..f32da19efd6f2
--- /dev/null
+++ b/apps/web/src/components/promptLinks/hostedThreadLink.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vite-plus/test";
+import { hostedThreadLinkAction } from "./hostedThreadLink";
+describe("bare hosted thread navigation", () => {
+  it("waits for environment discovery on refresh", () => {
+    expect(hostedThreadLinkAction("/env/thread", false, [])).toBe("wait");
+  });
+  it.each(["/env/first", "/env/second"])(
+    "keeps connected sidebar navigation and refresh in the browser: %s",
+    (path) => {
+      expect(hostedThreadLinkAction(path, true, ["env"])).toBe("continue");
+    },
+  );
+  it("offers the opener for an unknown environment", () => {
+    expect(hostedThreadLinkAction("/unknown/thread", true, ["env"])).toBe("choose");
+  });
+  it("keeps prompt links on the consent path", () => {
+    expect(hostedThreadLinkAction("/env/thread?prompt=go", true, ["env"])).toBe("choose");
+  });
+});
diff --git a/apps/web/src/components/promptLinks/hostedThreadLink.ts b/apps/web/src/components/promptLinks/hostedThreadLink.ts
new file mode 100644
index 0000000000000..2379f23f98981
--- /dev/null
+++ b/apps/web/src/components/promptLinks/hostedThreadLink.ts
@@ -0,0 +1,12 @@
+import { parseThreadPath } from "@t3tools/shared/threadDeepLinks";
+export function hostedThreadLinkAction(
+  appPath: string,
+  ready: boolean,
+  environmentIds: ReadonlyArray<string>,
+) {
+  const url = new URL(appPath, "https://app.invalid");
+  const ref = parseThreadPath(url.pathname);
+  if (!ref || url.searchParams.has("prompt")) return "choose";
+  if (!ready) return "wait";
+  return environmentIds.includes(ref.environmentId) ? "continue" : "choose";
+}
diff --git a/apps/web/src/lib/copyThreadReference.ts b/apps/web/src/lib/copyThreadReference.ts
index bbfa3b73a2c9c..3efbd1c1bd103 100644
--- a/apps/web/src/lib/copyThreadReference.ts
+++ b/apps/web/src/lib/copyThreadReference.ts
@@ -1,20 +1,10 @@
 import type { ThreadReferenceCopyTarget } from "@t3tools/client-runtime/thread-reference";
-import {
-  COMPOSER_CONTEXT_CLIPBOARD_MIME,
-  encodeComposerContextFragment,
-} from "@t3tools/shared/composerContextClipboard";
-
 import { stackedThreadToast, toastManager } from "../components/ui/toast";
 import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
 
 export async function copyThreadReference(target: ThreadReferenceCopyTarget): Promise<void> {
-  const fragment = target.fragment ? encodeComposerContextFragment(target.fragment) : null;
   try {
-    const didCopy = await writeTextToClipboard(
-      target.value,
-      target.clipboardTarget,
-      fragment ? { [COMPOSER_CONTEXT_CLIPBOARD_MIME]: fragment } : undefined,
-    );
+    const didCopy = await writeTextToClipboard(target.value, target.clipboardTarget);
     if (!didCopy) return;
     toastManager.add({
       type: "success",
diff --git a/packages/client-runtime/src/threadReference.test.ts b/packages/client-runtime/src/threadReference.test.ts
index 334303d61f60d..99a45a149c949 100644
--- a/packages/client-runtime/src/threadReference.test.ts
+++ b/packages/client-runtime/src/threadReference.test.ts
@@ -1,9 +1,5 @@
 import { EnvironmentId, ThreadId, type ThreadPullRequestLink } from "@t3tools/contracts";
-import {
-  normalizeThreadClipboard,
-  decodeComposerContextFragment,
-  encodeComposerContextFragment,
-} from "@t3tools/shared/composerContextClipboard";
+import { normalizeThreadClipboard } from "@t3tools/shared/composerContextClipboard";
 import { collectComposerContextReferences } from "@t3tools/shared/composerContextReferences";
 import { describe, expect, it } from "vite-plus/test";
 
@@ -87,28 +83,11 @@ describe("resolveThreadReferenceCopyTarget", () => {
       description: "Fix the login flow",
       successTitle: "Thread copied",
     });
-    const pasted = decodeComposerContextFragment(encodeComposerContextFragment(target!.fragment!));
-    expect(pasted).toEqual({
-      version: 1,
-      source: { environmentId: "env-1" },
-      records: [
-        expect.objectContaining({
-          kind: "thread",
-          environmentId: "env-1",
-          threadId: "thread-1",
-          title: "Fix the login flow",
-        }),
-      ],
-    });
-    // A paste keeps only the records its plain text references.
-    expect(
-      collectComposerContextReferences(normalizeThreadClipboard(target!.value, pasted).text),
-    ).toEqual([
-      expect.objectContaining({
-        kind: "thread",
-        contextId: pasted!.records[0]!.contextId,
-        label: "Fix the login flow",
-      }),
+    expect(target).not.toHaveProperty("fragment");
+    const pasted = normalizeThreadClipboard(target!.value, null);
+    expect(pasted.fragment?.records).toMatchObject([
+      { kind: "thread", environmentId: "env-1", threadId: "thread-1" },
     ]);
+    expect(collectComposerContextReferences(pasted.text)).toMatchObject([{ kind: "thread" }]);
   });
 });
diff --git a/packages/client-runtime/src/threadReference.ts b/packages/client-runtime/src/threadReference.ts
index 60c4cc8f94b78..3478ab13ba8fa 100644
--- a/packages/client-runtime/src/threadReference.ts
+++ b/packages/client-runtime/src/threadReference.ts
@@ -1,8 +1,4 @@
-import type {
-  ComposerContextClipboardFragment,
-  ScopedThreadRef,
-  ThreadPullRequestLink,
-} from "@t3tools/contracts";
+import type { ScopedThreadRef, ThreadPullRequestLink } from "@t3tools/contracts";
 import { threadContextRecord } from "@t3tools/shared/composerContextReferences";
 
 import { threadDeepLink } from "@t3tools/shared/threadDeepLinks";
@@ -15,8 +11,6 @@ export interface ThreadReferenceCopyTarget {
   readonly value: string;
   /** What a toast or palette row shows for the copy. */
   readonly description: string;
-  /** T3's clipboard format, which pastes a thread back into a composer as a chip. */
-  readonly fragment?: ComposerContextClipboardFragment;
   readonly clipboardTarget: string;
   readonly successTitle: string;
   readonly failureTitle: string;
@@ -32,7 +26,6 @@ export function threadChipCopyTarget(
     kind: "thread",
     value: threadDeepLink(threadRef),
     description: record.title,
-    fragment: { version: 1, source: { environmentId: threadRef.environmentId }, records: [record] },
     clipboardTarget: "thread",
     successTitle: "Thread copied",
     failureTitle: "Failed to copy thread",
diff --git a/packages/shared/src/composerContextClipboard.ts b/packages/shared/src/composerContextClipboard.ts
index 9411142cc7b13..2fcccf98ae8db 100644
--- a/packages/shared/src/composerContextClipboard.ts
+++ b/packages/shared/src/composerContextClipboard.ts
@@ -20,36 +20,51 @@ export function normalizeThreadClipboard(
   fragment: ComposerContextClipboardFragment | null,
   acceptedIds?: ReadonlyMap<string, string>,
 ) {
+  if (!text.includes("app.t3.codes/") && !text.includes("://threads/")) return { text, fragment };
   const records = [...(fragment?.records ?? [])];
+  const byThread = new Map(
+    records.flatMap((record) =>
+      record.kind === "thread" && !("payload" in record)
+        ? [[JSON.stringify([record.environmentId, record.threadId]), record] as const]
+        : [],
+    ),
+  );
+  const ids = new Set(records.map((record) => record.contextId));
   let source = fragment?.source;
-  // Skip code spans/fences and consume Markdown links as a unit to avoid nesting references.
+  // Consume code and every Markdown link as a unit; never rewrite a URL inside another link.
   const normalized = text.replace(
-    /(`{3,}|~{3,})[\s\S]*?(?:\1|$)|(`+)[^\n]*?\2|\[([^\]\n]*)\]\((https:\/\/app\.t3\.codes\/[^\s)]+|t3code(?:-dev|-preview)?:\/\/threads\/[^\s)]+)\)|<?(?:https:\/\/app\.t3\.codes\/|t3code(?:-dev|-preview)?:\/\/threads\/)[^\s<>`]+>?/g,
-    (value, fence, span, label, href) => {
-      if (fence || span) return value;
-      const ref = parseThreadDeepLink(href ?? value.replace(/^<|>$/g, ""));
+    /(?<fence>`{3,}|~{3,})[\s\S]*?(?:\k<fence>|$)|(?<span>`+)[^\n]*?\k<span>|!?\[(?<label>(?:\\.|[^\]\\\n]){0,512})\]\((?<href>[^\s)]{1,4096})\)|(?<![\w/:=?&.-])(?<bare><(?:https:\/\/app\.t3\.codes\/|t3code(?:-dev|-preview)?:\/\/threads\/)[^\s<>`]+>|(?:https:\/\/app\.t3\.codes\/|t3code(?:-dev|-preview)?:\/\/threads\/)[^\s<>`]+)/g,
+    (value, ...args) => {
+      const groups = args.at(-1) as {
+        fence?: string;
+        span?: string;
+        label?: string;
+        href?: string;
+        bare?: string;
+      };
+      if (groups.fence || groups.span || value.startsWith("![")) return value;
+      const candidate = groups.href ?? groups.bare;
+      if (!candidate) return value;
+      const punctuation =
+        groups.bare && !candidate.startsWith("<")
+          ? (candidate.match(/[.,;:!?)\]\x27\x22]+$/)?.[0] ?? "")
+          : "";
+      const address = punctuation ? candidate.slice(0, -punctuation.length) : candidate;
+      const ref = parseThreadDeepLink(address.replace(/^<|>$/g, ""));
       if (!ref) return value;
-      const existing = records.find(
-        (record) =>
-          record.kind === "thread" &&
-          !("payload" in record) &&
-          record.environmentId === ref.environmentId &&
-          record.threadId === ref.threadId,
-      );
-      let record = existing ?? threadContextRecord(ref, label || ref.threadId);
-      if (!existing && records.some((candidate) => candidate.contextId === record.contextId)) {
-        record = {
-          ...record,
-          contextId: toKindScopedComposerContextId(
-            "thread",
-            ref.environmentId + "/" + ref.threadId,
-          ),
-        };
+      const key = JSON.stringify([ref.environmentId, ref.threadId]);
+      let record = byThread.get(key);
+      if (!record) {
+        record = threadContextRecord(ref, groups.label || ref.threadId);
+        if (ids.has(record.contextId))
+          record = { ...record, contextId: toKindScopedComposerContextId("thread", key) };
+        records.push(record);
+        ids.add(record.contextId);
+        byThread.set(key, record);
       }
       if (acceptedIds && !acceptedIds.has(record.contextId)) return value;
-      if (!existing) records.push(record);
       source ??= { environmentId: ref.environmentId };
-      return formatComposerContextReference(record);
+      return formatComposerContextReference(record) + punctuation;
     },
   );
   return {
diff --git a/packages/shared/src/promptLinks.ts b/packages/shared/src/promptLinks.ts
index 8a24e77490037..0431dc66451f9 100644
--- a/packages/shared/src/promptLinks.ts
+++ b/packages/shared/src/promptLinks.ts
@@ -1,3 +1,4 @@
+import { parseThreadPath } from "./threadDeepLinks.ts";
 import { DEFAULT_HOSTED_APP_URL } from "./connectAuth.ts";
 
 export const PROMPT_LINK_MAX_PROMPT_LENGTH = 8_000;
@@ -182,7 +183,6 @@ export function buildNewThreadLink(input: {
 }
 
 const APP_SCHEME = /^t3code(?:-[a-z]+)?:$/;
-const THREAD_PATH = /^\/(?!settings\/|projects\/|draft\/)([^/]+)\/([^/]+)\/?$/;
 
 export function promptLinkAppPath(
   value: string,
@@ -194,13 +194,13 @@ export function promptLinkAppPath(
     if (url.host === "new" && (url.pathname === "" || url.pathname === "/")) {
       return `/new${url.search}`;
     }
-    const thread = url.host === "threads" ? THREAD_PATH.exec(url.pathname) : null;
-    return thread ? `/${thread[1]}/${thread[2]}${url.search}` : null;
+    const thread = url.host === "threads" ? parseThreadPath(url.pathname) : null;
+    return thread ? `${url.pathname.replace(/\/$/, "")}${url.search}` : null;
   }
   if (!URL.canParse(hostedAppUrl) || url.origin !== new URL(hostedAppUrl).origin) return null;
   if (url.pathname === "/new") return `/new${url.search}`;
-  const thread = THREAD_PATH.exec(url.pathname);
-  return thread ? `/${thread[1]}/${thread[2]}${url.search}` : null;
+  const thread = parseThreadPath(url.pathname);
+  return thread ? `${url.pathname.replace(/\/$/, "")}${url.search}` : null;
 }
 
 export function promptLinkDeepLink(appPath: string, scheme = "t3code"): string {
diff --git a/packages/shared/src/threadDeepLinks.test.ts b/packages/shared/src/threadDeepLinks.test.ts
index 49713881e5d7e..6e08b10aa554a 100644
--- a/packages/shared/src/threadDeepLinks.test.ts
+++ b/packages/shared/src/threadDeepLinks.test.ts
@@ -67,3 +67,34 @@ it("keeps identical thread ids on different machines distinct", () => {
     records.map((record) => record.contextId),
   );
 });
+
+it.each([
+  "See https://app.t3.codes/env/thread.",
+  "(https://app.t3.codes/env/thread)",
+  "https://app.t3.codes/env/thread, then",
+])("keeps punctuation outside thread IDs: %s", (text) => {
+  const result = normalizeThreadClipboard(text, null);
+  expect(result.fragment?.records).toMatchObject([{ threadId: "thread" }]);
+  expect(result.text.endsWith(text.endsWith("then") ? ", then" : text.slice(-1))).toBe(true);
+});
+it.each([
+  "https://example.com/?next=https://app.t3.codes/env/thread",
+  "[ https://app.t3.codes/env/thread ](https://example.com)",
+  "[Example](https://example.com/?next=https://app.t3.codes/env/thread)",
+])("leaves foreign URLs and Markdown labels intact: %s", (text) => {
+  expect(normalizeThreadClipboard(text, null)).toEqual({ text, fragment: null });
+});
+it.each([
+  "[".repeat(80000),
+  '[{"a":1},'.repeat(125000),
+  "[".repeat(80000) + " https://app.t3.codes/env/thread",
+])("handles large bracket-heavy pastes", (text) => {
+  const result = normalizeThreadClipboard(text, null);
+  expect(result.text.startsWith(text.slice(0, 80000))).toBe(true);
+});
+it.each(["/assets/index.js", "/.well-known/assetlinks.json", "/guest/x", "/new/x"])(
+  "rejects reserved web paths: %s",
+  (path) => {
+    expect(parseThreadDeepLink("https://app.t3.codes" + path)).toBeNull();
+  },
+);
diff --git a/packages/shared/src/threadDeepLinks.ts b/packages/shared/src/threadDeepLinks.ts
index 7cf3358f5cdf6..fce63a59167c7 100644
--- a/packages/shared/src/threadDeepLinks.ts
+++ b/packages/shared/src/threadDeepLinks.ts
@@ -13,6 +13,24 @@ export function threadDeepLink(ref: ScopedThreadRef): string {
   ).href;
 }
 
+export function parseThreadPath(pathname: string): ScopedThreadRef | null {
+  const match = /^\/([^/]+)\/([^/]+)\/?$/.exec(pathname);
+  if (!match) return null;
+  try {
+    const first = decodeURIComponent(match[1]!);
+    if (
+      first.startsWith(".") ||
+      ["settings", "projects", "draft", "assets", "guest", "new"].includes(first)
+    )
+      return null;
+    const environmentId = Option.getOrNull(decodeEnvironmentId(first));
+    const threadId = Option.getOrNull(decodeThreadId(decodeURIComponent(match[2]!)));
+    return environmentId === null || threadId === null ? null : { environmentId, threadId };
+  } catch {
+    return null;
+  }
+}
+
 /** Public thread addresses carry identity only; connecting still requires authorization. */
 export function parseThreadDeepLink(value: string): ScopedThreadRef | null {
   try {
@@ -23,11 +41,7 @@ export function parseThreadDeepLink(value: string): ScopedThreadRef | null {
       ["t3code:", "t3code-dev:", "t3code-preview:"].includes(url.protocol) &&
       url.host === "threads";
     if (!web && !app) return null;
-    const match = /^\/(?!settings\/|projects\/|draft\/)([^/]+)\/([^/]+)\/?$/.exec(url.pathname);
-    if (!match) return null;
-    const environmentId = Option.getOrNull(decodeEnvironmentId(decodeURIComponent(match[1]!)));
-    const threadId = Option.getOrNull(decodeThreadId(decodeURIComponent(match[2]!)));
-    return environmentId === null || threadId === null ? null : { environmentId, threadId };
+    return parseThreadPath(url.pathname);
   } catch {
     return null;
   }

From 981b850102e5123334ea5dcf60404627a39a9b33 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 09:25:18 -0400
Subject: [PATCH 03/10] fix(desktop): keep startup thread links queued until
 catalog loads

---
 ...DesktopWebLinkCoordinator.browser.test.tsx | 44 ++++++++++++++++++-
 .../desktop/DesktopWebLinkCoordinator.tsx     |  6 ++-
 2 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
index 31ad2028c5f51..51f20679c3b0d 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
@@ -16,6 +16,8 @@ const state = vi.hoisted(() => ({
   confirm: vi.fn(async (_message: string) => true),
   connectPairing: vi.fn(async (_input: { pairingUrl: string }) => ({ _tag: "Success" })),
   localEnvironmentDisabled: false,
+  catalogReady: true,
+  environmentIds: ["local"] as string[],
 }));
 
 // One connected primary environment that can read pull requests. Its project list and
@@ -31,6 +33,10 @@ vi.mock(import("@tanstack/react-router"), async (original) => ({
 vi.mock(import("../../state/environments"), async (original) => ({
   ...(await original()),
   usePrimaryEnvironmentId: () => "local" as EnvironmentId,
+  useEnvironments: (() => ({
+    isReady: state.catalogReady,
+    environments: state.environmentIds.map((environmentId) => ({ environmentId })),
+  })) as never,
   usePrimaryEnvironment: (() =>
     state.localEnvironmentDisabled
       ? null
@@ -147,6 +153,8 @@ function setup() {
   vi.clearAllMocks();
   state.confirm.mockResolvedValue(true);
   state.localEnvironmentDisabled = false;
+  state.catalogReady = true;
+  state.environmentIds = ["local"];
   state.projects = [];
   state.routeParams = {};
   state.preview
@@ -175,14 +183,21 @@ async function mount(...urls: string[]) {
       },
     }),
   );
-  stack.use(
+  const screen = stack.use(
     await render(
       <AppAtomRegistryProvider>
         <DesktopWebLinkCoordinator />
       </AppAtomRegistryProvider>,
     ),
   );
-  return stack.move();
+  return Object.assign(stack.move(), {
+    rerender: () =>
+      screen.rerender(
+        <AppAtomRegistryProvider>
+          <DesktopWebLinkCoordinator />
+        </AppAtomRegistryProvider>,
+      ),
+  });
 }
 
 it("holds a launch PR link until project discovery settles, then opens the PR view", async () => {
@@ -335,3 +350,28 @@ it("does not hold a PR link for project discovery that never settles with Local
   await using _coordinator = await mount(pullRequestUrl);
   await vi.waitFor(() => expect(state.openScratchProject).toHaveBeenCalledOnce());
 });
+
+it.each([false, true])(
+  "keeps a saved remote startup thread link queued until its catalog loads (local disabled: %s)",
+  async (localEnvironmentDisabled) => {
+    setup();
+    state.localEnvironmentDisabled = localEnvironmentDisabled;
+    state.catalogReady = false;
+    state.environmentIds = [];
+    await using coordinator = await mount("t3code://threads/remote/thread");
+    expect(state.navigate).not.toHaveBeenCalled();
+    expect(state.openScratchProject).not.toHaveBeenCalled();
+    expect(state.openLink).not.toHaveBeenCalled();
+
+    const navigated = new Promise<void>((resolve) => {
+      state.navigate.mockImplementationOnce(async () => resolve());
+    });
+    state.environmentIds = ["remote"];
+    state.catalogReady = true;
+    await coordinator.rerender();
+    await navigated;
+    expect(state.navigate).toHaveBeenCalledExactlyOnceWith({ href: "/remote/thread" });
+    expect(state.openScratchProject).not.toHaveBeenCalled();
+    expect(state.openLink).not.toHaveBeenCalled();
+  },
+);
diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
index 3e3889b6b6ead..15aaf21345822 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
@@ -86,7 +86,7 @@ function threadShowingBrowser(
 export function DesktopWebLinkCoordinator() {
   const router = useRouter();
   const primaryEnvironment = usePrimaryEnvironment();
-  const { environments } = useEnvironments();
+  const { environments, isReady: environmentsReady } = useEnvironments();
   const openPullRequestsInApp = useClientSettings((settings) => settings.pullRequestLinksOpenInApp);
   const openChangeRequest = useOpenChangeRequestLink();
   const { scratchEnvironmentId, openScratchProject } = useScratchProject();
@@ -104,9 +104,11 @@ export function DesktopWebLinkCoordinator() {
   // A sync IPC read; the setting only changes across a relaunch.
   const [localEnvironmentDisabled] = useState(isLocalEnvironmentDisabled);
   // With Local environment disabled there is no primary to wait for, so links run against the
-  // saved remote environments instead of waiting forever.
+  // saved remote environments instead of waiting forever. The catalog must finish loading
+  // before the bridge drains startup links, so saved remotes are not mistaken for unknown ones.
   const ready =
     webLinks !== undefined &&
+    environmentsReady &&
     (localEnvironmentDisabled ||
       (primaryEnvironment?.connection.phase === "connected" &&
         primaryEnvironment.serverConfig !== null));

From a740b7e7c5099fa71296c8d9a10ecef654615451 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 09:34:46 -0400
Subject: [PATCH 04/10] test(shared): exercise scanner on large thread-link
 pastes

---
 packages/shared/src/threadDeepLinks.test.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/packages/shared/src/threadDeepLinks.test.ts b/packages/shared/src/threadDeepLinks.test.ts
index 6e08b10aa554a..33df46fad5485 100644
--- a/packages/shared/src/threadDeepLinks.test.ts
+++ b/packages/shared/src/threadDeepLinks.test.ts
@@ -85,12 +85,13 @@ it.each([
   expect(normalizeThreadClipboard(text, null)).toEqual({ text, fragment: null });
 });
 it.each([
-  "[".repeat(80000),
-  '[{"a":1},'.repeat(125000),
   "[".repeat(80000) + " https://app.t3.codes/env/thread",
+  '[{"a":1},'.repeat(125000) + " https://app.t3.codes/env/thread",
 ])("handles large bracket-heavy pastes", (text) => {
   const result = normalizeThreadClipboard(text, null);
   expect(result.text.startsWith(text.slice(0, 80000))).toBe(true);
+  expect(result.fragment?.records).toMatchObject([{ environmentId: "env", threadId: "thread" }]);
+  expect(collectComposerContextReferences(result.text)).toHaveLength(1);
 });
 it.each(["/assets/index.js", "/.well-known/assetlinks.json", "/guest/x", "/new/x"])(
   "rejects reserved web paths: %s",

From 17222bc3279b324f250e05cddb164afe12b509c6 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 09:52:38 -0400
Subject: [PATCH 05/10] fix(web): preserve pasted thread identity across
 environments

---
 .../useComposerContextImport.browser.test.tsx | 69 ++++++++++++++++++-
 .../chat/useComposerContextImport.ts          |  7 +-
 2 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx b/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx
index a050b0f51edf0..5e8ae81b3ca65 100644
--- a/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx
+++ b/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx
@@ -1,5 +1,11 @@
+import { threadContextRecord } from "@t3tools/shared/composerContextReferences";
 import { useEffect } from "react";
-import { type ComposerContextRecord, ComposerContextId, EnvironmentId } from "@t3tools/contracts";
+import {
+  type ComposerContextRecord,
+  ComposerContextId,
+  EnvironmentId,
+  ThreadId,
+} from "@t3tools/contracts";
 import { expect, it, vi } from "vite-plus/test";
 
 import { act, render, stubGlobal } from "../../../test/render";
@@ -186,3 +192,64 @@ it.each([
       : [],
   );
 });
+
+it.each([false, true])(
+  "preserves thread identity when pasting a colliding context (other environment: %s)",
+  async (otherEnvironment) => {
+    const target = DraftId.make(`thread-collision-${otherEnvironment}`);
+    const store = useComposerDraftStore.getState();
+    using _draft = { [Symbol.dispose]: () => store.clearComposerContent(target) };
+    const environmentId = EnvironmentId.make("thread-source");
+    const otherEnvironmentId = EnvironmentId.make("other-thread-source");
+    const first = threadContextRecord(
+      { environmentId, threadId: ThreadId.make("same-id") },
+      "First",
+    );
+    const pasted = otherEnvironment
+      ? threadContextRecord(
+          { environmentId: otherEnvironmentId, threadId: first.threadId },
+          "Second",
+        )
+      : first;
+    store.addThreadContexts(target, [first], { appendReference: false });
+    let importer!: Importer;
+    await using _screen = await render(
+      <Harness
+        input={{
+          environmentId,
+          linkedEnvironments: new Map([[otherEnvironmentId, "Other machine"]]),
+          activeThread: undefined,
+          activeThreadId: null,
+          composerDraftTarget: target,
+          attachmentDraftTarget: target,
+          attachmentTargetKey: target,
+          attachmentTargetKeyRef: { current: target },
+          questionAttachmentTarget: null,
+          pendingUserInputs: [],
+          composerContextRecords: new Map([[first.contextId, { kind: "thread", record: first }]]),
+          composerImages: [],
+          composerFilesRef: { current: [] },
+          pendingThreadImportsRef: { current: new Map() },
+          promptRef: { current: "" },
+          addComposerFilesToDraft: () => [],
+        }}
+        ready={(value) => {
+          importer = value;
+        }}
+      />,
+    );
+    let importedId: string | undefined;
+    await act(() => {
+      importedId = importer
+        .importContextRecords([pasted], pasted.environmentId)
+        .get(pasted.contextId);
+    });
+    const records = store.getComposerDraft(target)!.threadContexts;
+    expect(records.find((record) => record.contextId === importedId)).toEqual({
+      ...pasted,
+      contextId: importedId,
+    });
+    expect(records).toHaveLength(otherEnvironment ? 2 : 1);
+    expect(records[0]).toEqual(first);
+  },
+);
diff --git a/apps/web/src/components/chat/useComposerContextImport.ts b/apps/web/src/components/chat/useComposerContextImport.ts
index de56d0bd530e3..61ccb11dad299 100644
--- a/apps/web/src/components/chat/useComposerContextImport.ts
+++ b/apps/web/src/components/chat/useComposerContextImport.ts
@@ -399,10 +399,13 @@ export function useComposerContextImport(input: {
             !linkedEnvironments.has(record.environmentId)
           )
             break;
-          addComposerDraftThreadContexts(threadDraftTarget, [record], {
+          const imported = conflicts
+            ? { ...record, contextId: toKindScopedComposerContextId("thread", randomUUID()) }
+            : record;
+          addComposerDraftThreadContexts(threadDraftTarget, [imported], {
             appendReference: false,
           });
-          rewritten.set(record.contextId, record.contextId);
+          rewritten.set(record.contextId, imported.contextId);
           break;
         }
         case "environment": {

From 9456187850237a1d5c22ecaa790627fa237a325c Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 10:04:26 -0400
Subject: [PATCH 06/10] fix: preserve thread link punctuation and external
 fallback

---
 .../DesktopWebLinkCoordinator.browser.test.tsx   | 16 ++++++++++++++++
 .../desktop/DesktopWebLinkCoordinator.tsx        |  3 ++-
 packages/shared/src/threadDeepLinks.test.ts      | 16 ++++++++++++----
 packages/shared/src/threadDeepLinks.ts           | 10 +++++++++-
 4 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
index 51f20679c3b0d..f527868c0d300 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
@@ -10,6 +10,7 @@ const state = vi.hoisted(() => ({
   projects: [] as EnvironmentProject[],
   routeParams: {} as Record<string, string>,
   preview: vi.fn(),
+  openExternal: vi.fn(async (_url: string) => true),
   openLink: vi.fn(async () => undefined),
   navigate: vi.fn(async (): Promise<void> => undefined),
   openScratchProject: vi.fn(async () => null),
@@ -172,6 +173,7 @@ async function mount(...urls: string[]) {
   stack.use(
     stubGlobal("desktopBridge", {
       getClientSettings: async () => null,
+      openExternal: state.openExternal,
       webLinks: {
         onOpen: (listener: (url: string) => void) => {
           deliver = listener;
@@ -375,3 +377,17 @@ it.each([false, true])(
     expect(state.openLink).not.toHaveBeenCalled();
   },
 );
+
+it.each(["https://app.t3.codes/unknown/thread", "t3code://threads/unknown/thread"])(
+  "opens an uncatalogued thread in the external browser: %s",
+  async (url) => {
+    setup();
+    await using _coordinator = await mount(url);
+    await vi.waitFor(() =>
+      expect(state.openExternal).toHaveBeenCalledWith("https://app.t3.codes/unknown/thread"),
+    );
+    expect(state.openScratchProject).not.toHaveBeenCalled();
+    expect(state.preview).not.toHaveBeenCalled();
+    expect(state.navigate).not.toHaveBeenCalled();
+  },
+);
diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
index 15aaf21345822..bfac9f3795b15 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
@@ -7,6 +7,7 @@ import type { EnvironmentId, ScopedThreadRef } from "@t3tools/contracts";
 import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
 import { parseThreadDeepLink, threadDeepLink } from "@t3tools/shared/threadDeepLinks";
 import { promptLinkAppPath } from "@t3tools/shared/promptLinks";
+import { readLocalApi } from "../../localApi";
 import { readPairingAppLink, resolveRemotePairingTarget } from "@t3tools/shared/remote";
 import { useRouter } from "@tanstack/react-router";
 import * as Effect from "effect/Effect";
@@ -225,7 +226,7 @@ export function DesktopWebLinkCoordinator() {
       return;
     }
     if (bareThread !== null) {
-      await openInBrowser(threadDeepLink(bareThread));
+      await readLocalApi()?.shell.openExternal(threadDeepLink(bareThread));
       return;
     }
     const routeParams = router.state.matches.at(-1)?.params ?? {};
diff --git a/packages/shared/src/threadDeepLinks.test.ts b/packages/shared/src/threadDeepLinks.test.ts
index 33df46fad5485..dcd8d8ef78797 100644
--- a/packages/shared/src/threadDeepLinks.test.ts
+++ b/packages/shared/src/threadDeepLinks.test.ts
@@ -9,10 +9,18 @@ import {
 const ref = { environmentId: EnvironmentId.make("env-1"), threadId: ThreadId.make("thread:1%2F") };
 
 describe("public thread links", () => {
-  it("round-trips encoded ids without losing literal escapes", () => {
-    expect(parseThreadDeepLink(threadDeepLink(ref))).toEqual(ref);
-    expect(parseThreadDeepLink("t3code://threads/env-1/thread%3A1%252F")).toEqual(ref);
-  });
+  it.each(["thread:1%2F", "thread.", "thread!", "thread)", "thread'", "thread("])(
+    "round-trips copied IDs through parsing and paste: %s",
+    (id) => {
+      const reference = { environmentId: EnvironmentId.make("env!"), threadId: ThreadId.make(id) };
+      const link = threadDeepLink(reference);
+      expect(parseThreadDeepLink(link)).toEqual(reference);
+      expect(normalizeThreadClipboard(link, null).fragment?.records).toEqual([
+        threadContextRecord(reference, reference.threadId),
+      ]);
+      expect(parseThreadDeepLink("t3code://threads/env-1/thread%3A1%252F")).toEqual(ref);
+    },
+  );
   it.each([
     "https://evil.test/env/thread",
     "https://app.t3.codes/settings/general",
diff --git a/packages/shared/src/threadDeepLinks.ts b/packages/shared/src/threadDeepLinks.ts
index fce63a59167c7..de199ca5a5dfd 100644
--- a/packages/shared/src/threadDeepLinks.ts
+++ b/packages/shared/src/threadDeepLinks.ts
@@ -6,9 +6,17 @@ import { DEFAULT_HOSTED_APP_URL } from "./connectAuth.ts";
 const decodeEnvironmentId = Schema.decodeOption(EnvironmentId);
 const decodeThreadId = Schema.decodeOption(ThreadId);
 
+// Keep ID punctuation distinct from prose delimiters when a plain URL is pasted.
+function encodeDeepLinkSegment(value: string): string {
+  return encodeURIComponent(value).replace(
+    /[.!'()]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
+  );
+}
+
 export function threadDeepLink(ref: ScopedThreadRef): string {
   return new URL(
-    `/${encodeURIComponent(ref.environmentId)}/${encodeURIComponent(ref.threadId)}`,
+    `/${encodeDeepLinkSegment(ref.environmentId)}/${encodeDeepLinkSegment(ref.threadId)}`,
     DEFAULT_HOSTED_APP_URL,
   ).href;
 }

From 7c6221e4989ea70ecf887e08d02572e17d8bfa6e Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 10:12:07 -0400
Subject: [PATCH 07/10] fix(web): reuse attached threads across repeated pastes

---
 .../useComposerContextImport.browser.test.tsx | 24 ++++++++++++-------
 .../chat/useComposerContextImport.ts          | 12 +++++++---
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx b/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx
index 5e8ae81b3ca65..4e342c074c94f 100644
--- a/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx
+++ b/apps/web/src/components/chat/useComposerContextImport.browser.test.tsx
@@ -193,10 +193,11 @@ it.each([
   );
 });
 
-it.each([false, true])(
-  "preserves thread identity when pasting a colliding context (other environment: %s)",
-  async (otherEnvironment) => {
-    const target = DraftId.make(`thread-collision-${otherEnvironment}`);
+it.each(["same", "renamed", "other-environment"] as const)(
+  "preserves thread identity across repeated pastes: %s",
+  async (variant) => {
+    const otherEnvironment = variant === "other-environment";
+    const target = DraftId.make(`thread-collision-${variant}`);
     const store = useComposerDraftStore.getState();
     using _draft = { [Symbol.dispose]: () => store.clearComposerContent(target) };
     const environmentId = EnvironmentId.make("thread-source");
@@ -210,7 +211,9 @@ it.each([false, true])(
           { environmentId: otherEnvironmentId, threadId: first.threadId },
           "Second",
         )
-      : first;
+      : variant === "renamed"
+        ? threadContextRecord({ environmentId, threadId: first.threadId }, "Renamed")
+        : first;
     store.addThreadContexts(target, [first], { appendReference: false });
     let importer!: Importer;
     await using _screen = await render(
@@ -245,11 +248,16 @@ it.each([false, true])(
         .get(pasted.contextId);
     });
     const records = store.getComposerDraft(target)!.threadContexts;
-    expect(records.find((record) => record.contextId === importedId)).toEqual({
-      ...pasted,
-      contextId: importedId,
+    expect(records.find((record) => record.contextId === importedId)).toMatchObject({
+      environmentId: pasted.environmentId,
+      threadId: pasted.threadId,
     });
     expect(records).toHaveLength(otherEnvironment ? 2 : 1);
     expect(records[0]).toEqual(first);
+    await act(() => {
+      const repeated = importer.importContextRecords([pasted], pasted.environmentId);
+      expect(repeated.get(pasted.contextId)).toBe(importedId);
+    });
+    expect(store.getComposerDraft(target)!.threadContexts).toEqual(records);
   },
 );
diff --git a/apps/web/src/components/chat/useComposerContextImport.ts b/apps/web/src/components/chat/useComposerContextImport.ts
index 61ccb11dad299..4b31a72e2b479 100644
--- a/apps/web/src/components/chat/useComposerContextImport.ts
+++ b/apps/web/src/components/chat/useComposerContextImport.ts
@@ -399,9 +399,15 @@ export function useComposerContextImport(input: {
             !linkedEnvironments.has(record.environmentId)
           )
             break;
-          const imported = conflicts
-            ? { ...record, contextId: toKindScopedComposerContextId("thread", randomUUID()) }
-            : record;
+          const attached = getComposerDraft(threadDraftTarget)?.threadContexts.find(
+            (thread) =>
+              thread.environmentId === record.environmentId && thread.threadId === record.threadId,
+          );
+          const imported =
+            attached ??
+            (conflicts
+              ? { ...record, contextId: toKindScopedComposerContextId("thread", randomUUID()) }
+              : record);
           addComposerDraftThreadContexts(threadDraftTarget, [imported], {
             appendReference: false,
           });

From b312a358931b7f0e56a9ba4bbc8f40051f7b5743 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 10:21:21 -0400
Subject: [PATCH 08/10] fix(web): stop unknown-thread handoff loops and report
 failures

---
 ...DesktopWebLinkCoordinator.browser.test.tsx | 24 ++++++++++++++++---
 .../desktop/DesktopWebLinkCoordinator.tsx     |  6 ++++-
 .../promptLinks/HostedPromptLinkLanding.tsx   |  2 +-
 .../promptLinks/hostedThreadLink.test.ts      |  4 ++--
 .../promptLinks/hostedThreadLink.ts           |  3 ++-
 5 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
index f527868c0d300..fd779b1b13255 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
@@ -5,6 +5,7 @@ import { AsyncResult, type Atom } from "effect/reactivity";
 import { expect, it, vi } from "vite-plus/test";
 
 import { act, render, stubGlobal } from "../../../test/render";
+import { toastManager } from "../ui/toast";
 
 const state = vi.hoisted(() => ({
   projects: [] as EnvironmentProject[],
@@ -378,10 +379,16 @@ it.each([false, true])(
   },
 );
 
-it.each(["https://app.t3.codes/unknown/thread", "t3code://threads/unknown/thread"])(
-  "opens an uncatalogued thread in the external browser: %s",
-  async (url) => {
+it.each([
+  { url: "https://app.t3.codes/unknown/thread", opened: true },
+  { url: "t3code://threads/unknown/thread", opened: true },
+  { url: "https://app.t3.codes/unknown/thread", opened: false },
+])(
+  "opens an uncatalogued thread externally and reports failure: $url (opened: $opened)",
+  async ({ url, opened }) => {
     setup();
+    state.openExternal.mockResolvedValueOnce(opened);
+    using notification = vi.spyOn(toastManager, "add");
     await using _coordinator = await mount(url);
     await vi.waitFor(() =>
       expect(state.openExternal).toHaveBeenCalledWith("https://app.t3.codes/unknown/thread"),
@@ -389,5 +396,16 @@ it.each(["https://app.t3.codes/unknown/thread", "t3code://threads/unknown/thread
     expect(state.openScratchProject).not.toHaveBeenCalled();
     expect(state.preview).not.toHaveBeenCalled();
     expect(state.navigate).not.toHaveBeenCalled();
+    if (!opened) {
+      await vi.waitFor(() =>
+        expect(notification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            type: "error",
+            title: "Could not open the link",
+            description: "Unable to open link.",
+          }),
+        ),
+      );
+    }
   },
 );
diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
index bfac9f3795b15..844605da5f479 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
@@ -226,7 +226,11 @@ export function DesktopWebLinkCoordinator() {
       return;
     }
     if (bareThread !== null) {
-      await readLocalApi()?.shell.openExternal(threadDeepLink(bareThread));
+      try {
+        await readLocalApi()?.shell.openExternal(threadDeepLink(bareThread));
+      } catch (error) {
+        reportFailure(url, error instanceof Error ? error.message : url);
+      }
       return;
     }
     const routeParams = router.state.matches.at(-1)?.params ?? {};
diff --git a/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx b/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
index 5ada3f3120dca..8780284971ee6 100644
--- a/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
+++ b/apps/web/src/components/promptLinks/HostedPromptLinkLanding.tsx
@@ -87,7 +87,7 @@ export function useHostedPromptLinkLanding(enabled: boolean): ReactNode | null {
     <HostedPromptLinkLanding
       appPath={appPath}
       canContinue={canContinue}
-      openInAppRemembered={opener === "app"}
+      openInAppRemembered={opener === "app" && threadAction !== "choose-manually"}
       onChoose={(choice, remember) => {
         if (remember) setOpener(choice);
         if (choice === "browser") setContinuedHref(href);
diff --git a/apps/web/src/components/promptLinks/hostedThreadLink.test.ts b/apps/web/src/components/promptLinks/hostedThreadLink.test.ts
index f32da19efd6f2..8779e5679b508 100644
--- a/apps/web/src/components/promptLinks/hostedThreadLink.test.ts
+++ b/apps/web/src/components/promptLinks/hostedThreadLink.test.ts
@@ -10,8 +10,8 @@ describe("bare hosted thread navigation", () => {
       expect(hostedThreadLinkAction(path, true, ["env"])).toBe("continue");
     },
   );
-  it("offers the opener for an unknown environment", () => {
-    expect(hostedThreadLinkAction("/unknown/thread", true, ["env"])).toBe("choose");
+  it("requires a manual choice for unknown environments even with a remembered app opener", () => {
+    expect(hostedThreadLinkAction("/unknown/thread", true, ["env"])).toBe("choose-manually");
   });
   it("keeps prompt links on the consent path", () => {
     expect(hostedThreadLinkAction("/env/thread?prompt=go", true, ["env"])).toBe("choose");
diff --git a/apps/web/src/components/promptLinks/hostedThreadLink.ts b/apps/web/src/components/promptLinks/hostedThreadLink.ts
index 2379f23f98981..7f1430d8bc50c 100644
--- a/apps/web/src/components/promptLinks/hostedThreadLink.ts
+++ b/apps/web/src/components/promptLinks/hostedThreadLink.ts
@@ -8,5 +8,6 @@ export function hostedThreadLinkAction(
   const ref = parseThreadPath(url.pathname);
   if (!ref || url.searchParams.has("prompt")) return "choose";
   if (!ready) return "wait";
-  return environmentIds.includes(ref.environmentId) ? "continue" : "choose";
+  // Desktop may hand an unknown thread back here; never automatically send it back again.
+  return environmentIds.includes(ref.environmentId) ? "continue" : "choose-manually";
 }

From 1ed926f4125cd93ca8380d2981bd4f16a913cd54 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 22:58:52 -0400
Subject: [PATCH 09/10] style(mobile): wrap thread paste checks for Kotlin lint

---
 .../expo/modules/t3composereditor/T3ComposerEditorView.kt   | 5 ++++-
 .../java/expo/modules/t3composereditor/ComposerPasteTest.kt | 6 +++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
index ff0873857fd96..1efe40a1a6ea5 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
@@ -742,7 +742,10 @@ internal class SelectionAwareEditText(
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
     val clip = clipboard?.primaryClip
     val plainText = clip?.plainText()
-    if (plainText != null && (plainText.contains("app.t3.codes/") || plainText.contains("://threads/"))) {
+    if (
+      plainText != null &&
+      (plainText.contains("app.t3.codes/") || plainText.contains("://threads/"))
+    ) {
       if (!pasteInterceptedText(clip)) {
         pasteContextListener?.invoke(payload + ("text" to plainText))
       }
diff --git a/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt b/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
index 5e7cfb61088b2..9f8555100651b 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
@@ -182,7 +182,11 @@ class ComposerPasteTest {
 
   @Test
   fun regularPasteSendsPlainThreadUrlsToTheContextImporter() {
-    for (url in listOf("https://app.t3.codes/environment/thread", "t3code://threads/environment/thread")) {
+    val urls = listOf(
+      "https://app.t3.codes/environment/thread",
+      "t3code://threads/environment/thread"
+    )
+    for (url in urls) {
       clipboard.setPrimaryClip(ClipData.newPlainText("test", url))
       editor.setText("before")
       editor.setSelection(6)

From d2c280a4d9aa2229c17d7967bb07e114380eb3f5 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sat, 31 Oct 2026 23:02:38 -0400
Subject: [PATCH 10/10] refactor(mobile): keep paste dispatch within return
 limit

---
 .../expo/modules/t3composereditor/T3ComposerEditorView.kt  | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
index 1efe40a1a6ea5..f9e80878113ee 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
@@ -742,16 +742,17 @@ internal class SelectionAwareEditText(
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
     val clip = clipboard?.primaryClip
     val plainText = clip?.plainText()
-    if (
+    return if (
       plainText != null &&
       (plainText.contains("app.t3.codes/") || plainText.contains("://threads/"))
     ) {
       if (!pasteInterceptedText(clip)) {
         pasteContextListener?.invoke(payload + ("text" to plainText))
       }
-      return true
+      true
+    } else {
+      pasteImagesOrInterceptedText()
     }
-    return pasteImagesOrInterceptedText()
   }
 
   private fun pasteImagesOrInterceptedText(): Boolean {