@@ -10,8 +10,9 @@ import { modelPickerFixtureRoute } from '@/lib/model-picker-fixture';
 // Composes the native-intent concerns in order: the share-extension check
 // returns early before web-path mapping (a share URL is never a web route), then
 // an app-action URL is handled by its own contract, and only what neither owns
-// reaches the universal-link mapper. Both handled branches return falsy
-// (`deep-link-handler.ts`); a truthy return re-dispatches the linking resolver.
+// reaches the universal-link mapper. Every handled or ignored link returns
+// falsy (`deep-link-handler.ts`); a truthy return re-dispatches the linking
+// resolver.
 export function redirectSystemPath({ path, initial }: { path: string; initial: boolean }) {
   let shareKey: string | null = null;
   try {
 
@@ -330,11 +330,21 @@ export function VariableEditForm({
         <Text className="flex-1 text-sm font-medium text-foreground">
           {t('profiles.secrets.markSecret')}
         </Text>
-        <Switch
-          value={isSecret}
-          accessibilityLabel={t('profiles.secrets.markSecret')}
-          onValueChange={setIsSecret}
-        />
+        {/* The native switch draws its 32dp track inside a box that reserves the
+            thumb's overhang, so the track ends about 12dp before the box does
+            and the row's 10.5dp padding leaves it 23dp from the row's edge,
+            twice the 13dp the lock glyph keeps from its opposite edge. Pulling
+            the box out by the padding itself lines the track's end up with the
+            glyph on both edges. The pull is on the END edge, so it must stay
+            logical: `marginInlineEnd` follows the writing direction, while a
+            hand-picked `-mr-3` lands on the title's side under RTL. */}
+        <View className="-me-3">
+          <Switch
+            value={isSecret}
+            accessibilityLabel={t('profiles.secrets.markSecret')}
+            onValueChange={setIsSecret}
+          />
+        </View>
       </View>
       <View className="flex-row gap-2">
         <Button variant="outline" className="flex-1" onPress={onCancel}>
 
@@ -11,6 +11,8 @@ import {
 import { handleAppActionPath } from './action-url-handler';
 import { getPendingAppAction, takePendingAppAction } from './pending-app-action';
 
+const SESSION_ID = 'ses_0123456789abcdefghijklmnop';
+
 vi.mock('@sentry/react-native', () => ({ captureException: vi.fn() }));
 
 beforeEach(() => {
@@ -39,11 +41,11 @@ describe('handleAppActionPath', () => {
   it('stashes a session URL on the universal-link rails', () => {
     expect(
       handleAppActionPath({
-        path: 'kiloapp:///actions/open-session?sessionId=ses_1',
+        path: `kiloapp:///actions/open-session?sessionId=${SESSION_ID}`,
         initial: false,
       })
     ).toBe(true);
-    expect(getPendingDeepLink()).toBe('/(app)/agent-chat/ses_1');
+    expect(getPendingDeepLink()).toBe(`/(app)/agent-chat/${SESSION_ID}`);
     expect(getPendingAppAction()).toBeNull();
   });
 
@@ -57,11 +59,24 @@ describe('handleAppActionPath', () => {
     expect(getPendingDeepLink()).toBe('/(app)/pr-review/o/r/7');
   });
 
+  it('opens nothing for a session id the route cannot resolve', () => {
+    // Still the contract's URL, but there is no destination to open: stashing
+    // the composer fallback would replace the current screen with it.
+    expect(
+      handleAppActionPath({
+        path: 'kiloapp:///actions/open-session?sessionId=not-a-session',
+        initial: false,
+      })
+    ).toBe(true);
+    expect(getPendingDeepLink()).toBeNull();
+    expect(getPendingAppAction()).toBeNull();
+  });
+
   it('accepts the scheme-less path expo-router hands redirectSystemPath', () => {
     expect(
-      handleAppActionPath({ path: '/actions/open-session?sessionId=ses_1', initial: true })
+      handleAppActionPath({ path: `/actions/open-session?sessionId=${SESSION_ID}`, initial: true })
     ).toBe(true);
-    expect(getPendingDeepLink()).toBe('/(app)/agent-chat/ses_1');
+    expect(getPendingDeepLink()).toBe(`/(app)/agent-chat/${SESSION_ID}`);
   });
 
   it('leaves anything that is not an action URL to the caller', () => {
@@ -108,23 +123,23 @@ describe('handleAppActionPath', () => {
   });
 
   it('does not re-stash a cold action when the launch capture already stashed', () => {
-    _setGetLinkingURLForTests(() => 'https://app.kilo.ai/cloud/sessions/ses_9');
+    _setGetLinkingURLForTests(() => `https://app.kilo.ai/cloud/sessions/${SESSION_ID}`);
     captureLaunchDeepLink();
-    expect(getPendingDeepLink()).toBe('/(app)/agent-chat/ses_9');
+    expect(getPendingDeepLink()).toBe(`/(app)/agent-chat/${SESSION_ID}`);
     expect(
       handleAppActionPath({
-        path: 'kiloapp:///actions/open-session?sessionId=ses_1',
+        path: `kiloapp:///actions/open-session?sessionId=${SESSION_ID}`,
         initial: true,
       })
     ).toBe(true);
     expect(getPendingDeepLink()).toBeNull();
     // A warm arrival has no launch capture to guard against, so it stashes.
     expect(
       handleAppActionPath({
-        path: 'kiloapp:///actions/open-session?sessionId=ses_1',
+        path: `kiloapp:///actions/open-session?sessionId=${SESSION_ID}`,
         initial: false,
       })
     ).toBe(true);
-    expect(getPendingDeepLink()).toBe('/(app)/agent-chat/ses_1');
+    expect(getPendingDeepLink()).toBe(`/(app)/agent-chat/${SESSION_ID}`);
   });
 });
@@ -9,6 +9,7 @@
 // cannot turn into a destination parks too: nothing opens, and the tabs layout
 // reports the contract's refusal instead of the app arriving unexplained.
 
+import { opensDestination } from '@/lib/deep-link-destination';
 import { setPendingDeepLink, wasLaunchLinkHandled } from '@/lib/deep-link-launch';
 
 import { appActionHref, parseAppActionUrl } from './app-action-contract';
@@ -20,9 +21,10 @@ import { setPendingAppAction } from './pending-app-action';
  * `false` means the path is not an action URL and the caller keeps going — the
  * universal-link mapper resolves nothing for these paths and must own the rest.
  * `true` means it belongs to this contract, including a link the provider
- * resolvers cannot turn into a destination: nothing is opened — the request
- * parks for the tabs consumer, which reports the refusal — and the path still
- * must not be mapped as a web route.
+ * resolvers cannot turn into a destination (parked for the tabs consumer, which
+ * reports the refusal) and a session destination the route cannot open (nothing
+ * opens, and the current screen keeps its state): the path still must not be
+ * mapped as a web route.
  *
  * The stash is the identical call `deep-link-handler.ts:71,76` makes, cold-start
  * guard included: the synchronous launch capture may already have stashed this
@@ -57,6 +59,12 @@ export function handleAppActionPath({
     setPendingAppAction(request);
     return true;
   }
+  if (!opensDestination(resolved)) {
+    // A session destination the route cannot open is not a destination: the
+    // same rule `deep-link-handler.ts` applies, so a hand-built action URL
+    // cannot replace the current screen with the composer. Nothing opens.
+    return true;
+  }
   if (initial ? !wasLaunchLinkHandled() : true) {
     setPendingDeepLink(resolved, 'universal-link');
   }
 
@@ -0,0 +1,117 @@
+// What an incoming link may open. The two shapes that used to replace the
+// visible screen — a session capture that cannot name a session, and a path
+// outside the app's route namespace — are rejected here, so the navigator never
+// resolves them and the screen beneath keeps its unsaved state.
+
+// eslint-disable-next-line import/no-nodejs-modules -- vitest-only check, runs in node, never bundled into the app
+import { readdirSync, readFileSync } from 'node:fs';
+// eslint-disable-next-line import/no-nodejs-modules -- vitest-only check, runs in node, never bundled into the app
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { APP_ROUTE_ROOTS, opensAppRoutePath, opensDestination } from './deep-link-destination';
+
+const SESSION_ID = 'ses_0123456789abcdefghijklmnop';
+
+describe('opensDestination', () => {
+  it.each([
+    '/(app)/(tabs)/(0_home)',
+    '/(app)/(tabs)/(3_profile)',
+    '/(app)/security-agent/personal/findings',
+    '/(app)/pr-review/Kilo-Org/cloud/6234',
+    '/(app)/agent-chat/new',
+    `/(app)/agent-chat/${SESSION_ID}`,
+  ])('opens the table destination %s', href => {
+    expect(opensDestination(href)).toBe(true);
+  });
+
+  it.each([
+    '/(app)/agent-chat/not-a-session',
+    '/(app)/agent-chat/00000000-0000-0000-0000-000000000000',
+    '/(app)/agent-chat/ses_short',
+  ])('refuses the session destination %s', href => {
+    expect(opensDestination(href)).toBe(false);
+  });
+});
+
+describe('opensAppRoutePath', () => {
+  it.each([
+    'kiloapp:///(app)/profile-management/34d743e6-7bb8-4dd1-880c-580bd8d907d5/variables',
+    'kiloapp:///(auth)/session-row-fixture',
+    'kiloapp:///force-update',
+    'kiloapp:///button-label-fixture',
+    '/(app)/agent-chat/new?mode=code',
+    '/(auth)/login',
+    `kiloapp:///(app)/agent-chat/${SESSION_ID}`,
+    'kiloapp:///(app)/agent-chat/new',
+    `kiloapp://agent-chat/${SESSION_ID}`,
+    'kiloapp://pr-review/Kilo-Org/cloud/6234',
+    'kiloapp://security-agent/personal',
+  ])('opens the app route %s', path => {
+    expect(opensAppRoutePath(path)).toBe(true);
+  });
+
+  it.each([
+    'kiloapp:///',
+    'kiloapp://',
+    'kiloapp:///definitely-not-a-route',
+    'kiloapp:///dev/unknown-fixture',
+    'https://app.kilo.ai/admin',
+    'https://example.com/profile',
+    'not a url',
+    'kiloapp://agent-chat/not-a-session',
+    'kiloapp:///(app)/agent-chat/not-a-session',
+    '/(app)/agent-chat/ses_short',
+  ])('refuses %s', path => {
+    expect(opensAppRoutePath(path)).toBe(false);
+  });
+});
+
+describe('route namespace', () => {
+  it('names every root entry of the route directory', () => {
+    // A new root-level route must be opened deliberately: an incoming link
+    // reaches the navigator only through one of these names (or the indexed
+    // families), so a route missing here is unreachable by link.
+    const entries = readdirSync(fileURLToPath(new URL('../app', import.meta.url)), {
+      withFileTypes: true,
+    })
+      .map(entry => entry.name)
+      // `_layout` and `+`-prefixed files are navigator plumbing, not routes.
+      .filter(name => !name.startsWith('_') && !name.startsWith('+'))
+      .filter(name => !/\.test\.tsx?$/.test(name))
+      .map(name => name.replace(/\.(tsx|ts|jsx|js)$/, ''));
+
+    expect([...new Set(entries)].sort()).toEqual([...APP_ROUTE_ROOTS].sort());
+  });
+});
+
+describe('seed fixture links', () => {
+  it('records the link form the app opens', () => {
+    // `dev/seed/AGENTS.md` requires a fixture to record the deep link that opens
+    // it, and `opensAppRoutePath` forwards only the group-prefixed form (or a
+    // `dev/` fixture link, which `+native-intent` answers before the mapper).
+    const files = seedSources(fileURLToPath(new URL('../../../../dev/seed', import.meta.url)));
+    const links = files.flatMap(file =>
+      [...readFileSync(file, 'utf8').matchAll(/kiloapp:\/\/[^\s'"`]+/g)].map(match => match[0])
+    );
+
+    expect(links.length).toBeGreaterThan(0);
+    for (const link of links) {
+      expect(
+        link.startsWith('kiloapp:///(app)/') || link.startsWith('kiloapp:///dev/'),
+        `${link} does not follow the recorded link form`
+      ).toBe(true);
+    }
+  });
+});
+
+function seedSources(directory: string): string[] {
+  return readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+    const path = `${directory}/${entry.name}`;
+    if (entry.isDirectory()) {
+      return seedSources(path);
+    }
+    return entry.name.endsWith('.ts') ? [path] : [];
+  });
+}
@@ -0,0 +1,103 @@
+/**
+ * What an incoming link may open.
+ *
+ * A link that names no screen the app can show must not reach the navigator:
+ * resolving a link replaces the visible route and unmounts the screen beneath
+ * it, so an open form and its unsaved input are lost even though the link
+ * opened nothing anyone asked for. The two consumers are `redirectSystemPath`
+ * (a warm arrival, which also forwards the app's own routes) and the
+ * synchronous cold-launch capture in `deep-link-launch.ts` (which only needs the
+ * table destination). One module owns both answers so they cannot disagree.
+ */
+
+import { parseKiloWebPath } from '@kilocode/app-shared/universal-links';
+
+import { isPlausibleKiloSessionId } from './session-id-shape';
+import {
+  deeplinkPathFromHref,
+  INDEXED_LINK_PREFIXES,
+  SESSION_HREF_PREFIX,
+} from './system-search-families';
+
+/**
+ * Root entries of `src/app` a link may address directly: the two route groups
+ * and the root-level screens. The universal-link table routes the app's
+ * published links; these are the in-app routes a dev or E2E link opens
+ * (`kiloapp:///(app)/…`, `kiloapp:///force-update`).
+ *
+ * `deep-link-destination.test.ts` keeps the list equal to the route
+ * directory's entries.
+ */
+export const APP_ROUTE_ROOTS: readonly string[] = [
+  '(app)',
+  '(auth)',
+  'button-label-fixture',
+  'force-update',
+];
+
+/** Route param that opens the New-session composer instead of a session. */
+const NEW_SESSION_CAPTURE = 'new';
+
+/** The session family's group-stripped prefix, as an indexed link carries it. */
+const SESSION_FAMILY_PREFIX = deeplinkPathFromHref(SESSION_HREF_PREFIX);
+
+/**
+ * Whether a universal-link destination opens something the app can show. Every
+ * row but the session row names a fixed screen; the session row accepts any
+ * capture, so its capture has to be the composer's `new` or an id the route can
+ * resolve. `isPlausibleKiloSessionId` is the same shape guard the route uses
+ * before it decides an id can never be a session.
+ */
+export function opensDestination(href: string): boolean {
+  if (!href.startsWith(SESSION_HREF_PREFIX)) {
+    return true;
+  }
+  const capture = href.slice(SESSION_HREF_PREFIX.length);
+  return capture === NEW_SESSION_CAPTURE || isPlausibleKiloSessionId(capture);
+}
+
+/**
+ * The pathname of a raw link: the path of one of our URL forms, or the
+ * scheme-less path expo-router hands `redirectSystemPath`. Null when the link
+ * carries no path of ours at all (a bare `kiloapp://`, or another host).
+ */
+function pathnameOf(path: string): string | null {
+  const webPath = parseKiloWebPath(path);
+  if (webPath !== null) {
+    return webPath;
+  }
+  if (!path.startsWith('/')) {
+    return null;
+  }
+  const end = path.search(/[?#]/);
+  return end === -1 ? path : path.slice(0, end);
+}
+
+/**
+ * Whether a link addresses the app's own routes — the paths this app, not the
+ * web table, owns. A dev or E2E link carries the route with its group segment
+ * (`kiloapp:///(app)/…`, the form the design gate and the mobile docs use); a
+ * system-search tap is delivered as the group-stripped family link the app
+ * itself indexed (`kiloapp://agent-chat/…`). The session route appears in both
+ * forms and its param must name a screen either way.
+ */
+export function opensAppRoutePath(path: string): boolean {
+  const pathname = pathnameOf(path);
+  if (pathname === null) {
+    return false;
+  }
+  const withoutLeadingSlash = pathname.replace(/^\/+/, '');
+  // One href for the session route, whichever form the link carries: with the
+  // group segment (dev and E2E links) or without it (a search tap).
+  const sessionHref = withoutLeadingSlash.startsWith(SESSION_FAMILY_PREFIX)
+    ? `${SESSION_HREF_PREFIX}${withoutLeadingSlash.slice(SESSION_FAMILY_PREFIX.length)}`
+    : `/${withoutLeadingSlash}`;
+  if (sessionHref.startsWith(SESSION_HREF_PREFIX)) {
+    return opensDestination(sessionHref);
+  }
+  if (INDEXED_LINK_PREFIXES.some(prefix => withoutLeadingSlash.startsWith(prefix))) {
+    return true;
+  }
+  const root = withoutLeadingSlash.split('/')[0];
+  return root !== undefined && APP_ROUTE_ROOTS.includes(root);
+}