diff --git a/.changeset/restore-archived-sessions.md b/.changeset/restore-archived-sessions.md
new file mode 100644
index 0000000000..2fd35cbf90
--- /dev/null
+++ b/.changeset/restore-archived-sessions.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+Add server APIs to restore archived sessions and list only archived sessions.
diff --git a/.changeset/web-archived-sessions-settings.md b/.changeset/web-archived-sessions-settings.md
new file mode 100644
index 0000000000..b12f05239b
--- /dev/null
+++ b/.changeset/web-archived-sessions-settings.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+web: Add an Archived sessions page in Settings to browse and restore archived sessions. Open Settings → Archived to find it.
diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index 5c5049b3c3..531ff3cb13 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -293,6 +293,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
       status?: AppSessionStatus;
       workspaceId?: string;
       includeArchive?: boolean;
+      archivedOnly?: boolean;
       excludeEmpty?: boolean;
     },
   ): Promise<Page<AppSession>> {
@@ -302,6 +303,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
       page_size: input?.pageSize,
       status: input?.status ? toWireSessionStatus(input.status) : undefined,
       include_archive: input?.includeArchive,
+      archived_only: input?.archivedOnly,
       exclude_empty: input?.excludeEmpty,
       // PRESUMED — daemon supports ?workspace_id= once the registry ships; it
       // ignores unknown query params until then, so this is safe to always send.
@@ -420,6 +422,16 @@ export class DaemonKimiWebApi implements KimiWebApi {
     return data;
   }
 
+  // POST /sessions/{id}:restore — clear the archived flag. The daemon returns
+  // the full restored session, so callers can merge it straight back into lists.
+  async restoreSession(sessionId: string): Promise<AppSession> {
+    const data = await this.http.post<WireSession>(
+      `/sessions/${encodeURIComponent(sessionId)}:restore`,
+      {},
+    );
+    return toAppSession(data);
+  }
+
   // -------------------------------------------------------------------------
   // Messages
   // -------------------------------------------------------------------------
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index 16adbbcd3c..08b6ae5174 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -645,7 +645,7 @@ export interface AppSessionWarning {
 export interface KimiWebApi {
   getHealth(): Promise<{ status: 'ok'; uptimeSec: number }>;
   getMeta(): Promise<{ serverVersion: string; serverId: string; startedAt: string; capabilities: Record<string, boolean>; openInApps: string[]; dangerousBypassAuth: boolean }>;
-  listSessions(input?: PageRequest & { status?: AppSessionStatus; workspaceId?: string; includeArchive?: boolean; excludeEmpty?: boolean }): Promise<Page<AppSession>>;
+  listSessions(input?: PageRequest & { status?: AppSessionStatus; workspaceId?: string; includeArchive?: boolean; archivedOnly?: boolean; excludeEmpty?: boolean }): Promise<Page<AppSession>>;
   createSession(input: { title?: string; cwd?: string; model?: string; workspaceId?: string }): Promise<AppSession>;
   /** Fetch one session by id (deep links beyond the first listSessions page). */
   getSession(sessionId: string): Promise<AppSession>;
@@ -653,6 +653,7 @@ export interface KimiWebApi {
   getSessionStatus(sessionId: string): Promise<AppSessionRuntimeStatus>;
   getSessionWarnings(sessionId: string): Promise<AppSessionWarning[]>;
   archiveSession(sessionId: string): Promise<{ archived: true }>;
+  restoreSession(sessionId: string): Promise<AppSession>;
   listMessages(sessionId: string, input?: PageRequest & { role?: AppMessageRole }): Promise<Page<AppMessage>>;
   /** v2 initial sync: atomic session state + `asOfSeq` watermark + epoch. */
   getSessionSnapshot(sessionId: string): Promise<AppSessionSnapshot>;
diff --git a/apps/kimi-web/src/components/settings/SettingsDialog.vue b/apps/kimi-web/src/components/settings/SettingsDialog.vue
index b910332c21..44d7cf3ca6 100644
--- a/apps/kimi-web/src/components/settings/SettingsDialog.vue
+++ b/apps/kimi-web/src/components/settings/SettingsDialog.vue
@@ -3,8 +3,10 @@
      scattered in the sidebar account popover: appearance, language, account,
      connection, plus notifications and the troubleshooting-log export. -->
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref } from 'vue';
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
+import { useKimiWebClient } from '../../composables/useKimiWebClient';
+import type { AppSession } from '../../api/types';
 import { useDialogFocus } from '../../composables/useDialogFocus';
 import LanguageSwitcher from './LanguageSwitcher.vue';
 import { serverEndpointLabel } from '../../api/config';
@@ -62,7 +64,7 @@ const emit = defineEmits<{
   close: [];
 }>();
 
-type SettingsTab = 'general' | 'agent' | 'account' | 'advanced';
+type SettingsTab = 'general' | 'agent' | 'account' | 'advanced' | 'archived';
 
 const activeTab = ref<SettingsTab>('general');
 
@@ -71,6 +73,7 @@ const tabs: { id: SettingsTab; labelKey: string }[] = [
   { id: 'agent', labelKey: 'settings.tabs.agent' },
   { id: 'account', labelKey: 'settings.tabs.account' },
   { id: 'advanced', labelKey: 'settings.tabs.advanced' },
+  { id: 'archived', labelKey: 'settings.tabs.archived' },
 ];
 
 const daemonEndpoint = serverEndpointLabel();
@@ -206,6 +209,107 @@ function toggleTelemetry(): void {
 function setTab(tab: SettingsTab): void {
   activeTab.value = tab;
 }
+
+// ---------------------------------------------------------------------------
+// Archived-sessions tab — its own list state (server-side `archived_only`
+// filter), kept separate from the per-workspace active list. Search, workspace
+// filter and sort all run client-side over the loaded pages. Restore goes
+// through the composable so the sidebar list updates automatically.
+// ---------------------------------------------------------------------------
+const client = useKimiWebClient();
+
+const archivedItems = ref<AppSession[]>([]);
+const archivedLoading = ref(false);
+const archivedLoaded = ref(false);
+const archiveQuery = ref('');
+const archiveWsFilter = ref<string>('all'); // 'all' | cwd
+const archiveSort = ref<'archived-desc' | 'created-desc' | 'name-asc'>('archived-desc');
+
+// Load every archived session once when the tab opens (no frontend pagination).
+// Search, sort and the workspace filter then run client-side over the full set,
+// so results are always global and there is no empty-page / cursor bookkeeping
+// to get wrong. The user waits a moment on first open in exchange for simplicity.
+const ARCHIVED_PAGE_SIZE = 100;
+
+async function loadAllArchived(): Promise<void> {
+  if (archivedLoading.value || archivedLoaded.value) return;
+  archivedLoading.value = true;
+  try {
+    const all: AppSession[] = [];
+    let beforeId: string | undefined;
+    for (;;) {
+      const page = await client.loadArchivedSessions({ beforeId, pageSize: ARCHIVED_PAGE_SIZE });
+      all.push(...page.items);
+      if (!page.hasMore || page.items.length === 0) break;
+      const next = page.items.at(-1)?.id;
+      if (next === undefined) break;
+      beforeId = next;
+    }
+    archivedItems.value = all;
+    archivedLoaded.value = true;
+  } catch (err) {
+    console.warn('loadAllArchived failed', err);
+  } finally {
+    archivedLoading.value = false;
+  }
+}
+
+watch(activeTab, (tab) => {
+  if (tab === 'archived' && !archivedLoaded.value) {
+    void loadAllArchived();
+  }
+});
+
+const archiveWorkspaces = computed<string[]>(() => {
+  const set = new Set<string>();
+  for (const s of archivedItems.value) set.add(s.cwd);
+  return Array.from(set).sort((a, b) => a.localeCompare(b));
+});
+
+const filteredArchived = computed<AppSession[]>(() => {
+  const q = archiveQuery.value.trim().toLowerCase();
+  // Defensive invariant: this panel must only ever render archived sessions,
+  // even if an older server ignores `archived_only` and falls back to the
+  // default (unarchived) list. Filter again on the client.
+  let rows = archivedItems.value.filter((s) => s.archived === true);
+  if (archiveWsFilter.value !== 'all') {
+    rows = rows.filter((s) => s.cwd === archiveWsFilter.value);
+  }
+  if (q) rows = rows.filter((s) => s.title.toLowerCase().includes(q));
+  rows = rows.slice();
+  if (archiveSort.value === 'archived-desc') {
+    rows.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  } else if (archiveSort.value === 'created-desc') {
+    rows.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  } else {
+    rows.sort((a, b) => a.title.localeCompare(b.title, 'zh'));
+  }
+  return rows;
+});
+
+const groupedArchived = computed<{ cwd: string; items: AppSession[] }[]>(() => {
+  const map = new Map<string, AppSession[]>();
+  for (const s of filteredArchived.value) {
+    const list = map.get(s.cwd) ?? [];
+    list.push(s);
+    map.set(s.cwd, list);
+  }
+  return Array.from(map.entries()).map(([cwd, items]) => ({ cwd, items }));
+});
+
+async function onRestore(id: string): Promise<void> {
+  const ok = await client.restoreSession(id);
+  if (ok) {
+    archivedItems.value = archivedItems.value.filter((s) => s.id !== id);
+  }
+}
+
+function archiveTime(iso: string): string {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  const pad = (n: number): string => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
 </script>
 
 <template>
@@ -467,6 +571,69 @@ function setTab(tab: SettingsTab): void {
           </section>
         </section>
 
+        <!-- Archived sessions -->
+        <section v-show="activeTab === 'archived'" class="panel">
+          <div class="panel-head">
+            <div class="panel-kicker">Archived sessions</div>
+            <h4 class="panel-title">{{ t('settings.archivedTitle') }}</h4>
+            <p class="panel-desc">{{ t('settings.archivedDesc') }}</p>
+          </div>
+
+          <div class="archive-toolbar">
+            <label class="archive-search">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="7" /><path d="m21 21-4.3-4.3" /></svg>
+              <input v-model="archiveQuery" :placeholder="t('settings.archivedSearch')" />
+            </label>
+            <Select
+              :model-value="archiveWsFilter"
+              size="sm"
+              :aria-label="t('settings.archivedAllWorkspaces')"
+              @update:model-value="archiveWsFilter = $event as string"
+            >
+              <option value="all">{{ t('settings.archivedAllWorkspaces') }}</option>
+              <option v-for="ws in archiveWorkspaces" :key="ws" :value="ws">{{ ws }}</option>
+            </Select>
+            <SegmentedControl
+              size="sm"
+              :model-value="archiveSort"
+              :options="[
+                { value: 'archived-desc', label: t('settings.archivedSortArchived') },
+                { value: 'created-desc', label: t('settings.archivedSortCreated') },
+                { value: 'name-asc', label: t('settings.archivedSortName') },
+              ]"
+              @update:model-value="archiveSort = $event as 'archived-desc' | 'created-desc' | 'name-asc'"
+            />
+          </div>
+
+          <div v-if="archivedLoading" class="archive-empty">
+            {{ t('settings.archivedLoadingAll') }}
+          </div>
+
+          <template v-else>
+            <div v-if="groupedArchived.length > 0" class="archive-list">
+              <section v-for="g in groupedArchived" :key="g.cwd" class="archive-card">
+                <div class="archive-workspace">
+                  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 7h6l2 2h10v9H3z" /><path d="M3 7V5h6l2 2" /></svg>
+                  <span class="path">{{ g.cwd }}</span>
+                  <span class="count">{{ t('settings.archivedSessionsCount', { count: g.items.length }) }}</span>
+                </div>
+                <div class="setting-card">
+                  <div v-for="s in g.items" :key="s.id" class="archive-row">
+                    <div class="archive-meta">
+                      <div class="archive-name">{{ s.title }}</div>
+                      <div class="archive-time">{{ t('settings.archivedAt', { time: archiveTime(s.updatedAt) }) }}</div>
+                    </div>
+                    <Button variant="secondary" size="sm" @click="onRestore(s.id)">{{ t('settings.archivedRestore') }}</Button>
+                  </div>
+                </div>
+              </section>
+            </div>
+            <div v-else class="archive-empty">
+              {{ archivedItems.length === 0 ? t('settings.archivedEmpty') : t('settings.archivedNoMatch') }}
+            </div>
+          </template>
+        </section>
+
       </div>
     </div>
   </Dialog>
@@ -615,4 +782,37 @@ function setTab(tab: SettingsTab): void {
     max-width: none;
   }
 }
+/* Archived-sessions tab */
+.setting-card { border: 1px solid var(--color-line); border-radius: var(--radius-xl); overflow: hidden; background: var(--color-bg); }
+.panel-head { margin-bottom: var(--space-4); }
+.panel-kicker { font-size: var(--text-xs); letter-spacing: 0.05em; text-transform: uppercase; color: var(--color-text-faint); margin-bottom: var(--space-1); }
+.panel-title { margin: 0 0 var(--space-2); font-family: var(--font-ui); font-size: var(--text-2xl); font-weight: var(--weight-semibold); letter-spacing: -0.01em; color: var(--color-text); }
+.panel-desc { margin: 0; font-family: var(--font-ui); font-size: var(--text-sm); line-height: var(--leading-normal); color: var(--color-text-muted); max-width: 560px; }
+.archive-toolbar { display: flex; align-items: center; gap: var(--space-3); margin-bottom: var(--space-4); flex-wrap: wrap; }
+.archive-search { flex: 1; min-width: 200px; height: 36px; display: flex; align-items: center; gap: var(--space-2); padding: 0 var(--space-3); border-radius: var(--radius-md); border: 1px solid var(--color-line); color: var(--color-text-faint); font-size: var(--text-sm); background: var(--color-surface-raised); transition: border-color var(--duration-fast) var(--ease-out), box-shadow var(--duration-fast) var(--ease-out); }
+.archive-search:focus-within { border-color: var(--color-accent); box-shadow: var(--p-focus-ring); color: var(--color-text-muted); }
+.archive-search svg { width: 15px; height: 15px; flex: none; }
+.archive-search input { width: 100%; border: none; outline: none; background: transparent; font: inherit; color: var(--color-text); }
+.archive-list { display: flex; flex-direction: column; gap: var(--space-4); }
+.archive-card .setting-card { margin-bottom: 0; }
+.archive-workspace { display: flex; align-items: center; gap: var(--space-2); margin: 0 2px var(--space-2); color: var(--color-text-muted); font-size: var(--text-sm); font-weight: var(--weight-medium); }
+.archive-workspace svg { width: 16px; height: 16px; color: var(--color-text-faint); flex: none; }
+.archive-workspace .path { font-family: var(--font-mono); font-size: var(--text-xs); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.archive-workspace .count { margin-left: auto; color: var(--color-text-faint); font-weight: var(--weight-regular); font-size: var(--text-xs); flex: none; }
+.archive-row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: var(--space-3); align-items: center; padding: var(--space-3) var(--space-4); border-top: 1px solid var(--color-line); }
+.archive-row:first-child { border-top: none; }
+.archive-row:hover { background: var(--color-surface-sunken); }
+.archive-meta { min-width: 0; }
+.archive-name { font-size: var(--text-base); font-weight: var(--weight-medium); color: var(--color-text); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.archive-time { margin-top: 2px; font-size: var(--text-xs); color: var(--color-text-faint); font-family: var(--font-mono); }
+.archive-draining { margin-bottom: var(--space-3); padding: var(--space-2) var(--space-3); border-radius: var(--radius-md); background: var(--color-accent-soft); color: var(--color-accent-hover); font-size: var(--text-sm); }
+.archive-empty { padding: var(--space-6) var(--space-4); border: 1px solid var(--color-line); border-radius: var(--radius-xl); color: var(--color-text-faint); font-size: var(--text-sm); text-align: center; background: var(--color-bg); }
+@media (max-width: 640px) {
+  .archive-toolbar { flex-direction: column; align-items: stretch; }
+  .archive-search { min-width: 0; }
+}
+/* Enlarge the settings frame a bit (Dialog `xl` = 760px wide, fixed-height
+   680px). Scoped to this dialog only. */
+:deep(.ui-dialog) { width: min(980px, 96vw); }
+:deep(.ui-dialog--fixed-height) { height: min(780px, calc(100vh - var(--space-8) * 2)); }
 </style>
diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index 00add89630..2f3776950d 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -1694,6 +1694,30 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     }
   }
 
+  /** Restore an archived session — calls API, then puts the returned session
+   *  back at the front of the list so it reappears in the sidebar. */
+  async function restoreSession(id: string): Promise<boolean> {
+    try {
+      const restored = await getKimiWebApi().restoreSession(id);
+      upsertSessionFront(restored);
+      return true;
+    } catch (err) {
+      pushOperationFailure('restoreSession', err, { sessionId: id });
+      return false;
+    }
+  }
+
+  /** List archived sessions (server-side `archived_only` filter). Kept separate
+   *  from the per-workspace active list — callers (e.g. Settings) hold the page
+   *  locally and do their own search/filter/sort. */
+  function loadArchivedSessions(input?: { beforeId?: string; pageSize?: number }) {
+    return getKimiWebApi().listSessions({
+      archivedOnly: true,
+      beforeId: input?.beforeId,
+      pageSize: input?.pageSize ?? 50,
+    });
+  }
+
   /** Logout from the managed Kimi provider. Re-checks auth and reloads sessions. */
   async function logout(): Promise<void> {
     try {
@@ -2007,6 +2031,8 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     renameWorkspace,
     deleteWorkspace,
     archiveSession,
+    restoreSession,
+    loadArchivedSessions,
     logout,
     compact,
     forkSession,
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 9e149433e6..d136c63473 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -2522,6 +2522,8 @@ export function useKimiWebClient() {
     reorderWorkspaces,
     setWorkspaceSortMode,
     archiveSession: workspaceState.archiveSession,
+    restoreSession: workspaceState.restoreSession,
+    loadArchivedSessions: workspaceState.loadArchivedSessions,
     compact: workspaceState.compact,
     forkSession: workspaceState.forkSession,
     undo: workspaceState.undo,
diff --git a/apps/kimi-web/src/i18n/locales/en/settings.ts b/apps/kimi-web/src/i18n/locales/en/settings.ts
index ae500f8024..a452bc7b11 100644
--- a/apps/kimi-web/src/i18n/locales/en/settings.ts
+++ b/apps/kimi-web/src/i18n/locales/en/settings.ts
@@ -6,6 +6,7 @@ export default {
     agent: 'Agent',
     account: 'Account',
     advanced: 'Advanced',
+    archived: 'Archived',
   },
   appearance: 'Appearance',
   notifications: 'Notifications',
@@ -47,4 +48,20 @@ export default {
   exportLogBtn: 'Export log',
   conversationToc: 'Show conversation outline',
   conversationTocHint: 'Show a clickable outline in the right margin to jump between messages',
+  archivedTitle: 'Archived sessions',
+  archivedDesc: 'Browse archived sessions, see their workspace path, name, and archive time, and restore them to the session list.',
+  archivedSearch: 'Search archived sessions',
+  archivedAllWorkspaces: 'All workspaces',
+  archivedSortLabel: 'Sort by',
+  archivedSortArchived: 'Archive time',
+  archivedSortCreated: 'Created time',
+  archivedSortName: 'Name',
+  archivedRestore: 'Restore',
+  archivedEmpty: 'No archived sessions yet',
+  archivedNoMatch: 'No matching archived sessions',
+  archivedSessionsCount: '{count} sessions',
+  archivedAt: 'Archived {time}',
+  archivedLoadMore: 'Load more',
+  archivedLoading: 'Loading…',
+  archivedLoadingAll: 'Loading all archived sessions…',
 };
diff --git a/apps/kimi-web/src/i18n/locales/zh/settings.ts b/apps/kimi-web/src/i18n/locales/zh/settings.ts
index 67e4f07f5c..34aa2f2939 100644
--- a/apps/kimi-web/src/i18n/locales/zh/settings.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/settings.ts
@@ -6,6 +6,7 @@ export default {
     agent: 'Agent',
     account: '账户',
     advanced: '高级',
+    archived: '已归档',
   },
   appearance: '外观',
   notifications: '通知',
@@ -47,4 +48,20 @@ export default {
   exportLogBtn: '导出日志',
   conversationToc: '显示对话目录',
   conversationTocHint: '在右侧显示可点击跳转的对话目录',
+  archivedTitle: '已归档会话',
+  archivedDesc: '查看已归档会话，确认其所属工作区路径、会话名称和归档时间，并可恢复到会话列表。',
+  archivedSearch: '搜索已归档会话',
+  archivedAllWorkspaces: '所有工作区',
+  archivedSortLabel: '排序方式',
+  archivedSortArchived: '归档时间',
+  archivedSortCreated: '创建时间',
+  archivedSortName: '按字母顺序',
+  archivedRestore: '恢复',
+  archivedEmpty: '还没有归档的会话',
+  archivedNoMatch: '没有匹配的已归档会话',
+  archivedSessionsCount: '{count} 个会话',
+  archivedAt: '归档于 {time}',
+  archivedLoadMore: '加载更多',
+  archivedLoading: '加载中…',
+  archivedLoadingAll: '正在加载全部归档会话…',
 };
diff --git a/packages/server/src/lib/sessionArchive.ts b/packages/server/src/lib/sessionArchive.ts
new file mode 100644
index 0000000000..c784662377
--- /dev/null
+++ b/packages/server/src/lib/sessionArchive.ts
@@ -0,0 +1,109 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
+
+import { SessionNotFoundError } from '@moonshot-ai/agent-core';
+
+/**
+ * Temporary server-side session restore.
+ *
+ * TODO: remove once `@moonshot-ai/agent-core` exposes `ISessionService.restore`
+ * natively. At that point the `:restore` route should delegate to the service
+ * instead of rewriting `state.json` here.
+ *
+ * Archive is a boolean flag (`archived`) persisted in each session's
+ * `<sessionDir>/state.json`. agent-core's `SessionStore` can set it to `true`
+ * (`archive`) but has no inverse; while agent-core is being refactored we flip
+ * it back from the server by:
+ *   1. reading `<homeDir>/session_index.jsonl` to resolve `sessionId -> sessionDir`;
+ *   2. validating the resolved dir is inside `<homeDir>/sessions` (defense
+ *      against a tampered index);
+ *   3. read-modify-write `state.json` with `archived: false`.
+ *
+ * This mirrors `SessionStore.archive` and publishes no event (same as archive).
+ * The query read-model rebuilds from the store on every call, so a restored
+ * session shows up in subsequent lists with no extra invalidation.
+ */
+
+interface SessionIndexEntry {
+  readonly sessionId: string;
+  readonly sessionDir: string;
+  readonly workDir: string;
+}
+
+export async function restoreArchivedSession(homeDir: string, sessionId: string): Promise<void> {
+  const sessionDir = await findSessionDir(homeDir, sessionId);
+  if (sessionDir === undefined) {
+    throw new SessionNotFoundError(sessionId);
+  }
+
+  const statePath = join(sessionDir, 'state.json');
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await readFile(statePath, 'utf-8')) as unknown;
+  } catch {
+    throw new SessionNotFoundError(sessionId);
+  }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    throw new SessionNotFoundError(sessionId);
+  }
+
+  const next: Record<string, unknown> = {
+    ...(parsed as Record<string, unknown>),
+    archived: false,
+    updatedAt: new Date().toISOString(),
+  };
+  await writeFile(statePath, `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+}
+
+async function findSessionDir(homeDir: string, sessionId: string): Promise<string | undefined> {
+  const indexPath = join(homeDir, 'session_index.jsonl');
+  let raw: string;
+  try {
+    raw = await readFile(indexPath, 'utf-8');
+  } catch {
+    return undefined;
+  }
+
+  const sessionsDir = join(homeDir, 'sessions');
+  let found: string | undefined;
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === '') continue;
+    const entry = parseIndexLine(trimmed);
+    if (entry === undefined || entry.sessionId !== sessionId) continue;
+    const sessionDir = resolve(entry.sessionDir);
+    if (!isAbsolute(entry.sessionDir)) continue;
+    if (!isPathInside(sessionsDir, sessionDir)) continue;
+    if (basename(sessionDir) !== entry.sessionId) continue;
+    // Last valid line wins, matching `readSessionIndex`'s Map semantics.
+    found = sessionDir;
+  }
+  return found;
+}
+
+function parseIndexLine(line: string): SessionIndexEntry | undefined {
+  try {
+    const parsed = JSON.parse(line) as unknown;
+    if (typeof parsed !== 'object' || parsed === null) return undefined;
+    const entry = parsed as Partial<SessionIndexEntry>;
+    if (
+      typeof entry.sessionId !== 'string' ||
+      typeof entry.sessionDir !== 'string' ||
+      typeof entry.workDir !== 'string'
+    ) {
+      return undefined;
+    }
+    return {
+      sessionId: entry.sessionId,
+      sessionDir: entry.sessionDir,
+      workDir: entry.workDir,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function isPathInside(parent: string, child: string): boolean {
+  const rel = relative(resolve(parent), resolve(child));
+  return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
diff --git a/packages/server/src/routes/sessions.ts b/packages/server/src/routes/sessions.ts
index 2c69bdb807..f8ae7c5b05 100644
--- a/packages/server/src/routes/sessions.ts
+++ b/packages/server/src/routes/sessions.ts
@@ -23,11 +23,12 @@ import {
   workspaceIdSchema,
   type Event,
 } from '@moonshot-ai/protocol';
-import { IPromptService, ISessionService, SessionNotFoundError, SessionUndoUnavailableError, ErrorCodes, KimiError, IWorkspaceRegistry, WorkspaceNotFoundError, IEventService, type IInstantiationService, type SessionClientTelemetry } from '@moonshot-ai/agent-core';
+import { IPromptService, ISessionService, SessionNotFoundError, SessionUndoUnavailableError, ErrorCodes, KimiError, IEnvironmentService, IWorkspaceRegistry, WorkspaceNotFoundError, IEventService, type IInstantiationService, type SessionClientTelemetry } from '@moonshot-ai/agent-core';
 import { z } from 'zod';
 
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { restoreArchivedSession } from '../lib/sessionArchive';
 import { defineRoute } from '../middleware/defineRoute';
 import { parseActionSuffix } from './action-suffix';
 
@@ -84,6 +85,7 @@ const sessionsListQueryCoercion = z
     status: sessionStatusSchema.optional(),
     include_archive: booleanQueryParam,
     exclude_empty: booleanQueryParam,
+    archived_only: booleanQueryParam,
 
     workspace_id: workspaceIdSchema.optional(),
   })
@@ -96,6 +98,14 @@ const sessionsListQueryCoercion = z
         params: { code: ErrorCode.VALIDATION_FAILED },
       });
     }
+    if (value.archived_only === true && value.include_archive === true) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'archived_only and include_archive are mutually exclusive',
+        path: ['archived_only'],
+        params: { code: ErrorCode.VALIDATION_FAILED },
+      });
+    }
   });
 
 const sessionChildrenListQueryCoercion = z
@@ -157,6 +167,71 @@ function headerString(headers: Record<string, unknown>, key: string): string | u
   return trimmed.length === 0 ? undefined : trimmed;
 }
 
+const DEFAULT_SESSION_LIST_PAGE_SIZE = 20;
+const MAX_SESSION_LIST_PAGE_SIZE = 100;
+
+type SessionListRequest = Parameters<ISessionService['list']>[0];
+type SessionListPage = Awaited<ReturnType<ISessionService['list']>>;
+type SessionListItem = SessionListPage['items'][number];
+type SessionListBaseQuery = Omit<SessionListRequest, 'before_id' | 'after_id' | 'page_size' | 'status'>;
+type SessionListCursor = Pick<SessionListRequest, 'before_id' | 'after_id' | 'page_size'>;
+
+function normalizeSessionListPageSize(cursor: SessionListCursor): number {
+  const requested = cursor.page_size ?? DEFAULT_SESSION_LIST_PAGE_SIZE;
+  return Math.min(Math.max(requested, 1), MAX_SESSION_LIST_PAGE_SIZE);
+}
+
+async function listSessionsWithRouteFilter(
+  fetchPage: (query: SessionListRequest) => Promise<SessionListPage>,
+  baseQuery: SessionListBaseQuery,
+  cursor: SessionListCursor,
+  predicate: (session: SessionListItem) => boolean,
+): Promise<SessionListPage> {
+  const targetSize = normalizeSessionListPageSize(cursor);
+  const forward = cursor.after_id !== undefined && cursor.before_id === undefined;
+
+  const matches: SessionListItem[] = [];
+  // Forward starts from the after_id pivot (the newest page above it); backward
+  // starts from before_id (or the newest when there is no cursor). After the first
+  // page both drain toward older sessions via before_id. In forward mode we stop
+  // the moment we reach the pivot session itself, so paging stays within the
+  // after_id bound and never reintroduces the pivot or anything older.
+  let beforeId = forward ? undefined : cursor.before_id;
+  let afterId = forward ? cursor.after_id : undefined;
+  let coreHasMore = true;
+
+  while (matches.length <= targetSize && coreHasMore) {
+    const page = await fetchPage({
+      ...baseQuery,
+      before_id: beforeId,
+      after_id: afterId,
+      page_size: MAX_SESSION_LIST_PAGE_SIZE,
+    });
+    if (page.items.length === 0) break;
+
+    let hitPivot = false;
+    for (const session of page.items) {
+      if (forward && session.id === afterId) {
+        hitPivot = true;
+        break;
+      }
+      if (predicate(session)) matches.push(session);
+    }
+    coreHasMore = page.has_more && !hitPivot;
+    if (!coreHasMore) break;
+
+    const nextBeforeId = page.items[page.items.length - 1]?.id;
+    if (nextBeforeId === undefined || nextBeforeId === beforeId) break;
+    beforeId = nextBeforeId;
+    afterId = undefined;
+  }
+
+  return {
+    items: matches.slice(0, targetSize),
+    has_more: matches.length > targetSize,
+  };
+}
+
 export function registerSessionsRoutes(
   app: SessionRouteHost,
   ix: IInstantiationService,
@@ -267,15 +342,12 @@ export function registerSessionsRoutes(
     async (req, reply) => {
       try {
         const raw = req.query;
-        const baseQuery = {
-          before_id: raw.before_id,
-          after_id: raw.after_id,
-          page_size: raw.page_size,
-          status: raw.status,
-          includeArchive: raw.include_archive,
+        const archivedOnly = raw.archived_only === true;
+        const status = raw.status;
+        let baseQuery: SessionListBaseQuery = {
+          includeArchive: archivedOnly ? true : raw.include_archive,
           excludeEmpty: raw.exclude_empty,
         };
-        let query;
         if (raw.workspace_id !== undefined) {
           const registry = ix.invokeFunction((a) => a.get(IWorkspaceRegistry));
           let root: string;
@@ -290,11 +362,30 @@ export function registerSessionsRoutes(
             }
             throw err;
           }
-          query = { ...baseQuery, workDir: root };
-        } else {
-          query = baseQuery;
+          baseQuery = { ...baseQuery, workDir: root };
+        }
+
+        if (archivedOnly) {
+          const page = await listSessionsWithRouteFilter(
+            (query) => ix.invokeFunction((a) => a.get(ISessionService).list(query)),
+            baseQuery,
+            raw,
+            (session) =>
+              session.archived === true && (status === undefined || session.status === status),
+          );
+          reply.send(okEnvelope(page, req.id));
+          return;
         }
-        const page = await ix.invokeFunction((a) => a.get(ISessionService).list(query));
+
+        const page = await ix.invokeFunction((a) =>
+          a.get(ISessionService).list({
+            ...baseQuery,
+            before_id: raw.before_id,
+            after_id: raw.after_id,
+            page_size: raw.page_size,
+            status,
+          }),
+        );
         reply.send(okEnvelope(page, req.id));
       } catch (err) {
         sendMappedError(reply, req.id, err);
@@ -427,7 +518,7 @@ export function registerSessionsRoutes(
         const { tail } = req.params;
         const parsed = parseActionSuffix({
           tail,
-          allowedActions: ['fork', 'compact', 'undo', 'abort', 'btw', 'archive'] as const,
+          allowedActions: ['fork', 'compact', 'undo', 'abort', 'btw', 'archive', 'restore'] as const,
           resourceLabel: 'session',
         });
         if (parsed.kind !== 'action') {
@@ -485,6 +576,16 @@ export function registerSessionsRoutes(
           return;
         }
 
+        if (parsed.action === 'restore') {
+          const homeDir = ix.invokeFunction((a) => a.get(IEnvironmentService)).homeDir;
+          await restoreArchivedSession(homeDir, parsed.id);
+          const session = await ix.invokeFunction((a) =>
+            a.get(ISessionService).get(parsed.id),
+          );
+          reply.send(okEnvelope(session, req.id));
+          return;
+        }
+
         const body = undoSessionRequestSchema.parse(req.body);
         const result = await ix.invokeFunction((a) =>
           a.get(ISessionService).undo(parsed.id, body),
diff --git a/packages/server/test/sessions.e2e.test.ts b/packages/server/test/sessions.e2e.test.ts
index 46d662d792..103bd22f8b 100644
--- a/packages/server/test/sessions.e2e.test.ts
+++ b/packages/server/test/sessions.e2e.test.ts
@@ -856,3 +856,167 @@ describe('POST /api/v1/sessions/{session_id}:archive — archive', () => {
     expect(env.code).toBe(40401);
   });
 });
+
+describe('GET /api/v1/sessions?archived_only — archived-only list', () => {
+  it('returns only archived sessions and hides them from the default list', async () => {
+    const r = await bootDaemon();
+    const cwd = join(tmpDir, 'workspace-archived-only');
+    const created = envelopeOf<{ id: string }>(
+      (await appOf(r).inject({
+        method: 'POST',
+        url: '/api/v1/sessions',
+        payload: { metadata: { cwd } },
+      })).json(),
+    ).data!;
+
+    await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${created.id}:archive`,
+      payload: {},
+    });
+
+    const defaultList = envelopeOf<{ items: Array<{ id: string }> }>(
+      (await appOf(r).inject({ method: 'GET', url: '/api/v1/sessions' })).json(),
+    );
+    expect(defaultList.data!.items.find((s) => s.id === created.id)).toBeUndefined();
+
+    const archivedOnly = envelopeOf<{ items: Array<{ id: string; archived?: boolean }>; has_more: boolean }>(
+      (await appOf(r).inject({ method: 'GET', url: '/api/v1/sessions?archived_only=true' })).json(),
+    );
+    expect(archivedOnly.code).toBe(0);
+    const listed = archivedOnly.data!.items.find((s) => s.id === created.id);
+    expect(listed).toBeDefined();
+    expect(listed!.archived).toBe(true);
+    // No live session should leak into the archived-only view.
+    expect(archivedOnly.data!.items.every((s) => s.archived === true)).toBe(true);
+  });
+
+  it('paginates archived_only without returning empty filtered pages', async () => {
+    const r = await bootDaemon();
+    const cwd = join(tmpDir, 'workspace-archived-only-pagination');
+
+    const archivedOlder = envelopeOf<{ id: string }>(
+      (await appOf(r).inject({
+        method: 'POST',
+        url: '/api/v1/sessions',
+        payload: { metadata: { cwd } },
+      })).json(),
+    ).data!;
+    await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${archivedOlder.id}:archive`,
+      payload: {},
+    });
+
+    const archivedNewer = envelopeOf<{ id: string }>(
+      (await appOf(r).inject({
+        method: 'POST',
+        url: '/api/v1/sessions',
+        payload: { metadata: { cwd } },
+      })).json(),
+    ).data!;
+    await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${archivedNewer.id}:archive`,
+      payload: {},
+    });
+
+    await appOf(r).inject({
+      method: 'POST',
+      url: '/api/v1/sessions',
+      payload: { metadata: { cwd } },
+    });
+    await appOf(r).inject({
+      method: 'POST',
+      url: '/api/v1/sessions',
+      payload: { metadata: { cwd } },
+    });
+
+    const first = envelopeOf<{ items: Array<{ id: string; archived?: boolean }>; has_more: boolean }>(
+      (await appOf(r).inject({
+        method: 'GET',
+        url: '/api/v1/sessions?archived_only=true&page_size=1',
+      })).json(),
+    );
+    expect(first.code).toBe(0);
+    expect(first.data!.items).toHaveLength(1);
+    expect(first.data!.items[0]).toMatchObject({ id: archivedNewer.id, archived: true });
+    expect(first.data!.has_more).toBe(true);
+
+    const second = envelopeOf<{ items: Array<{ id: string; archived?: boolean }>; has_more: boolean }>(
+      (await appOf(r).inject({
+        method: 'GET',
+        url: `/api/v1/sessions?archived_only=true&page_size=1&before_id=${archivedNewer.id}`,
+      })).json(),
+    );
+    expect(second.code).toBe(0);
+    expect(second.data!.items).toHaveLength(1);
+    expect(second.data!.items[0]).toMatchObject({ id: archivedOlder.id, archived: true });
+    expect(second.data!.has_more).toBe(false);
+  });
+
+  it('rejects archived_only together with include_archive', async () => {
+    const r = await bootDaemon();
+    const res = await appOf(r).inject({
+      method: 'GET',
+      url: '/api/v1/sessions?archived_only=true&include_archive=true',
+    });
+    const env = envelopeOf<unknown>(res.json());
+    expect(env.code).toBe(40001);
+  });
+});
+
+describe('POST /api/v1/sessions/{session_id}:restore — restore', () => {
+  it('restores an archived session so it reappears in the default list', async () => {
+    const r = await bootDaemon();
+    const cwd = join(tmpDir, 'workspace-restore');
+    const created = envelopeOf<{ id: string }>(
+      (await appOf(r).inject({
+        method: 'POST',
+        url: '/api/v1/sessions',
+        payload: { metadata: { cwd } },
+      })).json(),
+    ).data!;
+
+    await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${created.id}:archive`,
+      payload: {},
+    });
+
+    const restoreRes = await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${created.id}:restore`,
+      payload: {},
+    });
+    const restoreEnv = envelopeOf<unknown>(restoreRes.json());
+    expect(restoreEnv.code).toBe(0);
+    const session = sessionSchema.parse(restoreEnv.data);
+    expect(session.id).toBe(created.id);
+    expect(session.archived).toBe(false);
+
+    const defaultList = envelopeOf<{ items: Array<{ id: string; archived?: boolean }> }>(
+      (await appOf(r).inject({ method: 'GET', url: '/api/v1/sessions' })).json(),
+    );
+    const relisted = defaultList.data!.items.find((s) => s.id === created.id);
+    expect(relisted).toBeDefined();
+    expect(relisted!.archived).toBe(false);
+
+    const getRes = envelopeOf<unknown>(
+      (await appOf(r).inject({ method: 'GET', url: `/api/v1/sessions/${created.id}` })).json(),
+    );
+    expect(getRes.code).toBe(0);
+    expect(sessionSchema.parse(getRes.data).archived).toBe(false);
+  });
+
+  it('returns 40401 for unknown id', async () => {
+    const r = await bootDaemon();
+    const res = await appOf(r).inject({
+      method: 'POST',
+      url: '/api/v1/sessions/sess_missing:restore',
+      payload: {},
+    });
+    const env = envelopeOf<unknown>(res.json());
+    expect(env.code).toBe(40401);
+  });
+});