diff --git a/docs/backend-semantic-contract.md b/docs/backend-semantic-contract.md
index a57329e57..c269845a4 100644
--- a/docs/backend-semantic-contract.md
+++ b/docs/backend-semantic-contract.md
@@ -323,6 +323,26 @@ The Today aggregate is now a complete backend surface (the earlier
 - Tested for both empty-state and wired-sections behavior
   (`internal/today/handler_test.go`).
 - Daily Plan is subsumed by this aggregate (`cmd/app/routes.go` — `GET /api/admin/commitment/today`).
+- **Day-progress is due-based, not plan-based** (2026-06-30). The human Today
+  dashboard's open / completed / overdue figures derive from what is actually
+  scheduled today — due-today + recurring-due + in_progress (open), today's
+  completions incl. recurring `last_completed_on=today` (completed), and
+  past-due-still-open (overdue) — so the strip is meaningful without a committed
+  `daily_plan`. The aggregate exposes the contributing sections (including a new
+  `completed_todos`) and the front end sums their lengths; the old
+  `PlanCompletion` block (which counted `daily_plan_items`, and whose `.status`
+  column has no write path) was removed (`internal/today/today.go`,
+  `internal/today/handler.go::loadCompleted`). The MCP `brief(mode=reflection)`
+  tool **deliberately stays plan-based** — it reports plan-vs-actual over the
+  day's committed `daily_plan_items` for the planner agent
+  (`internal/mcp/brief.go::fillBriefReflection`). The two surfaces answer
+  different questions (human: "what is my actual day"; planner agent: "how did
+  the committed plan resolve"), so this divergence is intentional, not drift.
+- **Routines have a manage-all surface.** Beyond the due-today list, every active
+  recurring schedule is exposed via `GET /api/admin/commitment/todos/recurring`'s
+  `all` bucket (`internal/todo/query.sql::AllRecurringTodoItems`), backing the
+  admin Routines overview — the home for a routine on its off-days, which the
+  due-today list and the recurring-excluding Todos status tabs do not show.
 
 ### G. Carried-forward human-resolved decisions (do not re-litigate)
 
diff --git a/frontend/src/app/admin/admin-layout/admin-nav.config.ts b/frontend/src/app/admin/admin-layout/admin-nav.config.ts
index c3f18c0e7..8d6430a05 100644
--- a/frontend/src/app/admin/admin-layout/admin-nav.config.ts
+++ b/frontend/src/app/admin/admin-layout/admin-nav.config.ts
@@ -10,6 +10,7 @@ import {
   Home,
   Inbox as InboxIcon,
   Layers,
+  Repeat,
   Rss,
   Search,
   Sparkles,
@@ -90,6 +91,13 @@ export const ADMIN_NAV: readonly AdminNavGroup[] = [
         shortcutHint: 'G T',
         testId: 'admin-nav-todos',
       },
+      {
+        label: 'Routines',
+        route: '/admin/daily/routines',
+        icon: Repeat,
+        shortcutHint: '',
+        testId: 'admin-nav-routines',
+      },
     ],
   },
   {
diff --git a/frontend/src/app/admin/commitment/inbox/inbox.page.html b/frontend/src/app/admin/commitment/inbox/inbox.page.html
new file mode 100644
index 000000000..8a41fe3d8
--- /dev/null
+++ b/frontend/src/app/admin/commitment/inbox/inbox.page.html
@@ -0,0 +1,133 @@
+<!-- Persistent capture bar -->
+<form
+  class="flex h-[42px] shrink-0 items-center gap-2.5 border-b border-border bg-panel px-5"
+  (submit)="$event.preventDefault(); submitCapture()"
+  data-testid="gtd-capture-form"
+>
+  <lucide-icon
+    [img]="PlusIcon"
+    [size]="15"
+    class="shrink-0 text-fg-subtle"
+    aria-hidden="true"
+  />
+  <label for="gtd-capture" class="sr-only">Capture a thought</label>
+  <input
+    #captureInput
+    id="gtd-capture"
+    type="text"
+    [value]="captureDraft()"
+    (input)="captureDraft.set(readInput($event))"
+    placeholder="Capture a thought — it lands in the inbox, unclarified…"
+    class="h-full min-w-0 flex-1 bg-transparent text-[13px] text-fg outline-hidden placeholder:text-fg-faint"
+    data-testid="gtd-capture-input"
+  />
+  <kbd
+    class="shrink-0 rounded-sm border border-border border-b-2 bg-elevated px-1.5 font-mono text-[10px] whitespace-nowrap text-fg-muted"
+  >
+    ↵ capture
+  </kbd>
+</form>
+
+<!-- Scrollable inbox list -->
+<div class="min-h-0 flex-1 overflow-y-auto" data-testid="gtd-list">
+  @if (store.viewError()) {
+    <div
+      class="flex flex-col items-center gap-2 p-10 text-center"
+      data-testid="gtd-error"
+    >
+      <lucide-icon
+        [img]="HexagonIcon"
+        [size]="28"
+        class="mb-1 text-error opacity-70"
+        aria-hidden="true"
+      />
+      <h2 class="font-display text-sm font-semibold text-fg">
+        Couldn’t load this view
+      </h2>
+      <p class="max-w-[280px] text-xs leading-relaxed text-fg-subtle">
+        The todos service didn’t respond. Nothing was lost.
+      </p>
+      <button
+        type="button"
+        (click)="store.reloadActive()"
+        data-testid="gtd-retry"
+        class="mt-2 rounded-sm border border-border bg-elevated px-3 py-1.5 text-xs text-fg-muted transition-colors hover:border-brand hover:text-brand"
+      >
+        Retry
+      </button>
+    </div>
+  } @else if (store.viewLoading()) {
+    <div
+      class="flex flex-col gap-1 px-5 py-3"
+      data-testid="gtd-loading"
+      aria-busy="true"
+      aria-label="Loading inbox"
+    >
+      @for (row of [1, 2, 3, 4, 5, 6]; track row) {
+        <div class="h-8 animate-pulse rounded-sm bg-elevated"></div>
+      }
+    </div>
+  } @else {
+    @if (store.rows().length === 0) {
+      <app-empty-state
+        [icon]="HexagonIcon"
+        [title]="store.emptyCopy().title"
+        [description]="store.emptyCopy().description"
+      />
+    }
+    <div role="list">
+      @for (row of store.rows(); let i = $index; track row.id) {
+        <app-gtd-row
+          [item]="row"
+          [view]="view"
+          [selected]="i === store.selection()"
+          [busy]="store.busy()"
+          (rowHover)="store.selectedIndex.set(i)"
+          (openDetail)="store.openClarify(row)"
+          (clarify)="store.openClarify(row)"
+          (advance)="store.advanceRow(row)"
+          (deferRow)="store.deferRow(row)"
+          (dropRow)="store.dropRow(row)"
+          (pull)="store.pullRow(row)"
+          [attr.data-testid]="'gtd-row-' + i"
+        />
+      }
+    </div>
+  }
+</div>
+
+<!-- Contextual keyboard hint bar -->
+<footer
+  class="flex shrink-0 items-center gap-4 border-t border-border bg-panel px-5 py-2 font-mono text-[11px] text-fg-subtle"
+  data-testid="gtd-kbar"
+>
+  @for (hint of store.legend(); track hint.keys) {
+    <span class="inline-flex items-center gap-1.5">
+      <kbd
+        class="rounded-sm border border-border border-b-2 bg-elevated px-1.5 font-mono text-[10px] text-fg-muted"
+      >
+        {{ hint.keys }}
+      </kbd>
+      {{ hint.label }}
+    </span>
+  }
+  <span
+    class="ml-auto tabular-nums"
+    aria-live="polite"
+    data-testid="gtd-count"
+  >
+    {{ store.itemCount() }} {{ store.itemCount() === 1 ? 'item' : 'items' }}
+  </span>
+</footer>
+
+<!-- Clarify dialog -->
+@if (store.clarifyTarget(); as target) {
+  <app-clarify-modal
+    [item]="target"
+    [busy]="store.busy()"
+    (clarified)="store.clarified($event)"
+    (deferInstead)="store.deferInstead()"
+    (dropInstead)="store.dropInstead()"
+    (closed)="store.closeClarify()"
+  />
+}
diff --git a/frontend/src/app/admin/commitment/inbox/inbox.page.spec.ts b/frontend/src/app/admin/commitment/inbox/inbox.page.spec.ts
new file mode 100644
index 000000000..e8498e8db
--- /dev/null
+++ b/frontend/src/app/admin/commitment/inbox/inbox.page.spec.ts
@@ -0,0 +1,155 @@
+import { TestBed, type ComponentFixture } from '@angular/core/testing';
+import { provideHttpClient, withXhr } from '@angular/common/http';
+import {
+  HttpTestingController,
+  provideHttpClientTesting,
+} from '@angular/common/http/testing';
+import { InboxPageComponent } from './inbox.page';
+import type { TodoRow } from '../../../core/services/todo.service';
+
+// Pins the dedicated Inbox page against the commitment contract: the
+// backlog list feeds the inbox view (per_page=200, every live state), the
+// capture bar POSTs a raw todo, and an inbox row's Clarify opens the
+// clarify dialog. The store spins up its three resources, so the plan /
+// history reads are flushed even though the inbox surface never shows them.
+
+const TODOS_URL = '/api/admin/commitment/todos';
+const PLAN_URL = '/api/admin/commitment/daily-plan';
+const PROJECTS_URL = '/api/admin/commitment/projects';
+
+const backlogRows: TodoRow[] = [
+  {
+    id: 'inbox-1',
+    title: 'Raw capture',
+    state: 'inbox',
+    created_by: 'human',
+    created_at: '2026-06-10T07:00:00Z',
+    updated_at: '2026-06-10T07:00:00Z',
+  },
+  {
+    id: 'inbox-2',
+    title: 'Second capture',
+    state: 'inbox',
+    created_by: 'hermes',
+    created_at: '2026-06-10T07:30:00Z',
+    updated_at: '2026-06-10T07:30:00Z',
+  },
+];
+
+const planFixture = {
+  date: '2026-06-30',
+  items: [],
+  total: 0,
+  done: 0,
+  overdue_count: 0,
+};
+
+const historyFixture: unknown[] = [];
+
+describe('InboxPageComponent', () => {
+  let fixture: ComponentFixture<InboxPageComponent>;
+  let httpMock: HttpTestingController;
+
+  afterEach(() => {
+    httpMock.verify();
+    TestBed.resetTestingModule();
+  });
+
+  function el(): HTMLElement {
+    return fixture.nativeElement as HTMLElement;
+  }
+
+  function testid(id: string): HTMLElement | null {
+    return el().querySelector(`[data-testid="${id}"]`);
+  }
+
+  async function settle(): Promise<void> {
+    await fixture.whenStable();
+    fixture.detectChanges();
+  }
+
+  function flushBacklog(): void {
+    httpMock
+      .expectOne(
+        (r) =>
+          r.url.endsWith(TODOS_URL) &&
+          r.params.get('per_page') === '200' &&
+          r.params.get('state') === 'inbox,todo,in_progress,someday',
+      )
+      .flush({ data: backlogRows });
+  }
+
+  // Flush the three initial backlog-store loads, then settle (whenStable
+  // must not be awaited while a request is still open in zoneless mode).
+  async function render(): Promise<void> {
+    TestBed.configureTestingModule({
+      imports: [InboxPageComponent],
+      providers: [provideHttpClient(withXhr()), provideHttpClientTesting()],
+    });
+    httpMock = TestBed.inject(HttpTestingController);
+    fixture = TestBed.createComponent(InboxPageComponent);
+    fixture.detectChanges();
+    flushBacklog();
+    httpMock
+      .expectOne((r) => r.url.includes(PLAN_URL))
+      .flush({ data: planFixture });
+    httpMock
+      .expectOne((r) => r.url.endsWith(`${TODOS_URL}/history`))
+      .flush({ data: historyFixture });
+    await settle();
+  }
+
+  it('should render the inbox rows with the inbox count when loaded', async () => {
+    await render();
+
+    expect(testid('gtd-row-0')?.textContent).toContain('Raw capture');
+    expect(testid('gtd-row-1')?.textContent).toContain('Second capture');
+    expect(testid('gtd-count')?.textContent).toContain('2 items');
+  });
+
+  it('should post the capture to the create endpoint and clear the bar', async () => {
+    await render();
+
+    const input = testid('gtd-capture-input') as HTMLInputElement;
+    input.value = 'Look into NATS JetStream';
+    input.dispatchEvent(new Event('input'));
+    fixture.detectChanges();
+    (testid('gtd-capture-form') as HTMLFormElement).dispatchEvent(
+      new Event('submit'),
+    );
+
+    const post = httpMock.expectOne(
+      (r) => r.url.endsWith(TODOS_URL) && r.method === 'POST',
+    );
+    expect(post.request.body).toEqual({ title: 'Look into NATS JetStream' });
+    post.flush({
+      data: {
+        id: 'new-1',
+        title: 'Look into NATS JetStream',
+        state: 'inbox',
+        created_by: 'human',
+        created_at: '2026-06-10T08:00:00Z',
+        updated_at: '2026-06-10T08:00:00Z',
+      },
+    });
+    TestBed.tick();
+    flushBacklog();
+    await settle();
+
+    expect((testid('gtd-capture-input') as HTMLInputElement).value).toBe('');
+    expect(testid('gtd-list')?.textContent).toContain('Raw capture');
+  });
+
+  it('should open the clarify modal when an inbox row Clarify is clicked', async () => {
+    await render();
+
+    (testid('gtd-row-clarify') as HTMLButtonElement).click();
+    fixture.detectChanges();
+    httpMock
+      .expectOne((r) => r.url.includes(PROJECTS_URL))
+      .flush({ data: [] });
+    await settle();
+
+    expect(testid('clarify-modal')).toBeTruthy();
+  });
+});
diff --git a/frontend/src/app/admin/commitment/inbox/inbox.page.ts b/frontend/src/app/admin/commitment/inbox/inbox.page.ts
new file mode 100644
index 000000000..9dc7a8768
--- /dev/null
+++ b/frontend/src/app/admin/commitment/inbox/inbox.page.ts
@@ -0,0 +1,119 @@
+import {
+  ChangeDetectionStrategy,
+  Component,
+  DestroyRef,
+  inject,
+  signal,
+  viewChildren,
+} from '@angular/core';
+import { Hexagon, LucideAngularModule, Plus } from 'lucide-angular';
+import { AdminTopbarService } from '../../admin-layout/admin-topbar.service';
+import { EmptyStateComponent } from '../../../shared/components/empty-state/empty-state.component';
+import { GtdRowComponent } from '../todos/gtd-row.component';
+import { ClarifyModalComponent } from '../todos/clarify-modal.component';
+import { GtdStore } from '../todos/gtd.store';
+import {
+  isInteractiveTarget,
+  keyActionFor,
+  type GtdView,
+} from '../todos/gtd-view';
+
+/**
+ * Inbox — the capture + triage surface over the unclarified backlog. A
+ * persistent capture bar drops raw thoughts into the inbox; the list
+ * below is the inbox rows with j/k + verb keyboard triage and the
+ * clarify dialog. Reuses the GTD backlog store, row, and clarify modal,
+ * locked to the inbox view (no tabs). State and mutations live in the
+ * page-provided {@link GtdStore}, so they die with the route.
+ */
+@Component({
+  selector: 'app-inbox-page',
+  imports: [
+    LucideAngularModule,
+    EmptyStateComponent,
+    GtdRowComponent,
+    ClarifyModalComponent,
+  ],
+  providers: [GtdStore],
+  templateUrl: './inbox.page.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  host: {
+    class: 'flex min-h-full flex-1 flex-col',
+    '(document:keydown)': 'handleKeydown($event)',
+  },
+})
+export class InboxPageComponent {
+  protected readonly store = inject(GtdStore);
+  private readonly topbar = inject(AdminTopbarService);
+  private readonly destroyRef = inject(DestroyRef);
+
+  protected readonly HexagonIcon = Hexagon;
+  protected readonly PlusIcon = Plus;
+  protected readonly view: GtdView = 'inbox';
+  protected readonly captureDraft = signal('');
+
+  private readonly gtdRows = viewChildren(GtdRowComponent);
+
+  constructor() {
+    this.store.setView('inbox');
+    this.topbar.set({ title: 'Inbox', crumbs: ['Daily', 'Inbox'] });
+    this.destroyRef.onDestroy(() => this.topbar.reset());
+  }
+
+  protected readInput(event: Event): string {
+    return (event.target as HTMLInputElement).value;
+  }
+
+  protected submitCapture(): void {
+    const title = this.captureDraft().trim();
+    if (!title) return;
+    this.store.capture(title, () => this.captureDraft.set(''));
+  }
+
+  protected handleKeydown(event: KeyboardEvent): void {
+    if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey)
+      return;
+    if (this.store.clarifyTarget() !== null) return;
+    if (isInteractiveTarget(event.target)) return;
+    const rows = this.store.rows();
+    if (rows.length === 0) return;
+    const action = keyActionFor(event.key, this.view);
+    if (!action) return;
+    event.preventDefault();
+    const index = this.store.selection();
+    const row = rows[index];
+    // Inbox actions that open the clarify dialog: focus the row's trigger
+    // first so the modal's focus trap restores focus to it on close.
+    if (action === 'advance' || action === 'clarify' || action === 'pull') {
+      this.gtdRows()[index]?.focusOpen();
+    }
+    switch (action) {
+      case 'down':
+        this.store.selectedIndex.set(Math.min(index + 1, rows.length - 1));
+        break;
+      case 'up':
+        this.store.selectedIndex.set(Math.max(index - 1, 0));
+        break;
+      case 'advance':
+        this.store.advanceRow(row);
+        break;
+      case 'clarify':
+        // Go through openClarify (not a raw clarifyTarget.set) so the clarify
+        // intent is reset — a stale 'pull' intent from an earlier t must not
+        // leak into a keyboard clarify and append the todo to today's plan.
+        this.store.openClarify(row);
+        break;
+      case 'defer':
+        this.store.deferRow(row);
+        break;
+      case 'drop':
+        this.store.dropRow(row);
+        break;
+      case 'pull':
+        this.store.pullRow(row);
+        break;
+      default:
+        break;
+    }
+  }
+}
diff --git a/frontend/src/app/admin/commitment/routines/routines.page.html b/frontend/src/app/admin/commitment/routines/routines.page.html
new file mode 100644
index 000000000..68280978a
--- /dev/null
+++ b/frontend/src/app/admin/commitment/routines/routines.page.html
@@ -0,0 +1,106 @@
+<!-- Intro -->
+<header
+  class="flex shrink-0 items-center gap-2.5 border-b border-border bg-panel px-5 py-3"
+>
+  <lucide-icon
+    [img]="RepeatIcon"
+    [size]="15"
+    class="shrink-0 text-fg-subtle"
+    aria-hidden="true"
+  />
+  <p class="text-[13px] text-fg-subtle">
+    Every routine you keep and when it last ran. Edit a routine from its detail
+    on the Todos page; complete today’s occurrence on Today.
+  </p>
+</header>
+
+<!-- List -->
+<div class="min-h-0 flex-1 overflow-y-auto" data-testid="routines-list">
+  @if (isError()) {
+    <div
+      class="flex flex-col items-center gap-2 p-10 text-center"
+      data-testid="routines-error"
+    >
+      <lucide-icon
+        [img]="RepeatIcon"
+        [size]="28"
+        class="mb-1 text-error opacity-70"
+        aria-hidden="true"
+      />
+      <h2 class="font-display text-sm font-semibold text-fg">
+        Couldn’t load routines
+      </h2>
+      <p class="max-w-[280px] text-xs leading-relaxed text-fg-subtle">
+        The todos service didn’t respond. Nothing was lost.
+      </p>
+      <button
+        type="button"
+        (click)="retry()"
+        data-testid="routines-retry"
+        class="mt-2 rounded-sm border border-border bg-elevated px-3 py-1.5 text-xs text-fg-muted transition-colors hover:border-brand hover:text-brand"
+      >
+        Retry
+      </button>
+    </div>
+  } @else if (isLoading()) {
+    <div
+      class="flex flex-col gap-1 px-5 py-3"
+      data-testid="routines-loading"
+      aria-busy="true"
+      aria-label="Loading routines"
+    >
+      @for (row of [1, 2, 3, 4]; track row) {
+        <div class="h-8 animate-pulse rounded-sm bg-elevated"></div>
+      }
+    </div>
+  } @else if (routines().length === 0) {
+    <app-empty-state
+      [icon]="RepeatIcon"
+      title="No routines yet"
+      description="Make a todo recurring from its detail panel and it shows up here."
+    />
+  } @else {
+    <div role="list">
+      @for (routine of routines(); track routine.id) {
+        <div
+          role="listitem"
+          class="flex min-h-9 items-center gap-2.5 border-b border-border-faint px-5 py-2"
+          data-testid="routines-row"
+        >
+          <span class="min-w-0 flex-1 truncate text-[13px] text-fg">
+            {{ routine.title }}
+          </span>
+          @if (isDueToday(routine)) {
+            <span
+              class="shrink-0 rounded-sm bg-warn-bg px-1.5 py-0.5 font-mono text-[10px] text-warn"
+              data-testid="routines-due-today"
+            >
+              due today
+            </span>
+          }
+          @if (energyLevel(routine); as level) {
+            <app-energy-meter class="shrink-0" [level]="level" />
+          }
+          <span
+            class="shrink-0 rounded-sm bg-brand-muted px-1.5 py-0.5 font-mono text-[10px] text-brand"
+            data-testid="routines-schedule"
+          >
+            {{ scheduleLabel(routine) }}
+          </span>
+          <span
+            class="w-28 shrink-0 text-right font-mono text-[10px] text-fg-faint"
+            [attr.title]="
+              routine.last_completed_on ? 'Last completed' : 'Never completed'
+            "
+          >
+            @if (routine.last_completed_on) {
+              {{ routine.last_completed_on | date: 'MMM d' }}
+            } @else {
+              never run
+            }
+          </span>
+        </div>
+      }
+    </div>
+  }
+</div>
diff --git a/frontend/src/app/admin/commitment/routines/routines.page.spec.ts b/frontend/src/app/admin/commitment/routines/routines.page.spec.ts
new file mode 100644
index 000000000..b0fda92f3
--- /dev/null
+++ b/frontend/src/app/admin/commitment/routines/routines.page.spec.ts
@@ -0,0 +1,123 @@
+import { TestBed, type ComponentFixture } from '@angular/core/testing';
+import { provideHttpClient, withXhr } from '@angular/common/http';
+import {
+  HttpTestingController,
+  provideHttpClientTesting,
+} from '@angular/common/http/testing';
+import { RoutinesPageComponent } from './routines.page';
+
+const RECURRING_URL = '/api/admin/commitment/todos/recurring';
+
+const recurringFixture = {
+  due_today: [
+    {
+      id: 'r1',
+      title: 'Morning Japanese',
+      state: 'todo',
+      recur_weekdays: 127,
+      created_by: 'human',
+      created_at: '2026-06-01T07:00:00Z',
+      updated_at: '2026-06-01T07:00:00Z',
+    },
+  ],
+  all: [
+    {
+      id: 'r1',
+      title: 'Morning Japanese',
+      state: 'todo',
+      recur_weekdays: 127,
+      last_completed_on: null,
+      created_by: 'human',
+      created_at: '2026-06-01T07:00:00Z',
+      updated_at: '2026-06-01T07:00:00Z',
+    },
+    {
+      id: 'r2',
+      title: 'Weekly review',
+      state: 'todo',
+      recur_interval: 1,
+      recur_unit: 'weeks',
+      last_completed_on: '2026-06-28',
+      created_by: 'human',
+      created_at: '2026-06-01T07:00:00Z',
+      updated_at: '2026-06-01T07:00:00Z',
+    },
+  ],
+};
+
+describe('RoutinesPageComponent', () => {
+  let fixture: ComponentFixture<RoutinesPageComponent>;
+  let httpMock: HttpTestingController;
+
+  afterEach(() => {
+    httpMock.verify();
+    TestBed.resetTestingModule();
+  });
+
+  function el(): HTMLElement {
+    return fixture.nativeElement as HTMLElement;
+  }
+
+  function testid(id: string): HTMLElement | null {
+    return el().querySelector(`[data-testid="${id}"]`);
+  }
+
+  async function settle(): Promise<void> {
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    fixture.detectChanges();
+  }
+
+  async function render(): Promise<void> {
+    TestBed.configureTestingModule({
+      imports: [RoutinesPageComponent],
+      providers: [provideHttpClient(withXhr()), provideHttpClientTesting()],
+    });
+    httpMock = TestBed.inject(HttpTestingController);
+    fixture = TestBed.createComponent(RoutinesPageComponent);
+    fixture.detectChanges();
+    await settle();
+    httpMock
+      .expectOne((r) => r.url.endsWith(RECURRING_URL))
+      .flush({ data: recurringFixture });
+    await settle();
+  }
+
+  it('should list every active routine from the all bucket with its schedule', async () => {
+    await render();
+
+    const rows = el().querySelectorAll('[data-testid="routines-row"]');
+    expect(rows.length).toBe(2);
+    expect(rows[0]?.textContent).toContain('Morning Japanese');
+    expect(rows[0]?.textContent).toContain('daily');
+    expect(rows[1]?.textContent).toContain('Weekly review');
+    expect(rows[1]?.textContent).toContain('every 1w');
+  });
+
+  it('should mark a routine due today and show last-completed for the others', async () => {
+    await render();
+
+    // r1 is in due_today → marked; never run.
+    expect(testid('routines-due-today')).toBeTruthy();
+    const rows = el().querySelectorAll('[data-testid="routines-row"]');
+    expect(rows[0]?.textContent).toContain('never run');
+    // r2 is not due today and ran on Jun 28.
+    expect(rows[1]?.textContent).toContain('Jun 28');
+  });
+
+  it('should show the empty state when there are no routines', async () => {
+    TestBed.configureTestingModule({
+      imports: [RoutinesPageComponent],
+      providers: [provideHttpClient(withXhr()), provideHttpClientTesting()],
+    });
+    httpMock = TestBed.inject(HttpTestingController);
+    fixture = TestBed.createComponent(RoutinesPageComponent);
+    fixture.detectChanges();
+    await settle();
+    httpMock
+      .expectOne((r) => r.url.endsWith(RECURRING_URL))
+      .flush({ data: { due_today: [], all: [] } });
+    await settle();
+
+    expect(el().textContent).toContain('No routines yet');
+  });
+});
diff --git a/frontend/src/app/admin/commitment/routines/routines.page.ts b/frontend/src/app/admin/commitment/routines/routines.page.ts
new file mode 100644
index 000000000..84289a7ea
--- /dev/null
+++ b/frontend/src/app/admin/commitment/routines/routines.page.ts
@@ -0,0 +1,100 @@
+import {
+  ChangeDetectionStrategy,
+  Component,
+  DestroyRef,
+  computed,
+  inject,
+} from '@angular/core';
+import { rxResource } from '@angular/core/rxjs-interop';
+import { DatePipe } from '@angular/common';
+import { Repeat, LucideAngularModule } from 'lucide-angular';
+import {
+  TodoService,
+  type RecurringBuckets,
+  type TodoItem,
+} from '../../../core/services/todo.service';
+import { AdminTopbarService } from '../../admin-layout/admin-topbar.service';
+import { EmptyStateComponent } from '../../../shared/components/empty-state/empty-state.component';
+import { EnergyMeterComponent } from '../../../shared/components/energy-meter/energy-meter.component';
+import { energyOf, recurLabel } from '../todos/gtd-view';
+import type { EnergyLevel } from '../../../core/models/workbench.model';
+
+/**
+ * Routines — the overview of every active recurring schedule, not just the ones
+ * due today. It is the home for the routine-as-a-whole that the Today dashboard
+ * (which only shows what is due today) and the Todos status tabs (which exclude
+ * routines) deliberately do not surface. Read-only: a routine's schedule is
+ * edited from its detail panel on the Todos page; today's occurrence is
+ * completed on the Today dashboard. This view answers "what routines do I keep,
+ * and when did each last run".
+ */
+@Component({
+  selector: 'app-routines-page',
+  imports: [
+    DatePipe,
+    LucideAngularModule,
+    EmptyStateComponent,
+    EnergyMeterComponent,
+  ],
+  templateUrl: './routines.page.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  host: { class: 'flex min-h-full flex-1 flex-col' },
+})
+export class RoutinesPageComponent {
+  private readonly todoService = inject(TodoService);
+  private readonly topbar = inject(AdminTopbarService);
+  private readonly destroyRef = inject(DestroyRef);
+
+  protected readonly RepeatIcon = Repeat;
+
+  private readonly resource = rxResource<RecurringBuckets, void>({
+    stream: () => this.todoService.recurring(),
+  });
+
+  // Guard the read: rxResource.value() throws in the error state, so gate on
+  // hasValue() (the repo idiom) — a failed load shows the error UI, not a throw.
+  private readonly buckets = computed(() =>
+    this.resource.hasValue() ? this.resource.value() : undefined,
+  );
+
+  protected readonly isLoading = computed(
+    () => this.resource.status() === 'loading' && !this.buckets(),
+  );
+  protected readonly isError = computed(
+    () => this.resource.status() === 'error',
+  );
+
+  protected readonly routines = computed(() => this.buckets()?.all ?? []);
+
+  /** Ids due today, so each routine can show a "due today" marker. */
+  private readonly dueTodayIds = computed(
+    () => new Set((this.buckets()?.due_today ?? []).map((t) => t.id)),
+  );
+
+  constructor() {
+    this.topbar.set({ title: 'Routines', crumbs: ['Daily', 'Routines'] });
+    this.destroyRef.onDestroy(() => this.topbar.reset());
+  }
+
+  protected retry(): void {
+    this.resource.reload();
+  }
+
+  protected scheduleLabel(routine: TodoItem): string {
+    return (
+      recurLabel(
+        routine.recur_interval,
+        routine.recur_unit,
+        routine.recur_weekdays,
+      ) ?? 'recurring'
+    );
+  }
+
+  protected energyLevel(routine: TodoItem): EnergyLevel | null {
+    return energyOf(routine.energy);
+  }
+
+  protected isDueToday(routine: TodoItem): boolean {
+    return this.dueTodayIds().has(routine.id);
+  }
+}
diff --git a/frontend/src/app/admin/commitment/today/today-page.component.html b/frontend/src/app/admin/commitment/today/today-page.component.html
index a5a16bf38..a8ef4da3f 100644
--- a/frontend/src/app/admin/commitment/today/today-page.component.html
+++ b/frontend/src/app/admin/commitment/today/today-page.component.html
@@ -141,12 +141,12 @@ <h2 class="font-display text-sm font-semibold text-fg">
             <p
               class="font-display text-[22px] font-semibold text-fg tabular-nums"
             >
-              {{ figures().planned }}
+              {{ figures().open }}
             </p>
             <p
               class="font-mono text-[10px] tracking-wide text-fg-faint uppercase"
             >
-              Planned
+              Open
             </p>
           </div>
           <div>
@@ -164,15 +164,15 @@ <h2 class="font-display text-sm font-semibold text-fg">
           <div>
             <p
               class="font-display text-[22px] font-semibold tabular-nums"
-              [class.text-warn]="figures().deferred > 0"
-              [class.text-fg-subtle]="figures().deferred === 0"
+              [class.text-warn]="figures().overdue > 0"
+              [class.text-fg-subtle]="figures().overdue === 0"
             >
-              {{ figures().deferred }}
+              {{ figures().overdue }}
             </p>
             <p
               class="font-mono text-[10px] tracking-wide text-fg-faint uppercase"
             >
-              Deferred
+              Overdue
             </p>
           </div>
         </div>
@@ -184,7 +184,7 @@ <h2 class="font-display text-sm font-semibold text-fg">
             ></div>
             <div
               class="h-full bg-warn/70 transition-all"
-              [style.width.%]="figures().deferredWidth"
+              [style.width.%]="figures().overdueWidth"
             ></div>
           </div>
           <span
diff --git a/frontend/src/app/admin/commitment/today/today-page.component.spec.ts b/frontend/src/app/admin/commitment/today/today-page.component.spec.ts
index 3b8c88d56..b794b3fd6 100644
--- a/frontend/src/app/admin/commitment/today/today-page.component.spec.ts
+++ b/frontend/src/app/admin/commitment/today/today-page.component.spec.ts
@@ -84,8 +84,8 @@ function populatedBrief(): TodayBrief {
         updated_at: '2026-06-07T00:00:00Z',
       },
     ],
+    completed_todos: [],
     upcoming_todos: [],
-    plan_completion: { planned: 1, completed: 0, deferred: 0 },
     active_goals: [
       {
         id: 'g1',
@@ -117,9 +117,9 @@ function quietBrief(): TodayBrief {
     today_todos: [],
     active_todos: [],
     recurring_todos: [],
+    completed_todos: [],
     committed_todos: [],
     upcoming_todos: [],
-    plan_completion: { planned: 0, completed: 0, deferred: 0 },
     active_goals: [],
     rss_highlights: [],
   };
@@ -205,14 +205,17 @@ describe('TodayPageComponent', () => {
     expect(testid('today-plan-ip-dot')).toBeTruthy();
   });
 
-  it('should derive day-progress figures live from the committed rows', async () => {
+  it('should derive due-based day-progress figures from the section lengths', async () => {
     await render(populatedBrief());
+    const strip = testid('today-plan-completion');
+    // open = due-today(1) + recurring(1) + active(1) = 3; overdue(1); completed(0)
+    // → percent = round(0 / (3+1+0) * 100) = 0%. The committed plan does not count.
+    expect(strip?.textContent).toContain('Open');
+    expect(strip?.textContent).toContain('Completed');
+    expect(strip?.textContent).toContain('Overdue');
+    expect(strip?.textContent).not.toContain('Planned');
+    expect(strip?.textContent).not.toContain('Deferred');
     expect(testid('today-percent')?.textContent).toContain('0%');
-    expect(testid('today-plan-completion')?.textContent).toContain('Planned');
-    expect(testid('today-plan-completion')?.textContent).toContain(
-      'Completed',
-    );
-    expect(testid('today-plan-completion')?.textContent).toContain('Deferred');
   });
 
   it('should group loose todos and style the due chips per bucket', async () => {
@@ -252,7 +255,9 @@ describe('TodayPageComponent', () => {
     req.flush({});
     await settle();
 
-    expect(testid('today-percent')?.textContent).toContain('100%');
+    // Completing the one planned row adds it to today's completions: the strip is
+    // due-based, so completed becomes 1 of (open 3 + overdue 1 + completed 1) = 20%.
+    expect(testid('today-percent')?.textContent).toContain('20%');
     const notifications = TestBed.inject(NotificationService).notifications();
     expect(notifications.some((n) => n.message.includes('Marked done'))).toBe(
       true,
diff --git a/frontend/src/app/admin/commitment/today/today-page.component.ts b/frontend/src/app/admin/commitment/today/today-page.component.ts
index dd45715bc..b0c77fe0f 100644
--- a/frontend/src/app/admin/commitment/today/today-page.component.ts
+++ b/frontend/src/app/admin/commitment/today/today-page.component.ts
@@ -27,10 +27,9 @@ import {
   energyOf,
   greetingForHour,
   isQuietBrief,
+  markTodoCompleted,
   planAdvanceAction,
   recurrenceSummary,
-  removeLooseTodo,
-  removeRecurringTodo,
   truncateTitle,
 } from './today-view';
 import { AdminTopbarService } from '../../admin-layout/admin-topbar.service';
@@ -177,7 +176,13 @@ export class TodayPageComponent {
     this.todoService.advance(item.todo_id, action).subscribe({
       next: () => {
         this._busy.set(false);
-        this.brief.update((v) => (v ? applyPlanAdvance(v, item.id, action) : v));
+        this.brief.update((v) => {
+          if (!v) return v;
+          const advanced = applyPlanAdvance(v, item.id, action);
+          return action === 'complete'
+            ? markTodoCompleted(advanced, item.todo_id, item.todo_title)
+            : advanced;
+        });
         if (action === 'complete') {
           this.notifications.success(
             `Marked done · ${truncateTitle(item.todo_title)}`,
@@ -206,7 +211,7 @@ export class TodayPageComponent {
     complete$.subscribe({
       next: () => {
         this._busy.set(false);
-        this.brief.update((v) => (v ? removeLooseTodo(v, todo.id) : v));
+        this.brief.update((v) => (v ? markTodoCompleted(v, todo.id, todo.title) : v));
         this.notifications.success('Completed');
       },
       error: () => {
@@ -228,7 +233,7 @@ export class TodayPageComponent {
     this.todoService.advance(todo.id, 'complete').subscribe({
       next: () => {
         this._busy.set(false);
-        this.brief.update((v) => (v ? removeRecurringTodo(v, todo.id) : v));
+        this.brief.update((v) => (v ? markTodoCompleted(v, todo.id, todo.title) : v));
         this.notifications.success('Done for today');
       },
       error: () => {
diff --git a/frontend/src/app/admin/commitment/today/today-view.ts b/frontend/src/app/admin/commitment/today/today-view.ts
index 2ea056c92..ab1d7e82c 100644
--- a/frontend/src/app/admin/commitment/today/today-view.ts
+++ b/frontend/src/app/admin/commitment/today/today-view.ts
@@ -22,14 +22,14 @@ export interface LooseGroup {
   items: PendingDetail[];
 }
 
-/** Live day-progress figures derived from the committed plan rows. */
-export interface PlanFigures {
-  planned: number;
+/** Due-based day-progress figures for the strip, derived from section lengths. */
+export interface ProgressFigures {
+  open: number;
   completed: number;
-  deferred: number;
+  overdue: number;
   percent: number;
   doneWidth: number;
-  deferredWidth: number;
+  overdueWidth: number;
 }
 
 export const GOAL_VARIANT: Record<GoalStatus, BadgeVariant> = {
@@ -75,34 +75,28 @@ export function planAdvanceAction(
 }
 
 /**
- * Day-progress figures, counted live from the committed rows so the
- * strip and the plan stay on one source. plan_completion is only the
- * fallback when the plan section degraded to an empty list. Dropped
- * rows count toward no bucket, matching the backend aggregation.
+ * Day-progress figures for the strip, derived from the section lengths the page
+ * already renders: open = due-today + recurring-due + started work (the backend
+ * dedups these against each other), overdue = the overdue section, completed =
+ * what was finished today. Deriving from the same lists the optimistic mutators
+ * patch keeps the strip live without a committed plan and without re-counting.
  */
-export function computeFigures(v: TodayBrief | undefined): PlanFigures {
-  let planned = 0;
-  let completed = 0;
-  let deferred = 0;
-  if (v && v.committed_todos.length > 0) {
-    for (const item of v.committed_todos) {
-      if (item.status === 'planned') planned++;
-      else if (item.status === 'done') completed++;
-      else if (item.status === 'deferred') deferred++;
-    }
-  } else if (v) {
-    ({ planned, completed, deferred } = v.plan_completion);
-  }
-  const total = planned + completed + deferred;
+export function computeFigures(v: TodayBrief | undefined): ProgressFigures {
+  const open = v
+    ? v.today_todos.length + v.recurring_todos.length + v.active_todos.length
+    : 0;
+  const overdue = v ? v.overdue_todos.length : 0;
+  const completed = v ? v.completed_todos.length : 0;
+  const total = open + overdue + completed;
   const ratio = (n: number): number =>
     total === 0 ? 0 : (n / total) * PERCENT;
   return {
-    planned,
+    open,
     completed,
-    deferred,
+    overdue,
     percent: Math.round(ratio(completed)),
     doneWidth: ratio(completed),
-    deferredWidth: ratio(deferred),
+    overdueWidth: ratio(overdue),
   };
 }
 
@@ -130,6 +124,7 @@ export function isQuietBrief(v: TodayBrief): boolean {
     v.today_todos.length === 0 &&
     v.active_todos.length === 0 &&
     v.recurring_todos.length === 0 &&
+    v.completed_todos.length === 0 &&
     v.upcoming_todos.length === 0 &&
     v.active_goals.length === 0 &&
     v.rss_highlights.length === 0
@@ -178,21 +173,29 @@ export function applyPlanAdvance(
   };
 }
 
-/** Drops a completed loose todo from every due bucket, including In progress. */
-export function removeLooseTodo(v: TodayBrief, todoId: string): TodayBrief {
+/**
+ * Reflects a server-confirmed completion on the local brief: drops the todo
+ * from every still-to-do section (the due buckets and today's recurring list)
+ * and adds it to completed_todos, so the day-progress strip moves one unit from
+ * open/overdue to completed without a refetch. Idempotent — a todo already in
+ * completed_todos is not added twice (e.g. completing it from the plan list
+ * after it was already dropped from a due bucket).
+ */
+export function markTodoCompleted(
+  v: TodayBrief,
+  todoId: string,
+  title: string,
+): TodayBrief {
+  const alreadyCounted = v.completed_todos.some((t) => t.id === todoId);
   return {
     ...v,
     overdue_todos: v.overdue_todos.filter((t) => t.id !== todoId),
     today_todos: v.today_todos.filter((t) => t.id !== todoId),
     active_todos: v.active_todos.filter((t) => t.id !== todoId),
     upcoming_todos: v.upcoming_todos.filter((t) => t.id !== todoId),
-  };
-}
-
-/** Drops a completed recurring occurrence from today's recurring list. */
-export function removeRecurringTodo(v: TodayBrief, todoId: string): TodayBrief {
-  return {
-    ...v,
     recurring_todos: v.recurring_todos.filter((t) => t.id !== todoId),
+    completed_todos: alreadyCounted
+      ? v.completed_todos
+      : [{ id: todoId, title, state: 'done' as const }, ...v.completed_todos],
   };
 }
diff --git a/frontend/src/app/admin/commitment/today/today.service.spec.ts b/frontend/src/app/admin/commitment/today/today.service.spec.ts
index 6296552e2..580504d5a 100644
--- a/frontend/src/app/admin/commitment/today/today.service.spec.ts
+++ b/frontend/src/app/admin/commitment/today/today.service.spec.ts
@@ -15,9 +15,9 @@ function emptyBrief(): TodayBrief {
     today_todos: [],
     active_todos: [],
     recurring_todos: [],
+    completed_todos: [],
     committed_todos: [],
     upcoming_todos: [],
-    plan_completion: { planned: 0, completed: 0, deferred: 0 },
     active_goals: [],
     rss_highlights: [],
   };
diff --git a/frontend/src/app/admin/commitment/today/today.service.ts b/frontend/src/app/admin/commitment/today/today.service.ts
index a5501ca56..e934e60c2 100644
--- a/frontend/src/app/admin/commitment/today/today.service.ts
+++ b/frontend/src/app/admin/commitment/today/today.service.ts
@@ -71,10 +71,23 @@ export interface CommittedItem {
   updated_at: string;
 }
 
-export interface PlanCompletion {
-  planned: number;
-  completed: number;
-  deferred: number;
+/**
+ * A todo finished today (todo.Item on the wire): a one-time todo done today, or
+ * a recurring occurrence stamped today (last_completed_on = today). No project
+ * join — the done-today query selects the bare todo row.
+ */
+export interface CompletedTodo {
+  id: string;
+  title: string;
+  state: TodoState;
+  due?: string;
+  completed_at?: string;
+  last_completed_on?: string;
+  recur_interval?: number;
+  recur_unit?: string;
+  recur_weekdays?: number;
+  energy?: EnergyLevel;
+  priority?: string;
 }
 
 /** Active goal with milestone rollup (goal.ActiveGoalSummary). */
@@ -107,9 +120,9 @@ export interface TodayBrief {
   today_todos: PendingDetail[];
   active_todos: PendingDetail[];
   recurring_todos: RecurringTodo[];
+  completed_todos: CompletedTodo[];
   committed_todos: CommittedItem[];
   upcoming_todos: PendingDetail[];
-  plan_completion: PlanCompletion;
   active_goals: ActiveGoalSummary[];
   rss_highlights: RssHighlight[];
 }
diff --git a/frontend/src/app/admin/commitment/todos/gtd-row.component.html b/frontend/src/app/admin/commitment/todos/gtd-row.component.html
index 32d24842a..7b76c3eea 100644
--- a/frontend/src/app/admin/commitment/todos/gtd-row.component.html
+++ b/frontend/src/app/admin/commitment/todos/gtd-row.component.html
@@ -77,9 +77,14 @@
       data-testid="gtd-row-ip-dot"
     ></span>
   }
-  <span class="min-w-0 flex-1 truncate text-[13px] text-fg">
+  <button
+    type="button"
+    (click)="openDetail.emit()"
+    class="min-w-0 flex-1 truncate text-left text-[13px] text-fg transition-colors hover:text-brand"
+    data-testid="gtd-row-open"
+  >
     {{ item().title }}
-  </span>
+  </button>
   @if (recur(); as label) {
     <span
       class="shrink-0 rounded-sm bg-brand-muted px-1.5 py-0.5 font-mono text-[10px] text-brand"
diff --git a/frontend/src/app/admin/commitment/todos/gtd-row.component.spec.ts b/frontend/src/app/admin/commitment/todos/gtd-row.component.spec.ts
index b157561b8..9c67b860a 100644
--- a/frontend/src/app/admin/commitment/todos/gtd-row.component.spec.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd-row.component.spec.ts
@@ -111,7 +111,7 @@ describe('GtdRowComponent', () => {
   });
 
   it('should show Complete and the in-progress pill when the todo is started', () => {
-    render(makeRow({ state: 'in_progress' }), 'today');
+    render(makeRow({ state: 'in_progress' }), 'in_progress');
 
     expect(testid('gtd-row-advance')?.textContent).toContain('Complete');
     expect(testid('gtd-row-ip-dot')).toBeTruthy();
diff --git a/frontend/src/app/admin/commitment/todos/gtd-view.spec.ts b/frontend/src/app/admin/commitment/todos/gtd-view.spec.ts
index 45f10e347..bd281ed62 100644
--- a/frontend/src/app/admin/commitment/todos/gtd-view.spec.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd-view.spec.ts
@@ -11,6 +11,7 @@ import {
   keyActionFor,
   planMemberIds,
   recurLabel,
+  resolvedKindOf,
   rowsForView,
   todayInTaipei,
   viewCounts,
@@ -57,51 +58,44 @@ describe('gtd-view', () => {
   ];
   const planIds = new Set(['planned']);
 
-  it('filters the four backlog views by the exact predicates', () => {
-    expect(rowsForView('inbox', backlog, planIds, TODAY).map((r) => r.id)).toEqual(
-      ['capture'],
-    );
-    expect(rowsForView('today', backlog, planIds, TODAY).map((r) => r.id)).toEqual(
-      ['planned', 'due-today'],
-    );
+  it('filters the status views by the exact predicates', () => {
+    expect(rowsForView('inbox', backlog, planIds).map((r) => r.id)).toEqual([
+      'capture',
+    ]);
     expect(
-      rowsForView('pending', backlog, planIds, TODAY).map((r) => r.id),
+      rowsForView('pending', backlog, planIds).map((r) => r.id),
     ).toEqual(['due-today', 'pending']);
+    // In Progress = state in_progress, recurring excluded. 'planned' is the
+    // in_progress row in the backlog; its plan membership does not hide it.
     expect(
-      rowsForView('someday', backlog, planIds, TODAY).map((r) => r.id),
-    ).toEqual(['parked']);
+      rowsForView('in_progress', backlog, planIds).map((r) => r.id),
+    ).toEqual(['planned']);
+    expect(rowsForView('someday', backlog, planIds).map((r) => r.id)).toEqual([
+      'parked',
+    ]);
   });
 
-  it('keeps a started (in_progress) todo in Today even when unplanned and not due today', () => {
-    // Regression: starting a Pending todo (→ in_progress) once made it
-    // vanish from every view when it was neither in the plan nor due today.
-    const started = row({
-      id: 'started',
-      state: 'in_progress',
-      due: '2026-06-20T00:00:00Z',
-    });
-    const ids = rowsForView('today', [started], new Set<string>(), TODAY).map(
-      (r) => r.id,
-    );
-    expect(ids).toEqual(['started']);
-  });
-
-  it('counts every view, including recurring buckets and history length', () => {
-    const counts = viewCounts(
-      backlog,
-      planIds,
-      TODAY,
-      {
-        due_today: [],
-      },
-      7,
-    );
+  it('excludes recurring routines from the In Progress tab', () => {
+    const rows: TodoRow[] = [
+      row({ id: 'started', state: 'in_progress' }),
+      row({
+        id: 'started-routine',
+        state: 'in_progress',
+        recur_weekdays: 127,
+      }),
+    ];
+    expect(
+      rowsForView('in_progress', rows, new Set<string>()).map((r) => r.id),
+    ).toEqual(['started']);
+  });
+
+  it('counts every status view plus the resolved (Complete) length', () => {
+    const counts = viewCounts(backlog, planIds, 7);
     expect(counts).toEqual({
       inbox: 1,
-      today: 2,
       pending: 2,
+      in_progress: 1,
       someday: 1,
-      recurring: 0,
       history: 7,
     });
   });
@@ -189,7 +183,7 @@ describe('gtd-view', () => {
     // Only the non-recurring todo remains; BOTH recurrence modes are excluded
     // (weekday-mode was the leak this fix closes).
     expect(
-      rowsForView('pending', rows, new Set<string>(), TODAY).map((r) => r.id),
+      rowsForView('pending', rows, new Set<string>()).map((r) => r.id),
     ).toEqual(['plain']);
   });
 
@@ -198,7 +192,7 @@ describe('gtd-view', () => {
     expect(keyActionFor('c', 'inbox')).toBe('clarify');
     expect(keyActionFor('c', 'pending')).toBeNull();
     expect(keyActionFor('x', 'inbox')).toBe('drop');
-    expect(keyActionFor('x', 'today')).toBeNull();
+    expect(keyActionFor('x', 'pending')).toBeNull();
     expect(keyActionFor('d', 'someday')).toBeNull();
     expect(keyActionFor('t', 'someday')).toBe('pull');
     expect(keyActionFor('t', 'inbox')).toBe('pull');
@@ -215,6 +209,19 @@ describe('gtd-view', () => {
     expect(todayInTaipei(new Date('2026-06-10T06:00:00Z'))).toBe('2026-06-10');
   });
 
+  it('maps a resolved row to its kind by state', () => {
+    expect(resolvedKindOf('done')).toEqual({
+      label: 'done',
+      symbol: '✓',
+      tone: 'done',
+    });
+    expect(resolvedKindOf('dismissed').tone).toBe('dropped');
+    expect(resolvedKindOf('archived').tone).toBe('dropped');
+    // A still-active recurring routine (todo/in_progress) reads as recurring.
+    expect(resolvedKindOf('in_progress').tone).toBe('recurring');
+    expect(resolvedKindOf('todo').tone).toBe('recurring');
+  });
+
   it('builds the clarify field update only from set fields', () => {
     expect(
       clarifyUpdate({ project_id: null, energy: null, due: null }),
@@ -224,12 +231,15 @@ describe('gtd-view', () => {
     ).toEqual({ project_id: 'p1', energy: 'high', due_date: '2026-06-12' });
   });
 
-  it('falls back to inbox for unknown route data and swaps history empty copy while searching', () => {
-    expect(initialViewOf('today')).toBe('today');
-    expect(initialViewOf('nope')).toBe('inbox');
+  it('falls back to pending for unknown route data and swaps Complete empty copy while searching', () => {
+    expect(initialViewOf('someday')).toBe('someday');
+    expect(initialViewOf('today')).toBe('pending');
+    expect(initialViewOf('nope')).toBe('pending');
     expect(emptyCopyFor('history', true).description).toContain(
       'match your search',
     );
-    expect(emptyCopyFor('history', false).description).toContain('kept here');
+    expect(emptyCopyFor('history', false).description).toContain(
+      'recurring completions',
+    );
   });
 });
diff --git a/frontend/src/app/admin/commitment/todos/gtd-view.ts b/frontend/src/app/admin/commitment/todos/gtd-view.ts
index 32a671a07..bc829834f 100644
--- a/frontend/src/app/admin/commitment/todos/gtd-view.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd-view.ts
@@ -4,8 +4,6 @@ import type {
   DailyPlanWriteItem,
 } from '../../../core/services/daily-plan.service';
 import type {
-  RecurringBuckets,
-  TodoItem,
   TodoRow,
   TodoUpdateRequest,
 } from '../../../core/services/todo.service';
@@ -18,12 +16,14 @@ import type { EnergyLevel, TodoState } from '../../../core/models/workbench.mode
  * stays a thin binding layer.
  */
 
+// 'inbox' is not a Todos-page tab — it has its own page (InboxPageComponent),
+// which reuses this view-model with view='inbox'. The Todos page tabs are the
+// status-flow views in GTD_TABS. 'history' backs the Complete ("已了結") tab.
 export type GtdView =
   | 'inbox'
-  | 'today'
   | 'pending'
+  | 'in_progress'
   | 'someday'
-  | 'recurring'
   | 'history';
 
 export interface GtdTab {
@@ -31,32 +31,32 @@ export interface GtdTab {
   label: string;
 }
 
+/** The Todos-page tab strip — status-flow views only (Inbox is its own page). */
 export const GTD_TABS: readonly GtdTab[] = [
-  { view: 'inbox', label: 'Inbox' },
-  { view: 'today', label: 'Today' },
   { view: 'pending', label: 'Pending' },
+  { view: 'in_progress', label: 'In Progress' },
   { view: 'someday', label: 'Someday' },
-  { view: 'recurring', label: 'Recurring' },
-  { view: 'history', label: 'History' },
+  { view: 'history', label: 'Complete' },
 ];
 
 /** Views where row selection and the triage keys are active. */
 export function isTriageable(view: GtdView): boolean {
   return (
     view === 'inbox' ||
-    view === 'today' ||
     view === 'pending' ||
+    view === 'in_progress' ||
     view === 'someday'
   );
 }
 
-/** Coerce route data into a valid initial view; default to inbox. */
+/** Coerce route data into a valid initial Todos view; default to pending. */
 export function initialViewOf(value: unknown): GtdView {
-  return GTD_TABS.some((t) => t.view === value) ? (value as GtdView) : 'inbox';
+  return GTD_TABS.some((t) => t.view === value) ? (value as GtdView) : 'pending';
 }
 
 export function viewLabel(view: GtdView): string {
-  return GTD_TABS.find((t) => t.view === view)?.label ?? 'Inbox';
+  if (view === 'inbox') return 'Inbox';
+  return GTD_TABS.find((t) => t.view === view)?.label ?? 'Pending';
 }
 
 export interface EmptyCopy {
@@ -70,35 +70,30 @@ const EMPTY_COPY: Record<GtdView, EmptyCopy> = {
     description:
       'Nothing to clarify. Captures land here — clear them into todos, someday, or the bin.',
   },
-  today: {
-    title: 'Nothing pulled into today',
-    description:
-      'Pull pending todos in with t, or plan your day from the Plan view.',
-  },
   pending: {
     title: 'No clarified todos waiting',
     description: 'Clarify something from the inbox and it shows up here.',
   },
+  in_progress: {
+    title: 'Nothing in progress',
+    description: 'Start a pending todo with e and it moves here.',
+  },
   someday: {
     title: 'No someday/maybe',
     description:
       'Things you might do, but not now. Defer with d to park them here.',
   },
-  recurring: {
-    title: 'No recurring todos',
-    description: 'Recurring routines surface here when they’re due.',
-  },
   history: {
-    title: 'No history yet',
-    description: 'Completed todos are kept here.',
+    title: 'Nothing resolved yet',
+    description: 'Done, dropped, and recurring completions are kept here.',
   },
 };
 
 export function emptyCopyFor(view: GtdView, searching: boolean): EmptyCopy {
   if (view === 'history' && searching) {
     return {
-      title: 'No history yet',
-      description: 'No completed todos match your search.',
+      title: 'No matches',
+      description: 'No resolved todos match your search.',
     };
   }
   return EMPTY_COPY[view];
@@ -151,45 +146,31 @@ export function todayInTaipei(now: Date = new Date()): string {
   }).format(now);
 }
 
-/** Rows for the four backlog-derived views. */
+/** Rows for the backlog-derived status views (inbox / pending / in_progress /
+ *  someday). Recurring routines are excluded from the working tabs — they live
+ *  in the routines overview, the Today dashboard's due-today list, and each
+ *  row's detail panel — so the status flow stays free of daily routines. */
 export function rowsForView(
   view: GtdView,
   rows: readonly TodoRow[],
   planTodoIds: ReadonlySet<string>,
-  todayIso: string,
 ): TodoRow[] {
   switch (view) {
     case 'inbox':
       return rows.filter((r) => r.state === 'inbox');
-    case 'today':
-      // An in_progress todo is active work — it always belongs in Today
-      // (with its Complete action) regardless of plan membership or due
-      // date, so starting a task never makes it vanish from every view.
-      //
-      // NOTE (intentional, not drift): this flat triage tab DOES include a
-      // recurring in_progress todo via the in_progress branch, whereas the
-      // Today dashboard's Active section excludes recurring (routines live in
-      // its own Recurring section). The two surfaces serve different jobs —
-      // GTD-page = flat working list, dashboard = sectioned at-a-glance — and
-      // both surface the item, so this is a deliberate divergence, not the
-      // mirror-drift bug class.
-      return rows.filter(
-        (r) =>
-          r.state !== 'done' &&
-          r.state !== 'inbox' &&
-          (r.state === 'in_progress' ||
-            planTodoIds.has(r.id) ||
-            dueDay(r.due) === todayIso),
-      );
     case 'pending':
-      // Exclude recurring todos (either mode) — they live in the Recurring
-      // tab, governed by their schedule, not in the Pending backlog.
+      // Clarified, not yet started, not already pulled into today's plan, and
+      // not a recurring routine.
       return rows.filter(
         (r) =>
           r.state === 'todo' &&
           !planTodoIds.has(r.id) &&
           !isRecurringRow(r),
       );
+    case 'in_progress':
+      return rows.filter(
+        (r) => r.state === 'in_progress' && !isRecurringRow(r),
+      );
     case 'someday':
       return rows.filter((r) => r.state === 'someday');
     default:
@@ -298,6 +279,27 @@ export function energyOf(value?: string | null): EnergyLevel | null {
     : null;
 }
 
+export interface ResolvedKind {
+  label: string;
+  symbol: string;
+  tone: 'done' | 'dropped' | 'recurring';
+}
+
+/**
+ * How a resolved (Complete-tab) row was closed, from its current state: a
+ * terminal done, a dropped/filed todo (archived/dismissed), or a still-active
+ * recurring routine whose occurrence was completed (it stays todo/in_progress).
+ */
+export function resolvedKindOf(state: TodoState | undefined): ResolvedKind {
+  if (state === 'archived' || state === 'dismissed') {
+    return { label: 'dropped', symbol: '✕', tone: 'dropped' };
+  }
+  if (state === 'todo' || state === 'in_progress') {
+    return { label: 'recurring', symbol: '↻', tone: 'recurring' };
+  }
+  return { label: 'done', symbol: '✓', tone: 'done' };
+}
+
 /**
  * Which advance verb a non-inbox row takes next. `someday` rows go
  * through `activate` (someday → todo) so re-activation returns them to the
@@ -355,10 +357,10 @@ export function keyboardLegend(view: GtdView): KeyHint[] {
         { keys: 'd', label: 'defer' },
         { keys: 'x', label: 'drop' },
       ];
-    case 'today':
+    case 'in_progress':
       return [
         ...NAV_HINTS,
-        { keys: 'e', label: 'advance' },
+        { keys: 'e', label: 'complete' },
         { keys: 'd', label: 'defer' },
         { keys: 'r', label: 'recurrence' },
       ];
@@ -436,36 +438,19 @@ export function keyActionFor(key: string, view: GtdView): GtdKeyAction | null {
   }
 }
 
-export interface RecurringGroup {
-  label: string;
-  items: TodoItem[];
-}
-
-/** Non-empty recurring groups. Compute-on-read has only a due-today bucket. */
-export function recurringGroupsOf(
-  buckets: RecurringBuckets | undefined,
-): RecurringGroup[] {
-  return [{ label: 'Due today', items: buckets?.due_today ?? [] }].filter(
-    (group) => group.items.length > 0,
-  );
-}
-
-/** Live tab counts across all six views. */
+/** Live tab counts across the status views plus the resolved (Complete) count. */
 export function viewCounts(
   backlog: readonly TodoRow[],
   planTodoIds: ReadonlySet<string>,
-  todayIso: string,
-  buckets: RecurringBuckets | undefined,
   historyCount: number,
 ): Record<GtdView, number> {
   const count = (view: GtdView): number =>
-    rowsForView(view, backlog, planTodoIds, todayIso).length;
+    rowsForView(view, backlog, planTodoIds).length;
   return {
     inbox: count('inbox'),
-    today: count('today'),
     pending: count('pending'),
+    in_progress: count('in_progress'),
     someday: count('someday'),
-    recurring: buckets?.due_today.length ?? 0,
     history: historyCount,
   };
 }
diff --git a/frontend/src/app/admin/commitment/todos/gtd.page.html b/frontend/src/app/admin/commitment/todos/gtd.page.html
index dedba0acb..8f56e4e7a 100644
--- a/frontend/src/app/admin/commitment/todos/gtd.page.html
+++ b/frontend/src/app/admin/commitment/todos/gtd.page.html
@@ -1,33 +1,3 @@
-<!-- Persistent capture bar -->
-<form
-  class="flex h-[42px] shrink-0 items-center gap-2.5 border-b border-border bg-panel px-5"
-  (submit)="$event.preventDefault(); submitCapture()"
-  data-testid="gtd-capture-form"
->
-  <lucide-icon
-    [img]="PlusIcon"
-    [size]="15"
-    class="shrink-0 text-fg-subtle"
-    aria-hidden="true"
-  />
-  <label for="gtd-capture" class="sr-only">Capture a thought</label>
-  <input
-    #captureInput
-    id="gtd-capture"
-    type="text"
-    [value]="captureDraft()"
-    (input)="captureDraft.set(readInput($event))"
-    placeholder="Capture a thought — it lands in the inbox, unclarified…"
-    class="h-full min-w-0 flex-1 bg-transparent text-[13px] text-fg outline-hidden placeholder:text-fg-faint"
-    data-testid="gtd-capture-input"
-  />
-  <kbd
-    class="shrink-0 rounded-sm border border-border border-b-2 bg-elevated px-1.5 font-mono text-[10px] whitespace-nowrap text-fg-muted"
-  >
-    ↵ capture
-  </kbd>
-</form>
-
 <!-- View tabs with live counts -->
 <div
   class="flex shrink-0 flex-wrap items-center gap-1 border-b border-border bg-panel px-5 py-2"
@@ -110,59 +80,6 @@ <h2 class="font-display text-sm font-semibold text-fg">
     </div>
   } @else {
     @switch (store.view()) {
-      @case ('recurring') {
-        @if (store.recurringGroups().length === 0) {
-          <app-empty-state
-            [icon]="HexagonIcon"
-            [title]="store.emptyCopy().title"
-            [description]="store.emptyCopy().description"
-          />
-        }
-        @for (group of store.recurringGroups(); track group.label) {
-          <p
-            class="px-5 pt-3 pb-1 font-mono text-[10px] tracking-wider text-fg-faint uppercase"
-            [attr.data-testid]="'gtd-recurring-group-' + group.label"
-          >
-            {{ group.label }}
-          </p>
-          <div role="list">
-            @for (item of group.items; track item.id) {
-              <div
-                role="listitem"
-                class="flex min-h-8 items-center gap-2.5 border-b border-border-faint px-5 py-1.5"
-                data-testid="gtd-recurring-row"
-              >
-                <span class="min-w-0 flex-1 truncate text-[13px] text-fg">
-                  {{ item.title }}
-                </span>
-                @if (recurBadge(item); as badge) {
-                  <span
-                    class="shrink-0 rounded-sm bg-brand-muted px-1.5 py-0.5 font-mono text-[10px] text-brand"
-                  >
-                    {{ badge }}
-                  </span>
-                }
-                @if (recurEnergy(item); as level) {
-                  <app-energy-meter class="shrink-0" [level]="level" />
-                }
-                @if (recurDue(item); as chip) {
-                  <span
-                    class="shrink-0 rounded-sm px-1.5 py-0.5 font-mono text-[10px]"
-                    [class.bg-error-bg]="chip.tone === 'overdue'"
-                    [class.text-error]="chip.tone === 'overdue'"
-                    [class.bg-warn-bg]="chip.tone === 'soon'"
-                    [class.text-warn]="chip.tone === 'soon'"
-                    [class.bg-elevated]="chip.tone === 'default'"
-                    [class.text-fg-subtle]="chip.tone === 'default'"
-                  >
-                    {{ chip.label }}
-                  </span>
-                }
-              </div>
-            }
-          </div>
-        }
-      }
       @case ('history') {
         @if (store.historyRows().length === 0) {
           <app-empty-state
@@ -173,16 +90,22 @@ <h2 class="font-display text-sm font-semibold text-fg">
         }
         <div role="list">
           @for (row of store.historyRows(); track row.id) {
+            @let kind = resolvedKind(row.state);
             <div
               role="listitem"
               class="flex min-h-8 items-center gap-2.5 border-b border-border-faint px-5 py-1.5"
               data-testid="gtd-history-row"
             >
               <span
-                class="flex size-[15px] shrink-0 items-center justify-center rounded-sm bg-success text-[9px] leading-none font-bold text-[oklch(0.16_0.02_260)]"
+                class="flex size-[15px] shrink-0 items-center justify-center rounded-sm text-[9px] leading-none font-bold text-[oklch(0.16_0.02_260)]"
+                [class.bg-success]="kind.tone === 'done'"
+                [class.bg-fg-faint]="kind.tone === 'dropped'"
+                [class.bg-brand]="kind.tone === 'recurring'"
+                [attr.title]="kind.label"
+                [attr.data-testid]="'gtd-history-kind-' + kind.tone"
                 aria-hidden="true"
               >
-                ✓
+                {{ kind.symbol }}
               </span>
               <span class="min-w-0 flex-1 truncate text-[13px] text-fg-faint">
                 {{ row.title }}
@@ -219,7 +142,7 @@ <h2 class="font-display text-sm font-semibold text-fg">
               [selected]="showSelection() && i === store.selection()"
               [busy]="store.busy()"
               (rowHover)="store.selectedIndex.set(i)"
-              (openDetail)="store.openClarify(row)"
+              (openDetail)="store.openDetail(row)"
               (clarify)="store.openClarify(row)"
               (advance)="store.advanceRow(row)"
               (deferRow)="store.deferRow(row)"
@@ -270,6 +193,19 @@ <h2 class="font-display text-sm font-semibold text-fg">
   />
 }
 
+<!-- Row detail panel -->
+@if (store.detailTarget(); as target) {
+  <app-todo-detail-modal
+    [item]="target"
+    [busy]="store.busy()"
+    (advance)="store.advanceFromDetail()"
+    (deferRow)="store.deferFromDetail()"
+    (dropRow)="store.dropFromDetail()"
+    (editRecurrence)="store.editRecurrenceFromDetail()"
+    (closed)="store.closeDetail()"
+  />
+}
+
 <!-- Recurrence editor -->
 @if (store.recurrenceTarget(); as target) {
   <app-recurrence-modal
diff --git a/frontend/src/app/admin/commitment/todos/gtd.page.spec.ts b/frontend/src/app/admin/commitment/todos/gtd.page.spec.ts
index cf2ef1640..69acc10fe 100644
--- a/frontend/src/app/admin/commitment/todos/gtd.page.spec.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd.page.spec.ts
@@ -9,9 +9,9 @@ import { GtdPageComponent } from './gtd.page';
 import { todayInTaipei } from './gtd-view';
 import type { TodoRow } from '../../../core/services/todo.service';
 
-// Pins the GTD surface against the commitment contract: the backlog
-// list (per_page=200), the daily plan (today membership + t append),
-// the recurring buckets, and the completed history with ?q= search.
+// Pins the Todos surface against the commitment contract: the backlog
+// list (per_page=200), the daily plan (today membership + t append), and
+// the resolved history (Complete tab) with ?q= search.
 
 const TODOS_URL = '/api/admin/commitment/todos';
 const PLAN_URL = '/api/admin/commitment/daily-plan';
@@ -89,39 +89,21 @@ const planFixture = {
   overdue_count: 0,
 };
 
-const recurringFixture = {
-  due_today: [
-    {
-      id: 'routine-1',
-      title: 'Daily review',
-      state: 'todo',
-      recur_interval: 1,
-      recur_unit: 'days',
-      created_by: 'human',
-      created_at: '2026-06-01T07:00:00Z',
-      updated_at: '2026-06-01T07:00:00Z',
-    },
-    {
-      // Weekday-mode (Mon+Thu = 9) exercises the recurrence badge end-to-end
-      // through the recurring tab — interval-mode alone left it unverified.
-      id: 'routine-2',
-      title: 'Strength training',
-      state: 'todo',
-      recur_weekdays: 9,
-      created_by: 'human',
-      created_at: '2026-06-01T07:00:00Z',
-      updated_at: '2026-06-01T07:00:00Z',
-    },
-  ],
-};
-
 const historyFixture = [
   {
     id: 'hist-1',
     title: 'Shipped thing',
+    state: 'done',
     completed_at: '2026-06-09T10:00:00Z',
     project_title: 'koopa-core',
   },
+  {
+    id: 'hist-2',
+    title: 'Won’t pursue this',
+    state: 'dismissed',
+    completed_at: '2026-06-09T09:00:00Z',
+    project_title: '',
+  },
 ];
 
 describe('GtdPageComponent', () => {
@@ -146,8 +128,10 @@ describe('GtdPageComponent', () => {
     fixture.detectChanges();
   }
 
-  // Flush the four initial loads, then settle (whenStable must not be
-  // awaited while a request is still open in zoneless mode).
+  // Flush the three initial loads (backlog, plan, resolved history), then
+  // settle (whenStable must not be awaited while a request is still open in
+  // zoneless mode). Inbox is its own page now — the Todos page has no
+  // recurring resource.
   async function render(initialView: string): Promise<void> {
     TestBed.configureTestingModule({
       imports: [GtdPageComponent],
@@ -174,9 +158,6 @@ describe('GtdPageComponent', () => {
     httpMock
       .expectOne((r) => r.url.includes(PLAN_URL))
       .flush({ data: planFixture });
-    httpMock
-      .expectOne((r) => r.url.endsWith(`${TODOS_URL}/recurring`))
-      .flush({ data: recurringFixture });
     httpMock
       .expectOne((r) => r.url.endsWith(`${TODOS_URL}/history`))
       .flush({ data: historyFixture });
@@ -199,164 +180,63 @@ describe('GtdPageComponent', () => {
     fixture.detectChanges();
   }
 
-  it('should land on the Inbox view from the inbox route data with live counts', async () => {
-    await render('inbox');
+  it('should land on Pending by default with the status tabs and live counts', async () => {
+    // Unknown/legacy route data coerces to the default Pending view.
+    await render('today');
 
-    expect(testid('gtd-tab-inbox')?.getAttribute('aria-selected')).toBe('true');
-    expect(testid('gtd-tab-inbox')?.textContent).toContain('2');
-    expect(testid('gtd-tab-today')?.textContent).toContain('2');
+    expect(testid('gtd-tab-pending')?.getAttribute('aria-selected')).toBe(
+      'true',
+    );
+    // Pending = the one non-recurring, unplanned todo; routine-1 (recurring) and
+    // planned-1 (in_progress, in the plan) are excluded.
     expect(testid('gtd-tab-pending')?.textContent).toContain('1');
+    expect(testid('gtd-tab-in_progress')?.textContent).toContain('1');
     expect(testid('gtd-tab-someday')?.textContent).toContain('1');
-    expect(testid('gtd-tab-recurring')?.textContent).toContain('2');
-    expect(testid('gtd-tab-history')?.textContent).toContain('1');
-    expect(testid('gtd-row-0')?.textContent).toContain('Raw capture');
-    expect(testid('gtd-count')?.textContent).toContain('2 items');
+    expect(testid('gtd-tab-history')?.textContent).toContain('2');
+    // Inbox / Today / Recurring are no longer tabs on the Todos page.
+    expect(testid('gtd-tab-inbox')).toBeNull();
+    expect(testid('gtd-tab-today')).toBeNull();
+    expect(testid('gtd-tab-recurring')).toBeNull();
+    expect(testid('gtd-row-0')?.textContent).toContain('Pending todo');
   });
 
-  it('should land on the Today view from the todos route data', async () => {
-    await render('today');
+  it('should render the In Progress tab with started, non-recurring work', async () => {
+    await render('in_progress');
 
-    expect(testid('gtd-tab-today')?.getAttribute('aria-selected')).toBe(
+    expect(testid('gtd-tab-in_progress')?.getAttribute('aria-selected')).toBe(
       'true',
     );
     const list = testid('gtd-list');
     expect(list?.textContent).toContain('Planned thing');
-    expect(list?.textContent).toContain('Daily review');
     expect(list?.textContent).not.toContain('Pending todo');
+    expect(list?.textContent).not.toContain('Daily review');
   });
 
-  it('should capture on Enter, switch to Inbox, and reload the backlog', async () => {
-    await render('today');
-
-    const input = testid('gtd-capture-input') as HTMLInputElement;
-    input.value = 'Look into NATS JetStream';
-    input.dispatchEvent(new Event('input'));
-    fixture.detectChanges();
-    (testid('gtd-capture-form') as HTMLFormElement).dispatchEvent(
-      new Event('submit'),
-    );
+  it('should render the Complete tab with resolution-kind badges', async () => {
+    await render('history');
 
-    const post = httpMock.expectOne(
-      (r) => r.url.endsWith(TODOS_URL) && r.method === 'POST',
-    );
-    expect(post.request.body).toEqual({ title: 'Look into NATS JetStream' });
-    post.flush({
-      data: {
-        id: 'new-1',
-        title: 'Look into NATS JetStream',
-        state: 'inbox',
-        created_by: 'human',
-        created_at: '2026-06-10T08:00:00Z',
-        updated_at: '2026-06-10T08:00:00Z',
-      },
-    });
-    TestBed.tick();
-    flushBacklogReload();
-    await settle();
-
-    expect(testid('gtd-tab-inbox')?.getAttribute('aria-selected')).toBe(
-      'true',
-    );
-    expect((testid('gtd-capture-input') as HTMLInputElement).value).toBe('');
+    expect(testid('gtd-history-row')?.textContent).toContain('Shipped thing');
+    // done → green check; dropped (dismissed) → muted ✕.
+    expect(testid('gtd-history-kind-done')?.textContent).toContain('✓');
+    expect(testid('gtd-history-kind-dropped')?.textContent).toContain('✕');
   });
 
-  it('should move the selection with j and drop the selected capture with x', async () => {
-    await render('inbox');
+  it('should not render a capture bar on the Todos page', async () => {
+    await render('pending');
+    expect(testid('gtd-capture-input')).toBeNull();
+  });
 
+  it('should move the selection with j/k in a status view', async () => {
+    await render('someday');
+    // Seed two someday rows so j has somewhere to move.
     expect(testid('gtd-row-0')?.getAttribute('data-selected')).toBe('true');
     keydown('j');
-    expect(testid('gtd-row-1')?.getAttribute('data-selected')).toBe('true');
-    keydown('k');
+    // Only one someday row in the fixture, so selection stays clamped at 0.
     expect(testid('gtd-row-0')?.getAttribute('data-selected')).toBe('true');
-
-    keydown('x');
-    const advance = httpMock.expectOne((r) =>
-      r.url.endsWith(`${TODOS_URL}/inbox-1/advance`),
-    );
-    expect(advance.request.body).toEqual({ action: 'drop' });
-    advance.flush(null, { status: 204, statusText: 'No Content' });
-    TestBed.tick();
-    flushBacklogReload();
-    await settle();
-  });
-
-  it('should ignore triage keys while typing in the capture bar', async () => {
-    await render('inbox');
-
-    const input = testid('gtd-capture-input') as HTMLInputElement;
-    input.dispatchEvent(
-      new KeyboardEvent('keydown', { key: 'x', bubbles: true }),
-    );
-    fixture.detectChanges();
-
-    httpMock.expectNone((r) => r.url.includes('/advance'));
-  });
-
-  it('should open the clarify modal with e and run PUT + advance(clarify) on submit', async () => {
-    await render('inbox');
-
-    keydown('e');
-    httpMock
-      .expectOne((r) => r.url.includes('/api/admin/commitment/projects'))
-      .flush({ data: [] });
-    await settle();
-    expect(testid('clarify-modal')).toBeTruthy();
-
-    (testid('clarify-submit') as HTMLButtonElement).click();
-    // Energy defaults to medium, so the field PUT precedes the advance.
-    const put = httpMock.expectOne(
-      (r) =>
-        r.url.endsWith(`${TODOS_URL}/inbox-1`) && r.method === 'PUT',
-    );
-    expect(put.request.body).toEqual({ energy: 'medium' });
-    put.flush({ data: { ...backlogRows[0] } });
-    const advance = httpMock.expectOne((r) =>
-      r.url.endsWith(`${TODOS_URL}/inbox-1/advance`),
-    );
-    expect(advance.request.body).toEqual({ action: 'clarify' });
-    advance.flush({ data: { ...backlogRows[0], state: 'todo' } });
-    TestBed.tick();
-    flushBacklogReload();
-    await settle();
-
-    expect(testid('clarify-modal')).toBeNull();
-  });
-
-  it('should open the clarify modal when an inbox row body is clicked', async () => {
-    await render('inbox');
-
-    (testid('gtd-row-open') as HTMLButtonElement).click();
-    fixture.detectChanges();
-    httpMock
-      .expectOne((r) => r.url.includes('/api/admin/commitment/projects'))
-      .flush({ data: [] });
-    await settle();
-
-    expect(testid('clarify-modal')).toBeTruthy();
-  });
-
-  it('should focus the inbox row trigger when the dialog opens from the keyboard', async () => {
-    await render('inbox');
-    const trigger = testid('gtd-row-open') as HTMLButtonElement;
-
-    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'c' }));
-    // Pre-focus runs synchronously in the handler, before the modal mounts —
-    // it anchors the modal's focus trap so focus returns to the row on close.
-    expect(document.activeElement).toBe(trigger);
-
-    // Settle the now-open dialog so its projects read is satisfied for verify().
-    fixture.detectChanges();
-    httpMock
-      .expectOne((r) => r.url.includes('/api/admin/commitment/projects'))
-      .flush({ data: [] });
-    await settle();
   });
 
   it('should pull the selected pending todo into today with t via the atomic plan PUT', async () => {
-    await render('inbox');
-
-    (testid('gtd-tab-pending') as HTMLButtonElement).click();
-    fixture.detectChanges();
+    await render('pending');
     keydown('t');
 
     const put = httpMock.expectOne(
@@ -379,11 +259,31 @@ describe('GtdPageComponent', () => {
     await settle();
   });
 
-  it('should activate a someday row with e via advance(activate)', async () => {
-    await render('inbox');
+  it('should open the detail panel on a row click and advance from it', async () => {
+    await render('pending');
 
-    (testid('gtd-tab-someday') as HTMLButtonElement).click();
+    // Clicking the pending row's title opens the detail panel (not clarify).
+    (testid('gtd-row-open') as HTMLButtonElement).click();
     fixture.detectChanges();
+    expect(testid('todo-detail-modal')).toBeTruthy();
+    expect(testid('todo-detail-advance')?.textContent).toContain('Start');
+
+    // Advancing from the panel runs the verb and closes the panel.
+    (testid('todo-detail-advance') as HTMLButtonElement).click();
+    const advance = httpMock.expectOne((r) =>
+      r.url.endsWith(`${TODOS_URL}/pending-1/advance`),
+    );
+    expect(advance.request.body).toEqual({ action: 'start' });
+    advance.flush({ data: { ...backlogRows[3], state: 'in_progress' } });
+    TestBed.tick();
+    flushBacklogReload();
+    await settle();
+
+    expect(testid('todo-detail-modal')).toBeNull();
+  });
+
+  it('should activate a someday row with e via advance(activate)', async () => {
+    await render('someday');
     expect(testid('gtd-row-0')?.textContent).toContain('Someday idea');
 
     keydown('e');
@@ -397,11 +297,8 @@ describe('GtdPageComponent', () => {
     await settle();
   });
 
-  it('should show the history search box and run a debounced ?q= search', async () => {
-    await render('inbox');
-
-    (testid('gtd-tab-history') as HTMLButtonElement).click();
-    fixture.detectChanges();
+  it('should show the Complete search box and run a debounced ?q= search', async () => {
+    await render('history');
     expect(testid('gtd-history-row')?.textContent).toContain('Shipped thing');
 
     const search = testid('gtd-history-search') as HTMLInputElement;
@@ -426,24 +323,6 @@ describe('GtdPageComponent', () => {
     req.flush({ data: [] });
     await settle();
 
-    expect(el().textContent).toContain('No completed todos match your search.');
-  });
-
-  it('should render the recurring buckets with the every-N badge and no row actions', async () => {
-    await render('inbox');
-
-    (testid('gtd-tab-recurring') as HTMLButtonElement).click();
-    fixture.detectChanges();
-
-    expect(testid('gtd-recurring-group-Due today')).toBeTruthy();
-    const rows = (fixture.nativeElement as HTMLElement).querySelectorAll(
-      '[data-testid="gtd-recurring-row"]',
-    );
-    expect(rows[0]?.textContent).toContain('Daily review');
-    expect(rows[0]?.textContent).toContain('every 1d');
-    // Weekday-mode routine renders its day-list badge (Mon+Thu = mask 9).
-    expect(rows[1]?.textContent).toContain('Strength training');
-    expect(rows[1]?.textContent).toContain('Mon Thu');
-    expect(rows[0]?.querySelector('button')).toBeNull();
+    expect(el().textContent).toContain('No resolved todos match your search.');
   });
 });
diff --git a/frontend/src/app/admin/commitment/todos/gtd.page.ts b/frontend/src/app/admin/commitment/todos/gtd.page.ts
index 3fbb4f0dd..739558415 100644
--- a/frontend/src/app/admin/commitment/todos/gtd.page.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd.page.ts
@@ -2,46 +2,39 @@ import {
   ChangeDetectionStrategy,
   Component,
   DestroyRef,
-  ElementRef,
   computed,
   effect,
   inject,
-  signal,
-  viewChild,
-  viewChildren,
 } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
 import { DatePipe } from '@angular/common';
-import { Hexagon, LucideAngularModule, Plus } from 'lucide-angular';
-import type { TodoItem } from '../../../core/services/todo.service';
+import { Hexagon, LucideAngularModule } from 'lucide-angular';
+import type { TodoHistoryEntry } from '../../../core/services/todo.service';
 import { AdminTopbarService } from '../../admin-layout/admin-topbar.service';
 import { EmptyStateComponent } from '../../../shared/components/empty-state/empty-state.component';
-import { EnergyMeterComponent } from '../../../shared/components/energy-meter/energy-meter.component';
 import { GtdRowComponent } from './gtd-row.component';
 import { ClarifyModalComponent } from './clarify-modal.component';
 import { RecurrenceModalComponent } from './recurrence-modal.component';
+import { TodoDetailModalComponent } from './todo-detail-modal.component';
 import { GtdStore } from './gtd.store';
 import {
   GTD_TABS,
-  dueChip,
-  energyOf,
   initialViewOf,
   isInteractiveTarget,
   isTriageable,
   keyActionFor,
-  recurLabel,
-  todayInTaipei,
+  resolvedKindOf,
   viewLabel,
+  type ResolvedKind,
 } from './gtd-view';
 
 /**
- * GTD surface — six segmented views over the todo backlog (Inbox,
- * Today, Pending, Someday, Recurring, History) with a persistent
- * capture bar, j/k + verb keyboard triage, and the clarify dialog.
- * The initial view comes from route data so the Inbox and Todos nav
- * entries land on their own tab; each entry is a distinct route
- * config, so switching between them remounts and resets the view.
- * State and mutations live in the page-provided {@link GtdStore}.
+ * Todos — the status-flow surface over the todo backlog: Pending, In Progress,
+ * Someday, and Complete (the resolved history) as segmented tabs, with j/k +
+ * verb keyboard triage and the clarify / recurrence dialogs. Inbox is its own
+ * page (InboxPageComponent); capture happens there. The initial tab comes from
+ * route data, defaulting to Pending. State and mutations live in the
+ * page-provided {@link GtdStore}.
  */
 @Component({
   selector: 'app-gtd-page',
@@ -49,10 +42,10 @@ import {
     DatePipe,
     LucideAngularModule,
     EmptyStateComponent,
-    EnergyMeterComponent,
     GtdRowComponent,
     ClarifyModalComponent,
     RecurrenceModalComponent,
+    TodoDetailModalComponent,
   ],
   providers: [GtdStore],
   templateUrl: './gtd.page.html',
@@ -69,14 +62,7 @@ export class GtdPageComponent {
   private readonly destroyRef = inject(DestroyRef);
 
   protected readonly HexagonIcon = Hexagon;
-  protected readonly PlusIcon = Plus;
   protected readonly tabs = GTD_TABS;
-  protected readonly captureDraft = signal('');
-
-  private readonly todayIso = todayInTaipei();
-  private readonly captureInput =
-    viewChild<ElementRef<HTMLInputElement>>('captureInput');
-  private readonly gtdRows = viewChildren(GtdRowComponent);
 
   protected readonly showSelection = computed(() =>
     isTriageable(this.store.view()),
@@ -88,14 +74,6 @@ export class GtdPageComponent {
       this.topbar.set({
         title: 'Todos',
         crumbs: ['Daily', viewLabel(this.store.view())],
-        actions: [
-          {
-            id: 'gtd-capture-action',
-            label: 'Capture',
-            kind: 'primary',
-            run: () => this.captureInput()?.nativeElement.focus(),
-          },
-        ],
       });
     });
     this.destroyRef.onDestroy(() => this.topbar.reset());
@@ -105,22 +83,9 @@ export class GtdPageComponent {
     return (event.target as HTMLInputElement).value;
   }
 
-  protected submitCapture(): void {
-    const title = this.captureDraft().trim();
-    if (!title) return;
-    this.store.capture(title, () => this.captureDraft.set(''));
-  }
-
-  protected recurBadge(item: TodoItem): string | null {
-    return recurLabel(item.recur_interval, item.recur_unit, item.recur_weekdays);
-  }
-
-  protected recurDue(item: TodoItem): ReturnType<typeof dueChip> {
-    return dueChip(item.due, this.todayIso);
-  }
-
-  protected recurEnergy(item: TodoItem): ReturnType<typeof energyOf> {
-    return energyOf(item.energy);
+  /** Resolution kind for a Complete-tab row, from its current state. */
+  protected resolvedKind(state: TodoHistoryEntry['state']): ResolvedKind {
+    return resolvedKindOf(state);
   }
 
   protected handleKeydown(event: KeyboardEvent): void {
@@ -128,6 +93,7 @@ export class GtdPageComponent {
       return;
     if (this.store.clarifyTarget() !== null) return;
     if (this.store.recurrenceTarget() !== null) return;
+    if (this.store.detailTarget() !== null) return;
     if (isInteractiveTarget(event.target)) return;
     const view = this.store.view();
     if (!isTriageable(view)) return;
@@ -138,14 +104,6 @@ export class GtdPageComponent {
     event.preventDefault();
     const index = this.store.selection();
     const row = rows[index];
-    // Inbox actions that open the clarify dialog: focus the row's trigger
-    // first so the modal's focus trap restores focus to it on close.
-    if (
-      view === 'inbox' &&
-      (action === 'advance' || action === 'clarify' || action === 'pull')
-    ) {
-      this.gtdRows()[index]?.focusOpen();
-    }
     switch (action) {
       case 'down':
         this.store.selectedIndex.set(Math.min(index + 1, rows.length - 1));
@@ -156,9 +114,6 @@ export class GtdPageComponent {
       case 'advance':
         this.store.advanceRow(row);
         break;
-      case 'clarify':
-        this.store.clarifyTarget.set(row);
-        break;
       case 'defer':
         this.store.deferRow(row);
         break;
diff --git a/frontend/src/app/admin/commitment/todos/gtd.store.spec.ts b/frontend/src/app/admin/commitment/todos/gtd.store.spec.ts
index d6f24193b..a6fcab946 100644
--- a/frontend/src/app/admin/commitment/todos/gtd.store.spec.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd.store.spec.ts
@@ -96,9 +96,6 @@ describe('GtdStore', () => {
     httpMock
       .expectOne((r) => r.url.includes(PLAN_URL))
       .flush({ data: planFixture });
-    httpMock
-      .expectOne((r) => r.url.endsWith(`${TODOS_URL}/recurring`))
-      .flush({ data: { due_today: [] } });
     httpMock
       .expectOne((r) => r.url.endsWith(`${TODOS_URL}/history`))
       .flush({
@@ -106,6 +103,7 @@ describe('GtdStore', () => {
           {
             id: 'hist-1',
             title: 'Shipped thing',
+            state: 'done',
             completed_at: '2026-06-09T10:00:00Z',
             project_title: 'koopa-core',
           },
@@ -117,10 +115,9 @@ describe('GtdStore', () => {
   it('should derive live counts for every view from the loaded resources', () => {
     expect(store.counts()).toEqual({
       inbox: 1,
-      today: 1,
       pending: 1,
+      in_progress: 1,
       someday: 1,
-      recurring: 0,
       history: 1,
     });
   });
@@ -191,7 +188,7 @@ describe('GtdStore', () => {
     TestBed.tick();
 
     // planned-1 is already a member — no further PUT goes out.
-    store.setView('today');
+    store.setView('in_progress');
     store.pullRow(store.rows()[0]);
     httpMock.expectNone((r) => r.method === 'PUT');
   });
@@ -363,7 +360,6 @@ describe('GtdStore (resource error)', () => {
       .match((r) => r.url.endsWith(TODOS_URL) && r.params.get('per_page') === '200')
       .forEach(fail);
     httpMock.match((r) => r.url.includes(PLAN_URL)).forEach(fail);
-    httpMock.match((r) => r.url.endsWith(`${TODOS_URL}/recurring`)).forEach(fail);
     httpMock.match((r) => r.url.endsWith(`${TODOS_URL}/history`)).forEach(fail);
     TestBed.tick();
   }
@@ -379,10 +375,9 @@ describe('GtdStore (resource error)', () => {
     // counts() composes the guarded fallbacks — every view counts to 0.
     expect(store.counts()).toEqual({
       inbox: 0,
-      today: 0,
       pending: 0,
+      in_progress: 0,
       someday: 0,
-      recurring: 0,
       history: 0,
     });
   });
diff --git a/frontend/src/app/admin/commitment/todos/gtd.store.ts b/frontend/src/app/admin/commitment/todos/gtd.store.ts
index ba3ef8d1d..8cb23e3ea 100644
--- a/frontend/src/app/admin/commitment/todos/gtd.store.ts
+++ b/frontend/src/app/admin/commitment/todos/gtd.store.ts
@@ -22,9 +22,7 @@ import {
   keyboardLegend,
   mutationErrorMessage,
   planMemberIds,
-  recurringGroupsOf,
   rowsForView,
-  todayInTaipei,
   viewCounts,
   type ClarifyResult,
   type GtdView,
@@ -33,7 +31,7 @@ import {
 const BACKLOG_PAGE_SIZE = 200;
 const HISTORY_DEBOUNCE_MS = 250;
 
-// The backlog feeds the inbox / today / pending / someday views — every
+// The backlog feeds the inbox / pending / in_progress / someday views — every
 // live state, never `done`. Filtering server-side (rather than fetching
 // everything and dropping done locally) keeps a long completed history from
 // pushing live rows past the per_page cap.
@@ -48,11 +46,11 @@ const BACKLOG_STATES = ['inbox', 'todo', 'in_progress', 'someday'] as const;
 export type ClarifyIntent = 'clarify' | 'pull';
 
 /**
- * Page-scoped state for the GTD surface: the four data resources
- * (backlog list, daily plan, recurring buckets, completed history),
- * the active view + row selection, and every mutation round-trip
- * (capture, advance verbs, clarify, plan append). Provided by the GTD
- * page so the state dies with the route.
+ * Page-scoped state for the GTD surface: the three data resources
+ * (backlog list, daily plan, resolved history), the active view + row
+ * selection, and every mutation round-trip (capture, advance verbs,
+ * clarify, plan append). Provided by the GTD/Inbox pages so the state dies
+ * with the route.
  */
 @Injectable()
 export class GtdStore {
@@ -65,6 +63,7 @@ export class GtdStore {
   readonly selectedIndex = signal(0);
   readonly clarifyTarget = signal<TodoRow | null>(null);
   readonly recurrenceTarget = signal<TodoRow | null>(null);
+  readonly detailTarget = signal<TodoRow | null>(null);
   private readonly clarifyIntent = signal<ClarifyIntent>('clarify');
   readonly searchDraft = signal('');
   private readonly historyQuery = signal('');
@@ -82,9 +81,6 @@ export class GtdStore {
   readonly plan = rxResource<DailyPlan, void>({
     stream: () => this.dailyPlanService.today(),
   });
-  readonly recurring = rxResource({
-    stream: () => this.todoService.recurring(),
-  });
   readonly history = rxResource({
     params: () => ({ q: this.historyQuery() }),
     stream: ({ params }) =>
@@ -104,43 +100,28 @@ export class GtdStore {
   private readonly historyValue = computed(() =>
     this.history.hasValue() ? this.history.value() : [],
   );
-  private readonly recurringValue = computed(() =>
-    this.recurring.hasValue() ? this.recurring.value() : undefined,
-  );
 
-  private readonly todayIso = todayInTaipei();
   private readonly planIds = computed(() =>
     planMemberIds(this.planValue()?.items ?? []),
   );
   readonly rows = computed(() =>
-    rowsForView(this.view(), this.backlogValue(), this.planIds(), this.todayIso),
+    rowsForView(this.view(), this.backlogValue(), this.planIds()),
   );
   readonly selection = computed(() =>
     Math.min(this.selectedIndex(), Math.max(this.rows().length - 1, 0)),
   );
   readonly historyRows = computed(() => this.historyValue());
-  readonly recurringGroups = computed(() =>
-    recurringGroupsOf(this.recurringValue()),
-  );
   readonly counts = computed(() =>
-    viewCounts(
-      this.backlogValue(),
-      this.planIds(),
-      this.todayIso,
-      this.recurringValue(),
-      this.historyRows().length,
-    ),
+    viewCounts(this.backlogValue(), this.planIds(), this.historyRows().length),
   );
   readonly itemCount = computed(() => this.counts()[this.view()]);
   readonly legend = computed(() => keyboardLegend(this.view()));
   readonly emptyCopy = computed(() =>
     emptyCopyFor(this.view(), this.searchDraft().trim() !== ''),
   );
-  private readonly activeResource = computed(() => {
-    if (this.view() === 'recurring') return this.recurring;
-    if (this.view() === 'history') return this.history;
-    return this.backlog;
-  });
+  private readonly activeResource = computed(() =>
+    this.view() === 'history' ? this.history : this.backlog,
+  );
   readonly viewLoading = computed(
     () => this.activeResource().status() === 'loading',
   );
@@ -276,6 +257,50 @@ export class GtdStore {
     }
   }
 
+  /** Open the detail panel for a row — the Todos-page row-click surface. */
+  openDetail(row: TodoRow): void {
+    this.detailTarget.set(row);
+  }
+
+  /** Dismiss the detail panel without acting. */
+  closeDetail(): void {
+    this.detailTarget.set(null);
+  }
+
+  /**
+   * Detail-panel actions. Each closes the panel first (the backlog reload that
+   * follows the mutation removes the row underneath it) then runs the verb on
+   * the captured target.
+   */
+  advanceFromDetail(): void {
+    const row = this.detailTarget();
+    if (!row) return;
+    this.detailTarget.set(null);
+    this.advanceRow(row);
+  }
+
+  deferFromDetail(): void {
+    const row = this.detailTarget();
+    if (!row) return;
+    this.detailTarget.set(null);
+    this.deferRow(row);
+  }
+
+  dropFromDetail(): void {
+    const row = this.detailTarget();
+    if (!row) return;
+    this.detailTarget.set(null);
+    this.dropRow(row);
+  }
+
+  /** Swap the detail panel for the recurrence editor on the same row. */
+  editRecurrenceFromDetail(): void {
+    const row = this.detailTarget();
+    if (!row) return;
+    this.detailTarget.set(null);
+    this.openRecurrence(row);
+  }
+
   /** Open the recurrence editor for a row. */
   openRecurrence(row: TodoRow): void {
     this.recurrenceTarget.set(row);
@@ -288,8 +313,8 @@ export class GtdStore {
 
   /**
    * Recurrence-editor save: set or clear the row's schedule, then refresh the
-   * backlog and recurring buckets so the change shows immediately. Closes the
-   * editor before the round-trip so the modal unmounts cleanly.
+   * backlog so the change shows immediately. Closes the editor before the
+   * round-trip so the modal unmounts cleanly.
    */
   saveRecurrence(req: RecurrenceRequest): void {
     const row = this.recurrenceTarget();
@@ -297,7 +322,6 @@ export class GtdStore {
     this.recurrenceTarget.set(null);
     const message = req.clear ? 'Recurrence cleared' : 'Routine set';
     this.mutate(this.todoService.setRecurrence(row.id, req), message, {});
-    this.recurring.reload();
   }
 
   deferInstead(): void {
diff --git a/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.html b/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.html
new file mode 100644
index 000000000..6d09cb82d
--- /dev/null
+++ b/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.html
@@ -0,0 +1,102 @@
+<app-modal
+  [title]="item().title"
+  titleId="todo-detail-modal-title"
+  [maxWidth]="'md'"
+  (closed)="closed.emit()"
+>
+  <div class="flex flex-col gap-3" data-testid="todo-detail-modal">
+    <!-- At-a-glance facts -->
+    <dl class="grid grid-cols-[auto_1fr] gap-x-4 gap-y-2 text-[13px]">
+      <dt class="font-mono text-[11px] text-fg-faint uppercase">State</dt>
+      <dd>
+        <span
+          class="rounded-sm bg-elevated px-1.5 py-0.5 font-mono text-[11px] text-fg-muted"
+          data-testid="todo-detail-state"
+        >
+          {{ stateLabel() }}
+        </span>
+      </dd>
+
+      <dt class="font-mono text-[11px] text-fg-faint uppercase">Routine</dt>
+      <dd data-testid="todo-detail-recurrence">
+        @if (recurrence(); as label) {
+          <span
+            class="rounded-sm bg-brand-muted px-1.5 py-0.5 font-mono text-[11px] text-brand"
+          >
+            {{ label }}
+          </span>
+        } @else {
+          <span class="text-fg-subtle">One-time — not recurring</span>
+        }
+      </dd>
+
+      <dt class="font-mono text-[11px] text-fg-faint uppercase">Project</dt>
+      <dd class="text-fg">{{ item().project_title || 'Unfiled' }}</dd>
+
+      <dt class="font-mono text-[11px] text-fg-faint uppercase">Due</dt>
+      <dd class="text-fg">{{ due() ?? '—' }}</dd>
+
+      <dt class="font-mono text-[11px] text-fg-faint uppercase">Energy</dt>
+      <dd>
+        @if (energy(); as level) {
+          <app-energy-meter [level]="level" />
+        } @else {
+          <span class="text-fg-subtle">—</span>
+        }
+      </dd>
+    </dl>
+
+    @if (item().description) {
+      <p
+        class="border-t border-border-faint pt-3 text-[13px] leading-relaxed whitespace-pre-wrap text-fg-subtle"
+        data-testid="todo-detail-description"
+      >
+        {{ item().description }}
+      </p>
+    }
+  </div>
+
+  <div modal-footer class="flex w-full items-center gap-2.5">
+    <button
+      type="button"
+      (click)="dropRow.emit()"
+      [disabled]="busy()"
+      class="rounded-sm border border-transparent px-2.5 py-1.5 text-xs text-error transition-colors hover:bg-error-bg disabled:cursor-not-allowed disabled:opacity-40"
+      data-testid="todo-detail-drop"
+    >
+      Drop
+    </button>
+    <span class="flex-1"></span>
+    <button
+      type="button"
+      (click)="editRecurrence.emit()"
+      [disabled]="busy()"
+      class="rounded-sm border border-border bg-elevated px-2.5 py-1.5 text-xs text-fg-muted transition-colors hover:bg-overlay hover:text-fg disabled:cursor-not-allowed disabled:opacity-40"
+      data-testid="todo-detail-recurrence-edit"
+    >
+      {{ recurrence() ? 'Edit routine' : 'Make routine' }}
+    </button>
+    @if (showDefer()) {
+      <button
+        type="button"
+        (click)="deferRow.emit()"
+        [disabled]="busy()"
+        class="rounded-sm border border-border bg-elevated px-2.5 py-1.5 text-xs text-fg-muted transition-colors hover:bg-overlay hover:text-fg disabled:cursor-not-allowed disabled:opacity-40"
+        data-testid="todo-detail-defer"
+      >
+        Defer
+      </button>
+    }
+    @if (advanceLabel(); as label) {
+      <button
+        type="button"
+        (click)="advance.emit()"
+        [disabled]="busy()"
+        class="rounded-sm border border-brand bg-brand px-2.5 py-1.5 text-xs font-semibold text-[oklch(0.14_0.02_260)] transition-colors hover:bg-brand-strong disabled:cursor-not-allowed disabled:opacity-40"
+        data-testid="todo-detail-advance"
+      >
+        {{ label }}
+      </button>
+    }
+  </div>
+</app-modal>
diff --git a/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.spec.ts b/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.spec.ts
new file mode 100644
index 000000000..d9dfb40f9
--- /dev/null
+++ b/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.spec.ts
@@ -0,0 +1,80 @@
+import { TestBed, type ComponentFixture } from '@angular/core/testing';
+import { TodoDetailModalComponent } from './todo-detail-modal.component';
+import type { TodoRow } from '../../../core/services/todo.service';
+
+function makeRow(partial: Partial<TodoRow> = {}): TodoRow {
+  return {
+    id: 't1',
+    title: 'Rewrite the auth handler',
+    state: 'todo',
+    created_at: '2026-06-10T00:00:00Z',
+    updated_at: '2026-06-10T00:00:00Z',
+    ...partial,
+  };
+}
+
+describe('TodoDetailModalComponent', () => {
+  let fixture: ComponentFixture<TodoDetailModalComponent>;
+
+  function render(row: TodoRow): void {
+    TestBed.configureTestingModule({ imports: [TodoDetailModalComponent] });
+    fixture = TestBed.createComponent(TodoDetailModalComponent);
+    fixture.componentRef.setInput('item', row);
+    fixture.detectChanges();
+  }
+
+  function el(): HTMLElement {
+    return fixture.nativeElement as HTMLElement;
+  }
+
+  function testid(id: string): HTMLElement | null {
+    return el().querySelector(`[data-testid="${id}"]`);
+  }
+
+  afterEach(() => TestBed.resetTestingModule());
+
+  it('should label the advance verb Start for a todo and show one-time recurrence', () => {
+    render(makeRow({ state: 'todo' }));
+    expect(testid('todo-detail-advance')?.textContent).toContain('Start');
+    expect(testid('todo-detail-recurrence')?.textContent).toContain('One-time');
+    expect(testid('todo-detail-defer')).toBeTruthy();
+  });
+
+  it('should label the advance verb Complete for an in-progress todo', () => {
+    render(makeRow({ state: 'in_progress' }));
+    expect(testid('todo-detail-advance')?.textContent).toContain('Complete');
+  });
+
+  it('should show the recurrence badge and Edit-routine label for a routine', () => {
+    render(makeRow({ recur_interval: 2, recur_unit: 'weeks' }));
+    expect(testid('todo-detail-recurrence')?.textContent).toContain('every 2w');
+    expect(testid('todo-detail-recurrence-edit')?.textContent).toContain(
+      'Edit routine',
+    );
+  });
+
+  it('should hide Defer and offer Activate on a someday row', () => {
+    render(makeRow({ state: 'someday' }));
+    expect(testid('todo-detail-defer')).toBeNull();
+    expect(testid('todo-detail-advance')?.textContent).toContain('Activate');
+  });
+
+  it('should emit the action outputs when the footer buttons are clicked', () => {
+    render(makeRow({ state: 'todo' }));
+    let advanced = 0;
+    let deferred = 0;
+    let dropped = 0;
+    let editedRecurrence = 0;
+    fixture.componentInstance.advance.subscribe(() => advanced++);
+    fixture.componentInstance.deferRow.subscribe(() => deferred++);
+    fixture.componentInstance.dropRow.subscribe(() => dropped++);
+    fixture.componentInstance.editRecurrence.subscribe(() => editedRecurrence++);
+
+    (testid('todo-detail-advance') as HTMLButtonElement).click();
+    (testid('todo-detail-defer') as HTMLButtonElement).click();
+    (testid('todo-detail-drop') as HTMLButtonElement).click();
+    (testid('todo-detail-recurrence-edit') as HTMLButtonElement).click();
+
+    expect([advanced, deferred, dropped, editedRecurrence]).toEqual([1, 1, 1, 1]);
+  });
+});
diff --git a/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.ts b/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.ts
new file mode 100644
index 000000000..53f7713c6
--- /dev/null
+++ b/frontend/src/app/admin/commitment/todos/todo-detail-modal.component.ts
@@ -0,0 +1,72 @@
+import {
+  ChangeDetectionStrategy,
+  Component,
+  computed,
+  input,
+  output,
+} from '@angular/core';
+import type { TodoRow } from '../../../core/services/todo.service';
+import { ModalComponent } from '../../../shared/components/modal/modal.component';
+import { EnergyMeterComponent } from '../../../shared/components/energy-meter/energy-meter.component';
+import { advanceActionFor, energyOf, recurLabel } from './gtd-view';
+import type { EnergyLevel } from '../../../core/models/workbench.model';
+
+/** The next advance verb's button label, by state; null when there is none. */
+const ADVANCE_LABEL: Record<'start' | 'activate' | 'complete', string> = {
+  start: 'Start',
+  activate: 'Activate',
+  complete: 'Complete',
+};
+
+/**
+ * Todo detail panel — opens on a row click to surface, in one discoverable
+ * place, what the row is (state, project, due, energy, whether it is a recurring
+ * routine) and the actions previously hidden behind hover/keyboard: advance its
+ * state, defer it, edit its recurrence, or drop it. A pure view — the GTD store
+ * owns every round-trip; this emits intent against the open detail target.
+ */
+@Component({
+  selector: 'app-todo-detail-modal',
+  imports: [ModalComponent, EnergyMeterComponent],
+  templateUrl: './todo-detail-modal.component.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class TodoDetailModalComponent {
+  readonly item = input.required<TodoRow>();
+  readonly busy = input(false);
+
+  readonly advance = output<void>();
+  readonly deferRow = output<void>();
+  readonly dropRow = output<void>();
+  readonly editRecurrence = output<void>();
+  readonly closed = output<void>();
+
+  /** Human label for the state pill (in_progress → "in progress"). */
+  protected readonly stateLabel = computed(() =>
+    this.item().state.replaceAll('_', ' '),
+  );
+
+  /** The next advance verb's label, or null at a terminal state. */
+  protected readonly advanceLabel = computed(() => {
+    const action = advanceActionFor(this.item().state);
+    return action ? ADVANCE_LABEL[action] : null;
+  });
+
+  /** Someday rows re-enter the backlog via Activate; they cannot be deferred. */
+  protected readonly showDefer = computed(() => this.item().state !== 'someday');
+
+  /** Recurrence summary ("every 2w" / "Mon Thu" / "daily"), null if one-time. */
+  protected readonly recurrence = computed(() =>
+    recurLabel(
+      this.item().recur_interval,
+      this.item().recur_unit,
+      this.item().recur_weekdays,
+    ),
+  );
+
+  protected readonly energy = computed((): EnergyLevel | null =>
+    energyOf(this.item().energy),
+  );
+
+  protected readonly due = computed(() => this.item().due?.slice(0, 10) ?? null);
+}
diff --git a/frontend/src/app/app.routes.ts b/frontend/src/app/app.routes.ts
index 12d40a7f4..9ba319ee9 100644
--- a/frontend/src/app/app.routes.ts
+++ b/frontend/src/app/app.routes.ts
@@ -111,10 +111,9 @@ export const routes: Routes = [
       {
         path: 'daily/inbox',
         loadComponent: () =>
-          import('./admin/commitment/todos/gtd.page').then(
-            (m) => m.GtdPageComponent,
+          import('./admin/commitment/inbox/inbox.page').then(
+            (m) => m.InboxPageComponent,
           ),
-        data: { gtdView: 'inbox' },
       },
       {
         path: 'daily/todos',
@@ -122,7 +121,14 @@ export const routes: Routes = [
           import('./admin/commitment/todos/gtd.page').then(
             (m) => m.GtdPageComponent,
           ),
-        data: { gtdView: 'today' },
+        data: { gtdView: 'pending' },
+      },
+      {
+        path: 'daily/routines',
+        loadComponent: () =>
+          import('./admin/commitment/routines/routines.page').then(
+            (m) => m.RoutinesPageComponent,
+          ),
       },
 
       // ── Commitment ───────────────────────────────────────────────
diff --git a/frontend/src/app/core/models/workbench.model.ts b/frontend/src/app/core/models/workbench.model.ts
index b8b6e6e81..9f28db67d 100644
--- a/frontend/src/app/core/models/workbench.model.ts
+++ b/frontend/src/app/core/models/workbench.model.ts
@@ -146,7 +146,17 @@ export interface CellState {
 // Todo — shared enums (todo list / plan / detail views).
 // ============================================================
 
-export type TodoState = 'inbox' | 'todo' | 'in_progress' | 'done' | 'someday';
+// Mirrors the backend todo_state enum (internal/todo/todo.go). archived and
+// dismissed are terminal self-close states (filed away / won't do), distinct
+// from done; they surface in the Complete view as "dropped".
+export type TodoState =
+  | 'inbox'
+  | 'todo'
+  | 'in_progress'
+  | 'done'
+  | 'someday'
+  | 'archived'
+  | 'dismissed';
 
 export type EnergyLevel = 'low' | 'medium' | 'high';
 export type PriorityLevel = 'low' | 'medium' | 'high';
diff --git a/frontend/src/app/core/services/todo.service.ts b/frontend/src/app/core/services/todo.service.ts
index d81560d6b..987d71506 100644
--- a/frontend/src/app/core/services/todo.service.ts
+++ b/frontend/src/app/core/services/todo.service.ts
@@ -57,24 +57,34 @@ export interface TodoItem {
   recur_unit?: string | null;
   /** Weekday-mode recurrence mask (Mon=bit0..Sun=bit6); see TodoRow. */
   recur_weekdays?: number | null;
+  /** Date of the most recent recurring occurrence (YYYY-MM-DD); null if never. */
+  last_completed_on?: string | null;
   description?: string;
   created_by: string;
   created_at: string;
   updated_at: string;
 }
 
-/** GET /todos/recurring: occurrences due today (compute-on-read). */
+/**
+ * GET /todos/recurring. due_today is the compute-on-read occurrences due today;
+ * all is every active recurring schedule (the routines overview / manage-all
+ * view), regardless of whether it is due today.
+ */
 export interface RecurringBuckets {
   due_today: TodoItem[];
+  all: TodoItem[];
 }
 
 /**
- * History row — the common projection of the two history wire shapes
- * (completed-since default path and the ?q= full-text search path).
+ * History row — the common projection of the two history wire shapes (the
+ * resolved-since default path and the ?q= full-text search path). state carries
+ * the resolution kind so the Complete view can badge done / dropped / recurring;
+ * completed_at holds the per-kind resolution instant.
  */
 export interface TodoHistoryEntry {
   id: string;
   title: string;
+  state?: TodoState;
   completed_at?: string | null;
   project_title: string;
 }
diff --git a/internal/db/query.sql.go b/internal/db/query.sql.go
index 637c6b47a..1fb3ecbcd 100644
--- a/internal/db/query.sql.go
+++ b/internal/db/query.sql.go
@@ -455,6 +455,61 @@ func (q *Queries) AllPublishedSlugs(ctx context.Context) ([]AllPublishedSlugsRow
 	return items, nil
 }
 
+const allRecurringTodoItems = `-- name: AllRecurringTodoItems :many
+SELECT id, title, state, due, project_id,
+       completed_at, energy, priority, recur_interval, recur_unit, recur_weekdays, last_completed_on,
+       description, created_by, created_at, updated_at
+FROM todos
+WHERE state NOT IN ('done', 'someday', 'inbox', 'archived', 'dismissed')
+  AND (recur_weekdays IS NOT NULL OR recur_interval IS NOT NULL)
+ORDER BY priority NULLS LAST, title
+`
+
+// Every active recurring todo's schedule, for the routines overview (manage all
+// routines, not just today's due ones — distinct from RecurringTodoItemsDueToday).
+// Uses the SAME active-state filter as RecurringTodoItemsDueToday so the overview
+// is a superset of the due-today list and never shows a closed routine: a
+// terminally done, someday-parked, still-in-inbox, or archived/dismissed
+// recurring row is not a live schedule and is reachable on its own surface
+// (Complete / Someday / Inbox tabs). Selects the full todos column set so sqlc
+// returns db.Todo and rowToItem applies.
+func (q *Queries) AllRecurringTodoItems(ctx context.Context) ([]Todo, error) {
+	rows, err := q.db.Query(ctx, allRecurringTodoItems)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []Todo{}
+	for rows.Next() {
+		var i Todo
+		if err := rows.Scan(
+			&i.ID,
+			&i.Title,
+			&i.State,
+			&i.Due,
+			&i.ProjectID,
+			&i.CompletedAt,
+			&i.Energy,
+			&i.Priority,
+			&i.RecurInterval,
+			&i.RecurUnit,
+			&i.RecurWeekdays,
+			&i.LastCompletedOn,
+			&i.Description,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const archiveContentReturning = `-- name: ArchiveContentReturning :one
 UPDATE contents SET status = 'archived', review_note = NULL, updated_at = now()
 WHERE id = $1
@@ -985,39 +1040,57 @@ func (q *Queries) CompletedMilestonesInWindow(ctx context.Context, arg Completed
 	return items, nil
 }
 
-const completedTodoDetailSince = `-- name: CompletedTodoDetailSince :many
-SELECT t.id, t.title, t.completed_at, t.project_id,
-       COALESCE(p.title, '') AS project_title
-FROM todos t
-LEFT JOIN projects p ON t.project_id = p.id
-WHERE t.state = 'done' AND t.completed_at >= $1
-ORDER BY t.completed_at DESC
-`
-
-type CompletedTodoDetailSinceRow struct {
-	ID           uuid.UUID  `json:"id"`
-	Title        string     `json:"title"`
-	CompletedAt  *time.Time `json:"completed_at"`
-	ProjectID    *uuid.UUID `json:"project_id"`
-	ProjectTitle string     `json:"project_title"`
-}
-
-// Get todo items completed since a given time with project context.
-func (q *Queries) CompletedTodoDetailSince(ctx context.Context, since *time.Time) ([]CompletedTodoDetailSinceRow, error) {
-	rows, err := q.db.Query(ctx, completedTodoDetailSince, since)
+const completedTodoItemsOn = `-- name: CompletedTodoItemsOn :many
+SELECT id, title, state, due, project_id,
+       completed_at, energy, priority, recur_interval, recur_unit, recur_weekdays, last_completed_on,
+       description, created_by, created_at, updated_at
+FROM todos
+WHERE (state = 'done' AND completed_at >= $1 AND completed_at < $2)
+   OR ((recur_weekdays IS NOT NULL OR recur_interval IS NOT NULL)
+       AND last_completed_on = $3::date)
+ORDER BY completed_at DESC NULLS LAST, last_completed_on DESC NULLS LAST, title
+`
+
+type CompletedTodoItemsOnParams struct {
+	DayStart *time.Time `json:"day_start"`
+	DayEnd   *time.Time `json:"day_end"`
+	Today    time.Time  `json:"today"`
+}
+
+// Todos completed on @today, for the Today dashboard's done-today count and
+// list. Two arms: a one-time todo finished within the day window [@day_start,
+// @day_end) (state=done, completed_at in range), OR a recurring todo whose
+// occurrence was stamped on @today (last_completed_on = @today). A recurring
+// todo terminally closed the same day it had an occurrence stamped satisfies
+// both arms, but a WHERE-OR over a base table emits each row once, so the done
+// count is never inflated. Selects the full todos column set (no join) so sqlc
+// returns db.Todo and rowToItem applies.
+func (q *Queries) CompletedTodoItemsOn(ctx context.Context, arg CompletedTodoItemsOnParams) ([]Todo, error) {
+	rows, err := q.db.Query(ctx, completedTodoItemsOn, arg.DayStart, arg.DayEnd, arg.Today)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	items := []CompletedTodoDetailSinceRow{}
+	items := []Todo{}
 	for rows.Next() {
-		var i CompletedTodoDetailSinceRow
+		var i Todo
 		if err := rows.Scan(
 			&i.ID,
 			&i.Title,
-			&i.CompletedAt,
+			&i.State,
+			&i.Due,
 			&i.ProjectID,
-			&i.ProjectTitle,
+			&i.CompletedAt,
+			&i.Energy,
+			&i.Priority,
+			&i.RecurInterval,
+			&i.RecurUnit,
+			&i.RecurWeekdays,
+			&i.LastCompletedOn,
+			&i.Description,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
 		); err != nil {
 			return nil, err
 		}
@@ -5026,6 +5099,65 @@ func (q *Queries) ResolveTodoByCreator(ctx context.Context, arg ResolveTodoByCre
 	return i, err
 }
 
+const resolvedTodoDetailSince = `-- name: ResolvedTodoDetailSince :many
+SELECT t.id, t.title, t.state,
+       CASE
+           WHEN t.state = 'done' THEN t.completed_at
+           WHEN t.state IN ('archived', 'dismissed') THEN t.updated_at
+           ELSE t.last_completed_on::timestamptz
+       END AS resolved_at,
+       COALESCE(p.title, '') AS project_title
+FROM todos t
+LEFT JOIN projects p ON t.project_id = p.id
+WHERE (t.state = 'done' AND t.completed_at >= $1)
+   OR (t.state IN ('archived', 'dismissed') AND t.updated_at >= $1)
+   OR ((t.recur_weekdays IS NOT NULL OR t.recur_interval IS NOT NULL)
+       AND t.state NOT IN ('done', 'archived', 'dismissed')
+       AND t.last_completed_on IS NOT NULL
+       AND t.last_completed_on >= $1::date)
+ORDER BY resolved_at DESC NULLS LAST
+`
+
+type ResolvedTodoDetailSinceRow struct {
+	ID           uuid.UUID `json:"id"`
+	Title        string    `json:"title"`
+	State        TodoState `json:"state"`
+	ResolvedAt   time.Time `json:"resolved_at"`
+	ProjectTitle string    `json:"project_title"`
+}
+
+// Resolved ("已了結") todos since a given time, for the Todos page Complete tab:
+// one-time todos done (state=done, by completed_at), todos dropped/filed
+// (archived/dismissed, by updated_at), and recurring routines with a recent
+// occurrence (last_completed_on, while still active so the schedule keeps
+// running). resolved_at is the per-kind resolution instant; state lets the
+// front end badge the kind (done / archived / dismissed / recurring-active).
+func (q *Queries) ResolvedTodoDetailSince(ctx context.Context, since *time.Time) ([]ResolvedTodoDetailSinceRow, error) {
+	rows, err := q.db.Query(ctx, resolvedTodoDetailSince, since)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ResolvedTodoDetailSinceRow{}
+	for rows.Next() {
+		var i ResolvedTodoDetailSinceRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.Title,
+			&i.State,
+			&i.ResolvedAt,
+			&i.ProjectTitle,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const retireAgent = `-- name: RetireAgent :execrows
 UPDATE agents
 SET status     = 'retired',
@@ -5285,99 +5417,65 @@ func (q *Queries) SearchContentsCount(ctx context.Context, arg SearchContentsCou
 	return count, err
 }
 
-const searchTodoItems = `-- name: SearchTodoItems :many
-SELECT t.id, t.title, t.state, t.due, t.project_id,
-       t.energy, t.priority, t.recur_interval, t.recur_unit, t.recur_weekdays, t.last_completed_on,
-       t.completed_at, t.description, t.created_at, t.updated_at,
-       COALESCE(p.title, '') AS project_title,
-       COALESCE(p.slug, '') AS project_slug
+const searchResolvedTodoItems = `-- name: SearchResolvedTodoItems :many
+SELECT t.id, t.title, t.state,
+       CASE
+           WHEN t.state = 'done' THEN t.completed_at
+           WHEN t.state IN ('archived', 'dismissed') THEN t.updated_at
+           ELSE t.last_completed_on::timestamptz
+       END AS resolved_at,
+       COALESCE(p.title, '') AS project_title
 FROM todos t
 LEFT JOIN projects p ON t.project_id = p.id
-WHERE ($1::text IS NULL OR (t.title ILIKE '%' || $1 || '%' OR t.description ILIKE '%' || $1 || '%'))
-  AND ($2::text IS NULL OR p.slug = $2)
-  AND ($3::text IS NULL OR
-       CASE $3
-           WHEN 'pending' THEN t.state != 'done'
-           WHEN 'done' THEN t.state = 'done'
-           ELSE true
-       END)
-  AND ($4::timestamptz IS NULL OR t.completed_at >= $4)
-  AND ($5::timestamptz IS NULL OR t.completed_at < $5)
-ORDER BY
-    CASE WHEN t.state != 'done' THEN 0 ELSE 1 END,
-    CASE WHEN t.state != 'done' THEN
-        CASE WHEN t.due IS NOT NULL THEN 0 ELSE 1 END
-    ELSE 2 END,
-    t.due ASC NULLS LAST,
-    t.completed_at DESC NULLS LAST,
-    t.updated_at ASC
-LIMIT $6
+WHERE (t.title ILIKE '%' || $1 || '%' OR t.description ILIKE '%' || $1 || '%')
+  AND (
+        (t.state = 'done' AND t.completed_at >= $2)
+     OR (t.state IN ('archived', 'dismissed') AND t.updated_at >= $2)
+     OR ((t.recur_weekdays IS NOT NULL OR t.recur_interval IS NOT NULL)
+         AND t.state NOT IN ('done', 'archived', 'dismissed')
+         AND t.last_completed_on IS NOT NULL
+         AND t.last_completed_on >= $2::date)
+      )
+ORDER BY resolved_at DESC NULLS LAST
+LIMIT $3
 `
 
-type SearchTodoItemsParams struct {
-	Query           *string    `json:"query"`
-	ProjectSlug     *string    `json:"project_slug"`
-	StateFilter     *string    `json:"state_filter"`
-	CompletedAfter  *time.Time `json:"completed_after"`
-	CompletedBefore *time.Time `json:"completed_before"`
-	MaxResults      int32      `json:"max_results"`
-}
-
-type SearchTodoItemsRow struct {
-	ID              uuid.UUID  `json:"id"`
-	Title           string     `json:"title"`
-	State           TodoState  `json:"state"`
-	Due             *time.Time `json:"due"`
-	ProjectID       *uuid.UUID `json:"project_id"`
-	Energy          *string    `json:"energy"`
-	Priority        *string    `json:"priority"`
-	RecurInterval   *int32     `json:"recur_interval"`
-	RecurUnit       *string    `json:"recur_unit"`
-	RecurWeekdays   *int16     `json:"recur_weekdays"`
-	LastCompletedOn *time.Time `json:"last_completed_on"`
-	CompletedAt     *time.Time `json:"completed_at"`
-	Description     string     `json:"description"`
-	CreatedAt       time.Time  `json:"created_at"`
-	UpdatedAt       time.Time  `json:"updated_at"`
-	ProjectTitle    string     `json:"project_title"`
-	ProjectSlug     string     `json:"project_slug"`
+type SearchResolvedTodoItemsParams struct {
+	Query      *string    `json:"query"`
+	Since      *time.Time `json:"since"`
+	MaxResults int32      `json:"max_results"`
 }
 
-// Search todo items by title/description with optional filters.
-func (q *Queries) SearchTodoItems(ctx context.Context, arg SearchTodoItemsParams) ([]SearchTodoItemsRow, error) {
-	rows, err := q.db.Query(ctx, searchTodoItems,
-		arg.Query,
-		arg.ProjectSlug,
-		arg.StateFilter,
-		arg.CompletedAfter,
-		arg.CompletedBefore,
-		arg.MaxResults,
-	)
+type SearchResolvedTodoItemsRow struct {
+	ID           uuid.UUID `json:"id"`
+	Title        string    `json:"title"`
+	State        TodoState `json:"state"`
+	ResolvedAt   time.Time `json:"resolved_at"`
+	ProjectTitle string    `json:"project_title"`
+}
+
+// The ?q= search counterpart of ResolvedTodoDetailSince: resolved ("已了結")
+// todos since @since whose title or description matches @query. It applies the
+// SAME resolution arms as ResolvedTodoDetailSince (done by completed_at, dropped
+// by updated_at, recurring by last_completed_on) so the Complete tab's search
+// covers done, dropped, AND recurring resolutions — not only done. @query is
+// pre-escaped by the caller (escapeILIKE); the wrapping wildcards are the only
+// ILIKE metacharacters. resolved_at is the per-kind resolution instant.
+func (q *Queries) SearchResolvedTodoItems(ctx context.Context, arg SearchResolvedTodoItemsParams) ([]SearchResolvedTodoItemsRow, error) {
+	rows, err := q.db.Query(ctx, searchResolvedTodoItems, arg.Query, arg.Since, arg.MaxResults)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	items := []SearchTodoItemsRow{}
+	items := []SearchResolvedTodoItemsRow{}
 	for rows.Next() {
-		var i SearchTodoItemsRow
+		var i SearchResolvedTodoItemsRow
 		if err := rows.Scan(
 			&i.ID,
 			&i.Title,
 			&i.State,
-			&i.Due,
-			&i.ProjectID,
-			&i.Energy,
-			&i.Priority,
-			&i.RecurInterval,
-			&i.RecurUnit,
-			&i.RecurWeekdays,
-			&i.LastCompletedOn,
-			&i.CompletedAt,
-			&i.Description,
-			&i.CreatedAt,
-			&i.UpdatedAt,
+			&i.ResolvedAt,
 			&i.ProjectTitle,
-			&i.ProjectSlug,
 		); err != nil {
 			return nil, err
 		}
diff --git a/internal/today/handler.go b/internal/today/handler.go
index 9ab2105e7..12715b75f 100644
--- a/internal/today/handler.go
+++ b/internal/today/handler.go
@@ -38,12 +38,20 @@ type todoActiveReader interface {
 	RecurringItemsDueToday(ctx context.Context, today time.Time) ([]todo.Item, error)
 }
 
+// todoCompletedReader returns the todos completed today — one-time todos done
+// within the day window plus recurring occurrences stamped today — backing the
+// Today Completed count and review list. Backed by *todo.Store.
+type todoCompletedReader interface {
+	CompletedItemsOn(ctx context.Context, today, dayStart, dayEnd time.Time) ([]todo.Item, error)
+}
+
 // TodoReader is the todo-views surface the Today aggregate composes — the
 // consumer-boundary subset of *todo.Store it depends on, split by role so each
 // part stays small (interfaces.md).
 type TodoReader interface {
 	todoDateReader
 	todoActiveReader
+	todoCompletedReader
 }
 
 // PlanItemReader returns the day's committed daily plan items. Backed by
@@ -130,6 +138,7 @@ func (h *Handler) Today(w http.ResponseWriter, r *http.Request) {
 		TodayTodos:     []todo.PendingDetail{},
 		ActiveTodos:    []todo.PendingDetail{},
 		RecurringTodos: []todo.Item{},
+		CompletedTodos: []todo.Item{},
 		CommittedTodos: []daily.Item{},
 		UpcomingTodos:  []todo.PendingDetail{},
 		ActiveGoals:    []goal.ActiveGoalSummary{},
@@ -137,6 +146,7 @@ func (h *Handler) Today(w http.ResponseWriter, r *http.Request) {
 	}
 
 	h.loadTodos(ctx, date, &resp)
+	h.loadCompleted(ctx, date, &resp)
 	h.loadPlan(ctx, date, &resp)
 	// Active dedups against the date sections, the plan, and recurring, so it
 	// must run after loadTodos + loadPlan have populated them.
@@ -216,29 +226,36 @@ func (h *Handler) loadActive(ctx context.Context, resp *Response) {
 	resp.ActiveTodos = active
 }
 
+// loadCompleted fills CompletedTodos with what was finished today — one-time
+// todos done within [date, date+1d) plus recurring occurrences stamped today —
+// feeding the front end's Completed count (derived from len(CompletedTodos))
+// and the "completed today" list.
+func (h *Handler) loadCompleted(ctx context.Context, date time.Time, resp *Response) {
+	if h.todos == nil {
+		return
+	}
+	dayEnd := date.AddDate(0, 0, 1)
+	if rows, err := h.todos.CompletedItemsOn(ctx, date, date, dayEnd); err != nil {
+		h.logger.Warn("today: completed todos failed", "error", err)
+	} else if rows != nil {
+		resp.CompletedTodos = rows
+	}
+}
+
+// loadPlan fills CommittedTodos with the day's committed plan. The plan is now
+// an optional pin: it no longer drives the progress counts (the front end
+// derives those from the due/recurring/completed section lengths), so a missing
+// plan does not zero the dashboard — hence a failure logs at Warn like the other
+// optional sections, not Error.
 func (h *Handler) loadPlan(ctx context.Context, date time.Time, resp *Response) {
 	items, err := h.planItems.ItemsByDate(ctx, date)
 	if err != nil {
-		h.logger.Error("today: plan items failed", "error", err)
+		h.logger.Warn("today: plan items failed", "error", err)
 		return
 	}
 	if items != nil {
 		resp.CommittedTodos = items
 	}
-	// Completion derives from the backing todo's state (and recurring-occurrence
-	// completion), NOT daily_plan_items.status — that column has no write path,
-	// so it is always 'planned'. daily.Item.IsCompletedOn/IsDeferred is the
-	// single source brief(reflection) also uses, so the two surfaces agree.
-	for i := range items {
-		switch {
-		case items[i].IsCompletedOn(date):
-			resp.PlanCompletion.Completed++
-		case items[i].IsDeferred():
-			resp.PlanCompletion.Deferred++
-		default:
-			resp.PlanCompletion.Planned++
-		}
-	}
 }
 
 func (h *Handler) loadGoals(ctx context.Context, resp *Response) {
diff --git a/internal/today/handler_test.go b/internal/today/handler_test.go
index fa953df34..a86a0fdd4 100644
--- a/internal/today/handler_test.go
+++ b/internal/today/handler_test.go
@@ -40,6 +40,7 @@ type fakeTodos struct {
 	inRange    []todo.PendingDetail
 	inProgress []todo.PendingDetail
 	recurring  []todo.Item
+	completed  []todo.Item
 }
 
 func (f *fakeTodos) OverdueItems(context.Context, time.Time) ([]todo.PendingDetail, error) {
@@ -62,6 +63,10 @@ func (f *fakeTodos) RecurringItemsDueToday(context.Context, time.Time) ([]todo.I
 	return f.recurring, nil
 }
 
+func (f *fakeTodos) CompletedItemsOn(context.Context, time.Time, time.Time, time.Time) ([]todo.Item, error) {
+	return f.completed, nil
+}
+
 // fakeGoals satisfies ActiveGoalReader.
 type fakeGoals struct {
 	goals []goal.ActiveGoalSummary
@@ -114,6 +119,7 @@ func TestToday_EmptyStateReturnsEmptyArrays(t *testing.T) {
 		TodayTodos:     []todo.PendingDetail{},
 		ActiveTodos:    []todo.PendingDetail{},
 		RecurringTodos: []todo.Item{},
+		CompletedTodos: []todo.Item{},
 		CommittedTodos: []daily.Item{},
 		UpcomingTodos:  []todo.PendingDetail{},
 		ActiveGoals:    []goal.ActiveGoalSummary{},
@@ -127,7 +133,7 @@ func TestToday_EmptyStateReturnsEmptyArrays(t *testing.T) {
 	raw := rec.Body.String()
 	for _, field := range []string{
 		"overdue_todos", "today_todos", "active_todos", "recurring_todos",
-		"committed_todos", "upcoming_todos",
+		"completed_todos", "committed_todos", "upcoming_todos",
 		"active_goals", "rss_highlights",
 	} {
 		if strings.Contains(raw, `"`+field+`":null`) {
@@ -137,33 +143,42 @@ func TestToday_EmptyStateReturnsEmptyArrays(t *testing.T) {
 }
 
 // TestToday_WiredSectionsPopulate proves each wired reader contributes its
-// section and plan completion counts derive from the committed items.
+// section and that the day-progress strip is due-based: the front end derives
+// open from due-today + recurring + started work, overdue from the overdue
+// section, and completed from today's completions — independent of any
+// committed plan. This test pins the section lengths those figures sum.
 func TestToday_WiredSectionsPopulate(t *testing.T) {
 	t.Parallel()
 
 	overdue := []todo.PendingDetail{{ID: uuid.New(), Title: "ship audit memo"}}
 	dueOn := []todo.PendingDetail{{ID: uuid.New(), Title: "review draft"}}
 	inRange := []todo.PendingDetail{{ID: uuid.New(), Title: "next week task"}}
+	started := todo.PendingDetail{ID: uuid.New(), Title: "started, undated", State: todo.StateInProgress}
+	recurring := []todo.Item{
+		{ID: uuid.New(), Title: "morning Japanese"},
+		{ID: uuid.New(), Title: "standup"},
+	}
+	completed := []todo.Item{
+		{ID: uuid.New(), Title: "shipped one-time"},
+		{ID: uuid.New(), Title: "morning Japanese (done today)"},
+	}
 	goals := []goal.ActiveGoalSummary{{Goal: goal.Goal{ID: uuid.New(), Title: "GDE application"}}}
 
-	// Completion derives from the backing todo's state (+ recurring-occurrence
-	// completion), not daily_plan_items.status (which has no write path). Each
-	// item carries Status=planned (the only value the dead column ever holds) to
-	// prove it is IGNORED; the TodoState / recurrence fields drive the counts.
-	now := time.Now().UTC()
-	todayUTC := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
-	recurInterval := int32(1)
-	planItems := []daily.Item{
-		{ID: uuid.New(), Status: daily.StatusPlanned, TodoState: "todo"},    // → Planned
-		{ID: uuid.New(), Status: daily.StatusPlanned, TodoState: "done"},    // → Completed (terminal)
-		{ID: uuid.New(), Status: daily.StatusPlanned, TodoState: "someday"}, // → Deferred
-		{ID: uuid.New(), Status: daily.StatusPlanned, TodoState: "in_progress", // recurring occurrence completed today → Completed
-			TodoRecurInterval: &recurInterval, TodoLastCompletedOn: &todayUTC},
-	}
+	// A committed plan is present but must NOT drive progress — it is an optional
+	// pin now. If progress regressed to plan-based counting this planned item
+	// would skew Open, so the assertion below would catch the regression.
+	planItems := []daily.Item{{ID: uuid.New(), TodoID: uuid.New(), Status: daily.StatusPlanned, TodoState: "todo"}}
 
 	h := NewHandler(fakePlanItems{items: planItems}, time.UTC, slog.New(slog.NewTextHandler(io.Discard, nil))).
 		WithSources(
-			&fakeTodos{overdue: overdue, dueOn: dueOn, inRange: inRange},
+			&fakeTodos{
+				overdue:    overdue,
+				dueOn:      dueOn,
+				inRange:    inRange,
+				inProgress: []todo.PendingDetail{started},
+				recurring:  recurring,
+				completed:  completed,
+			},
 			fakeGoals{goals: goals},
 			nil, // rss left nil — its section must stay []
 		)
@@ -184,12 +199,22 @@ func TestToday_WiredSectionsPopulate(t *testing.T) {
 		t.Errorf("active_goals mismatch (-want +got):\n%s", diff)
 	}
 
-	wantCompletion := PlanCompletion{Planned: 1, Completed: 2, Deferred: 1}
-	if diff := cmp.Diff(wantCompletion, got.PlanCompletion); diff != "" {
-		t.Errorf("plan_completion mismatch (-want +got):\n%s", diff)
+	// The day-progress strip is derived (front end) from these section lengths:
+	// open = due-today(1) + recurring(2) + started(1) = 4 — the upcoming-week
+	// section is NOT today's work and must not leak in; overdue = 1; completed =
+	// today's completions = 2. Pin every contributing section so a regression in
+	// the active-dedup or completed wiring is caught here.
+	if n := len(got.ActiveTodos); n != 1 {
+		t.Errorf("active_todos len = %d, want 1", n)
+	}
+	if n := len(got.RecurringTodos); n != 2 {
+		t.Errorf("recurring_todos len = %d, want 2", n)
+	}
+	if n := len(got.CompletedTodos); n != 2 {
+		t.Errorf("completed_todos len = %d, want 2", n)
 	}
-	if n := len(got.CommittedTodos); n != 4 {
-		t.Errorf("committed_todos len = %d, want 4", n)
+	if n := len(got.CommittedTodos); n != 1 {
+		t.Errorf("committed_todos len = %d, want 1", n)
 	}
 	if n := len(got.RSSHighlights); n != 0 {
 		t.Errorf("rss_highlights len = %d, want 0 (reader is nil)", n)
diff --git a/internal/today/today.go b/internal/today/today.go
index 4a6f95c1e..9c5321be0 100644
--- a/internal/today/today.go
+++ b/internal/today/today.go
@@ -27,14 +27,6 @@ type RSSHighlight struct {
 	CreatedAt string `json:"created_at"`
 }
 
-// PlanCompletion is the small counts panel derived from the day's
-// committed plan items: how many are still planned, done, or deferred.
-type PlanCompletion struct {
-	Planned   int `json:"planned"`
-	Completed int `json:"completed"`
-	Deferred  int `json:"deferred"`
-}
-
 // Response is the wire shape for GET /api/admin/commitment/today. It
 // carries the same morning sections as brief(mode=morning), exposed via
 // the admin API. List fields always marshal as [] (never null).
@@ -43,15 +35,23 @@ type PlanCompletion struct {
 // and due-today routines were invisible on the day's surfaces: ActiveTodos is
 // in_progress work not already shown by a date section or the plan; RecurringTodos
 // is the compute-on-read due-today routines (mirrors brief(morning)).
+//
+// CompletedTodos is what was finished today (one-time todos done today plus
+// recurring occurrences stamped today): it backs the "completed today" review
+// list, and the admin Today strip derives its done count from this section's
+// length. The day-progress strip is due-based — its open / overdue / completed
+// figures are the lengths of the today+recurring+active, overdue, and completed
+// sections, so it never depends on a committed plan existing. CommittedTodos is
+// the day's committed plan, retained as an optional pin only.
 type Response struct {
 	Date           string                   `json:"date"`
 	OverdueTodos   []todo.PendingDetail     `json:"overdue_todos"`
 	TodayTodos     []todo.PendingDetail     `json:"today_todos"`
 	ActiveTodos    []todo.PendingDetail     `json:"active_todos"`
 	RecurringTodos []todo.Item              `json:"recurring_todos"`
+	CompletedTodos []todo.Item              `json:"completed_todos"`
 	CommittedTodos []daily.Item             `json:"committed_todos"`
 	UpcomingTodos  []todo.PendingDetail     `json:"upcoming_todos"`
-	PlanCompletion PlanCompletion           `json:"plan_completion"`
 	ActiveGoals    []goal.ActiveGoalSummary `json:"active_goals"`
 	RSSHighlights  []RSSHighlight           `json:"rss_highlights"`
 }
diff --git a/internal/todo/handler.go b/internal/todo/handler.go
index 73215e6a5..cef2149e0 100644
--- a/internal/todo/handler.go
+++ b/internal/todo/handler.go
@@ -163,10 +163,13 @@ func (h *Handler) List(w http.ResponseWriter, r *http.Request) {
 	api.Encode(w, http.StatusOK, api.Response{Data: out})
 }
 
-// recurringResponse is the wire shape for GET /todos/recurring. The array is
-// non-nil so an empty result serializes [] not null.
+// recurringResponse is the wire shape for GET /todos/recurring. Both arrays are
+// non-nil so an empty result serializes [] not null. DueToday is the compute-on-
+// read occurrences due today; All is every active recurring schedule, for the
+// routines overview (manage-all view).
 type recurringResponse struct {
 	DueToday []Item `json:"due_today"`
+	All      []Item `json:"all"`
 }
 
 // Recurring handles GET /api/admin/commitment/todos/recurring — the recurring
@@ -185,7 +188,14 @@ func (h *Handler) Recurring(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	resp := recurringResponse{DueToday: ensureItems(dueToday)}
+	all, err := h.store.AllRecurringItems(r.Context())
+	if err != nil {
+		h.logger.Error("listing all recurring todos", "error", err)
+		api.Error(w, http.StatusInternalServerError, "INTERNAL", "failed to list recurring todos")
+		return
+	}
+
+	resp := recurringResponse{DueToday: ensureItems(dueToday), All: ensureItems(all)}
 	api.Encode(w, http.StatusOK, api.Response{Data: resp})
 }
 
@@ -199,10 +209,11 @@ const (
 	historyMaxLimit     = 100
 )
 
-// History handles GET /api/admin/commitment/todos/history. With ?q= it
-// runs the full-text search path; without it, the completed-since path.
-// Query params: since (YYYY-MM-DD, default 30d ago), q, project (slug),
-// limit (1-100, default 20).
+// History handles GET /api/admin/commitment/todos/history — the Complete
+// ("已了結") view. With ?q= it searches the resolved set (done + dropped +
+// recurring occurrences) by title/description; without it, it lists the same
+// resolved set since the cutoff. Query params: since (YYYY-MM-DD, default 30d
+// ago), q, limit (1-100, default 20).
 func (h *Handler) History(w http.ResponseWriter, r *http.Request) {
 	q := r.URL.Query()
 
@@ -226,39 +237,36 @@ func (h *Handler) History(w http.ResponseWriter, r *http.Request) {
 		limit = n
 	}
 
-	// Search path: ?q= present → full-text search over the historical
-	// record, scoped to completed-after the since cutoff so the same
-	// window applies to both paths.
+	// Search path: ?q= present → search the SAME resolved set as the default
+	// view (done + dropped + recurring occurrences), title/description match,
+	// within the since window. Matching the default view's arms is what makes a
+	// dropped or recurring resolution searchable in the Complete tab.
 	if query := q.Get("q"); query != "" {
-		var projectSlug *string
-		if p := q.Get("project"); p != "" {
-			projectSlug = &p
-		}
-		sinceCopy := since
-		results, err := h.store.SearchItems(r.Context(), &query, projectSlug, nil, &sinceCopy, nil, int32(limit)) // #nosec G115 -- limit bounded to [1, 100]
+		results, err := h.store.SearchResolvedItems(r.Context(), query, since, int32(limit)) // #nosec G115 -- limit bounded to [1, 100]
 		if err != nil {
 			h.logger.Error("searching todo history", "error", err)
 			api.Error(w, http.StatusInternalServerError, "INTERNAL", "failed to search todo history")
 			return
 		}
 		if results == nil {
-			results = []SearchDetail{}
+			results = []ResolvedDetail{}
 		}
 		api.Encode(w, http.StatusOK, api.Response{Data: results})
 		return
 	}
 
-	// Completed-since path: the default history view.
-	completed, err := h.store.CompletedItemsDetailSince(r.Context(), since)
+	// Resolved-since path: the default Complete-tab view — done, dropped, and
+	// recurring routines' recent occurrences.
+	resolved, err := h.store.ResolvedItemsDetailSince(r.Context(), since)
 	if err != nil {
-		h.logger.Error("listing completed todo history", "error", err)
+		h.logger.Error("listing resolved todo history", "error", err)
 		api.Error(w, http.StatusInternalServerError, "INTERNAL", "failed to list todo history")
 		return
 	}
-	if completed == nil {
-		completed = []CompletedDetail{}
+	if resolved == nil {
+		resolved = []ResolvedDetail{}
 	}
-	api.Encode(w, http.StatusOK, api.Response{Data: completed})
+	api.Encode(w, http.StatusOK, api.Response{Data: resolved})
 }
 
 // ensureItems returns a non-nil slice so empty results serialize as [].
diff --git a/internal/todo/history.go b/internal/todo/history.go
index dc67184b0..4c62e607f 100644
--- a/internal/todo/history.go
+++ b/internal/todo/history.go
@@ -15,60 +15,52 @@ import (
 	"github.com/Koopa0/koopa/internal/db"
 )
 
-// SearchItems searches todo items with optional filters.
-func (s *Store) SearchItems(ctx context.Context, query, projectSlug, stateFilter *string, completedAfter, completedBefore *time.Time, maxResults int32) ([]SearchDetail, error) {
-	var escapedQuery *string
-	if query != nil {
-		v := escapeILIKE(*query)
-		escapedQuery = &v
-	}
-	rows, err := s.q.SearchTodoItems(ctx, db.SearchTodoItemsParams{
-		Query:           escapedQuery,
-		ProjectSlug:     projectSlug,
-		StateFilter:     stateFilter,
-		CompletedAfter:  completedAfter,
-		CompletedBefore: completedBefore,
-		MaxResults:      maxResults,
+// SearchResolvedItems searches resolved ("已了結") todos — done, dropped
+// (archived/dismissed), or a recurring routine's recent occurrence — by title
+// or description, for the Complete tab's ?q= path. It shares the resolution
+// arms of ResolvedItemsDetailSince so the search covers the same set the default
+// view shows, not just done items. See SearchResolvedTodoItems in query.sql.
+func (s *Store) SearchResolvedItems(ctx context.Context, query string, since time.Time, maxResults int32) ([]ResolvedDetail, error) {
+	escaped := escapeILIKE(query)
+	rows, err := s.q.SearchResolvedTodoItems(ctx, db.SearchResolvedTodoItemsParams{
+		Query:      &escaped,
+		Since:      &since,
+		MaxResults: maxResults,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("searching todo items: %w", err)
+		return nil, fmt.Errorf("searching resolved todo items: %w", err)
 	}
-	items := make([]SearchDetail, len(rows))
+	result := make([]ResolvedDetail, len(rows))
 	for i := range rows {
-		r := &rows[i]
-		items[i] = SearchDetail{
-			ID:            r.ID,
-			Title:         r.Title,
-			State:         State(r.State),
-			Due:           r.Due,
-			ProjectTitle:  r.ProjectTitle,
-			ProjectSlug:   r.ProjectSlug,
-			Energy:        r.Energy,
-			Priority:      r.Priority,
-			RecurInterval: r.RecurInterval,
-			RecurUnit:     r.RecurUnit,
-			CompletedAt:   r.CompletedAt,
-			Description:   r.Description,
-			CreatedAt:     r.CreatedAt,
-			UpdatedAt:     r.UpdatedAt,
+		resolvedAt := rows[i].ResolvedAt
+		result[i] = ResolvedDetail{
+			ID:           rows[i].ID,
+			Title:        rows[i].Title,
+			State:        State(rows[i].State),
+			CompletedAt:  &resolvedAt,
+			ProjectTitle: rows[i].ProjectTitle,
 		}
 	}
-	return items, nil
+	return result, nil
 }
 
-// CompletedItemsDetailSince returns todo items completed since the given time.
-func (s *Store) CompletedItemsDetailSince(ctx context.Context, since time.Time) ([]CompletedDetail, error) {
-	rows, err := s.q.CompletedTodoDetailSince(ctx, &since)
+// ResolvedItemsDetailSince returns todos resolved ("已了結") since the given
+// time — done, dropped (archived/dismissed), or a recurring routine's recent
+// occurrence — for the Complete tab. See ResolvedTodoDetailSince in query.sql.
+func (s *Store) ResolvedItemsDetailSince(ctx context.Context, since time.Time) ([]ResolvedDetail, error) {
+	rows, err := s.q.ResolvedTodoDetailSince(ctx, &since)
 	if err != nil {
-		return nil, fmt.Errorf("listing completed todo items since %s: %w", since.Format(time.DateOnly), err)
+		return nil, fmt.Errorf("listing resolved todo items since %s: %w", since.Format(time.DateOnly), err)
 	}
-	result := make([]CompletedDetail, len(rows))
-	for i, r := range rows {
-		result[i] = CompletedDetail{
-			ID:           r.ID,
-			Title:        r.Title,
-			CompletedAt:  r.CompletedAt,
-			ProjectTitle: r.ProjectTitle,
+	result := make([]ResolvedDetail, len(rows))
+	for i := range rows {
+		resolvedAt := rows[i].ResolvedAt
+		result[i] = ResolvedDetail{
+			ID:           rows[i].ID,
+			Title:        rows[i].Title,
+			State:        State(rows[i].State),
+			CompletedAt:  &resolvedAt,
+			ProjectTitle: rows[i].ProjectTitle,
 		}
 	}
 	return result, nil
diff --git a/internal/todo/integration_test.go b/internal/todo/integration_test.go
index 61b442424..0a709a417 100644
--- a/internal/todo/integration_test.go
+++ b/internal/todo/integration_test.go
@@ -188,6 +188,16 @@ func TestIntegration_Todo_Recurring(t *testing.T) {
 	doneTodayWeekday := seed("Already done today", iptr(allWeekdays), nil, nil, sptr(today))
 	dueInterval := seed("Every 3 days, never done", nil, iptr(3), sptr("days"), nil)
 
+	// A recurring row that was terminally closed (state=done) is no longer a
+	// live schedule — it must appear in neither bucket, including `all`.
+	var doneRecurring uuid.UUID
+	if err := testPool.QueryRow(t.Context(),
+		`INSERT INTO todos (title, state, recur_weekdays, completed_at, created_by)
+		 VALUES ('Retired routine', 'done', 127, now(), 'human') RETURNING id`,
+	).Scan(&doneRecurring); err != nil {
+		t.Fatalf("seeding done recurring todo: %v", err)
+	}
+
 	req := httptest.NewRequest(http.MethodGet, "/api/admin/commitment/todos/recurring", nil)
 	rec := serveRead(t, h.Recurring, req)
 
@@ -204,6 +214,9 @@ func TestIntegration_Todo_Recurring(t *testing.T) {
 			DueToday []struct {
 				ID uuid.UUID `json:"id"`
 			} `json:"due_today"`
+			All []struct {
+				ID uuid.UUID `json:"id"`
+			} `json:"all"`
 		} `json:"data"`
 	}
 	if err := json.Unmarshal(body, &env); err != nil {
@@ -233,6 +246,32 @@ func TestIntegration_Todo_Recurring(t *testing.T) {
 			t.Errorf("%s (%s) must NOT be in due_today (body=%s)", name, id, body)
 		}
 	}
+
+	// The `all` bucket (routines overview) carries every active recurring
+	// schedule, including the off-day and already-done-today ones that the
+	// due_today bucket excludes — that is the whole point of the manage-all view.
+	all := make(map[uuid.UUID]struct{}, len(env.Data.All))
+	for _, a := range env.Data.All {
+		all[a.ID] = struct{}{}
+	}
+	for name, id := range map[string]uuid.UUID{
+		"all-weekday todo":        dueWeekday,
+		"today-only weekday":      dueTodayOnly,
+		"interval, never done":    dueInterval,
+		"weekday excluding today": notTodayWeekday,
+		"already completed today": doneTodayWeekday,
+	} {
+		if _, ok := all[id]; !ok {
+			t.Errorf("%s (%s) missing from all (body=%s)", name, id, body)
+		}
+	}
+	// A terminally done recurring row is not a live schedule — excluded from both.
+	if _, ok := all[doneRecurring]; ok {
+		t.Errorf("done recurring %s must NOT be in all (body=%s)", doneRecurring, body)
+	}
+	if _, ok := due[doneRecurring]; ok {
+		t.Errorf("done recurring %s must NOT be in due_today (body=%s)", doneRecurring, body)
+	}
 }
 
 // TestIntegration_Todo_Recurring_Interval exercises the interval-mode
@@ -315,19 +354,35 @@ func TestIntegration_Todo_Recurring_Interval(t *testing.T) {
 	}
 }
 
-// TestIntegration_Todo_History seeds a completed todo and asserts it appears
-// in the default (completed-since) history view.
+// TestIntegration_Todo_History seeds the three resolution kinds the Complete
+// ("已了結") view collects — a one-time done todo, a dropped (dismissed) todo,
+// and a still-active recurring routine with a recent occurrence — and asserts
+// all three appear, while an untouched pending todo does not.
 func TestIntegration_Todo_History(t *testing.T) {
 	truncate(t)
 	h := newHandler()
 
-	var done uuid.UUID
+	var done, dropped, recurring uuid.UUID
 	if err := testPool.QueryRow(t.Context(),
 		`INSERT INTO todos (title, state, completed_at, created_by)
 		 VALUES ('Shipped the feature', 'done', now(), 'human') RETURNING id`,
 	).Scan(&done); err != nil {
 		t.Fatalf("seeding completed todo: %v", err)
 	}
+	if err := testPool.QueryRow(t.Context(),
+		`INSERT INTO todos (title, state, created_by)
+		 VALUES ('Won''t do this', 'dismissed', 'human') RETURNING id`,
+	).Scan(&dropped); err != nil {
+		t.Fatalf("seeding dismissed todo: %v", err)
+	}
+	if err := testPool.QueryRow(t.Context(),
+		`INSERT INTO todos (title, state, recur_weekdays, last_completed_on, created_by)
+		 VALUES ('Morning Japanese', 'todo', 127, current_date, 'human') RETURNING id`,
+	).Scan(&recurring); err != nil {
+		t.Fatalf("seeding recurring todo: %v", err)
+	}
+	// A pending todo with no resolution must NOT surface in the Complete view.
+	pending := seedTodo(t, "Still to do", "todo", "human")
 
 	req := httptest.NewRequest(http.MethodGet, "/api/admin/commitment/todos/history", nil)
 	rec := serveRead(t, h.History, req)
@@ -341,8 +396,40 @@ func TestIntegration_Todo_History(t *testing.T) {
 	}
 
 	ids := dataIDs(t, body)
-	if _, ok := ids[done]; !ok {
-		t.Errorf("completed todo %s missing from history (body=%s)", done, body)
+	for name, id := range map[string]uuid.UUID{"done": done, "dropped": dropped, "recurring": recurring} {
+		if _, ok := ids[id]; !ok {
+			t.Errorf("%s todo %s missing from Complete view (body=%s)", name, id, body)
+		}
+	}
+	if _, ok := ids[pending]; ok {
+		t.Errorf("pending todo %s must NOT appear in Complete view (body=%s)", pending, body)
+	}
+
+	// The ?q= search path searches the SAME resolved set: "Japanese" must find
+	// the recurring occurrence (the exact gap the old completed_at-only search
+	// missed), and a token shared by a resolved and a non-resolved row ("do":
+	// dropped "Won't do this" vs pending "Still to do") must return only the
+	// resolved one.
+	searchIDs := func(query string) map[uuid.UUID]struct{} {
+		sreq := httptest.NewRequest(http.MethodGet, "/api/admin/commitment/todos/history?q="+query, nil)
+		srec := serveRead(t, h.History, sreq)
+		sresp := srec.Result()
+		defer sresp.Body.Close()
+		sbody, _ := io.ReadAll(sresp.Body)
+		if sresp.StatusCode != http.StatusOK {
+			t.Fatalf("search status = %d, want 200 (body=%s)", sresp.StatusCode, sbody)
+		}
+		return dataIDs(t, sbody)
+	}
+	if _, ok := searchIDs("Japanese")[recurring]; !ok {
+		t.Errorf("recurring %s not searchable in Complete tab via ?q=Japanese", recurring)
+	}
+	doMatches := searchIDs("do")
+	if _, ok := doMatches[dropped]; !ok {
+		t.Errorf("dropped %s not searchable via ?q=do", dropped)
+	}
+	if _, ok := doMatches[pending]; ok {
+		t.Errorf("pending %s must NOT be searchable in the Complete tab via ?q=do", pending)
 	}
 }
 
diff --git a/internal/todo/query.sql b/internal/todo/query.sql
index 34dbd33ff..40747af27 100644
--- a/internal/todo/query.sql
+++ b/internal/todo/query.sql
@@ -139,14 +139,64 @@ RETURNING id, title, state, due, project_id,
           completed_at, energy, priority, recur_interval, recur_unit, recur_weekdays, last_completed_on,
           description, created_by, created_at, updated_at;
 
--- name: CompletedTodoDetailSince :many
--- Get todo items completed since a given time with project context.
-SELECT t.id, t.title, t.completed_at, t.project_id,
+-- name: ResolvedTodoDetailSince :many
+-- Resolved ("已了結") todos since a given time, for the Todos page Complete tab:
+-- one-time todos done (state=done, by completed_at), todos dropped/filed
+-- (archived/dismissed, by updated_at), and recurring routines with a recent
+-- occurrence (last_completed_on, while still active so the schedule keeps
+-- running). resolved_at is the per-kind resolution instant; state lets the
+-- front end badge the kind (done / archived / dismissed / recurring-active).
+SELECT t.id, t.title, t.state,
+       CASE
+           WHEN t.state = 'done' THEN t.completed_at
+           WHEN t.state IN ('archived', 'dismissed') THEN t.updated_at
+           ELSE t.last_completed_on::timestamptz
+       END AS resolved_at,
        COALESCE(p.title, '') AS project_title
 FROM todos t
 LEFT JOIN projects p ON t.project_id = p.id
-WHERE t.state = 'done' AND t.completed_at >= @since
-ORDER BY t.completed_at DESC;
+WHERE (t.state = 'done' AND t.completed_at >= @since)
+   OR (t.state IN ('archived', 'dismissed') AND t.updated_at >= @since)
+   OR ((t.recur_weekdays IS NOT NULL OR t.recur_interval IS NOT NULL)
+       AND t.state NOT IN ('done', 'archived', 'dismissed')
+       AND t.last_completed_on IS NOT NULL
+       AND t.last_completed_on >= @since::date)
+ORDER BY resolved_at DESC NULLS LAST;
+
+-- name: AllRecurringTodoItems :many
+-- Every active recurring todo's schedule, for the routines overview (manage all
+-- routines, not just today's due ones — distinct from RecurringTodoItemsDueToday).
+-- Uses the SAME active-state filter as RecurringTodoItemsDueToday so the overview
+-- is a superset of the due-today list and never shows a closed routine: a
+-- terminally done, someday-parked, still-in-inbox, or archived/dismissed
+-- recurring row is not a live schedule and is reachable on its own surface
+-- (Complete / Someday / Inbox tabs). Selects the full todos column set so sqlc
+-- returns db.Todo and rowToItem applies.
+SELECT id, title, state, due, project_id,
+       completed_at, energy, priority, recur_interval, recur_unit, recur_weekdays, last_completed_on,
+       description, created_by, created_at, updated_at
+FROM todos
+WHERE state NOT IN ('done', 'someday', 'inbox', 'archived', 'dismissed')
+  AND (recur_weekdays IS NOT NULL OR recur_interval IS NOT NULL)
+ORDER BY priority NULLS LAST, title;
+
+-- name: CompletedTodoItemsOn :many
+-- Todos completed on @today, for the Today dashboard's done-today count and
+-- list. Two arms: a one-time todo finished within the day window [@day_start,
+-- @day_end) (state=done, completed_at in range), OR a recurring todo whose
+-- occurrence was stamped on @today (last_completed_on = @today). A recurring
+-- todo terminally closed the same day it had an occurrence stamped satisfies
+-- both arms, but a WHERE-OR over a base table emits each row once, so the done
+-- count is never inflated. Selects the full todos column set (no join) so sqlc
+-- returns db.Todo and rowToItem applies.
+SELECT id, title, state, due, project_id,
+       completed_at, energy, priority, recur_interval, recur_unit, recur_weekdays, last_completed_on,
+       description, created_by, created_at, updated_at
+FROM todos
+WHERE (state = 'done' AND completed_at >= @day_start AND completed_at < @day_end)
+   OR ((recur_weekdays IS NOT NULL OR recur_interval IS NOT NULL)
+       AND last_completed_on = @today::date)
+ORDER BY completed_at DESC NULLS LAST, last_completed_on DESC NULLS LAST, title;
 
 -- name: UpdateTodoItem :one
 -- Update editable todo item fields. State transitions go through
@@ -164,34 +214,34 @@ RETURNING id, title, state, due, project_id,
           completed_at, energy, priority, recur_interval, recur_unit, recur_weekdays, last_completed_on,
           description, created_by, created_at, updated_at;
 
--- name: SearchTodoItems :many
--- Search todo items by title/description with optional filters.
-SELECT t.id, t.title, t.state, t.due, t.project_id,
-       t.energy, t.priority, t.recur_interval, t.recur_unit, t.recur_weekdays, t.last_completed_on,
-       t.completed_at, t.description, t.created_at, t.updated_at,
-       COALESCE(p.title, '') AS project_title,
-       COALESCE(p.slug, '') AS project_slug
+-- name: SearchResolvedTodoItems :many
+-- The ?q= search counterpart of ResolvedTodoDetailSince: resolved ("已了結")
+-- todos since @since whose title or description matches @query. It applies the
+-- SAME resolution arms as ResolvedTodoDetailSince (done by completed_at, dropped
+-- by updated_at, recurring by last_completed_on) so the Complete tab's search
+-- covers done, dropped, AND recurring resolutions — not only done. @query is
+-- pre-escaped by the caller (escapeILIKE); the wrapping wildcards are the only
+-- ILIKE metacharacters. resolved_at is the per-kind resolution instant.
+SELECT t.id, t.title, t.state,
+       CASE
+           WHEN t.state = 'done' THEN t.completed_at
+           WHEN t.state IN ('archived', 'dismissed') THEN t.updated_at
+           ELSE t.last_completed_on::timestamptz
+       END AS resolved_at,
+       COALESCE(p.title, '') AS project_title
 FROM todos t
 LEFT JOIN projects p ON t.project_id = p.id
-WHERE (sqlc.narg('query')::text IS NULL OR (t.title ILIKE '%' || sqlc.narg('query') || '%' OR t.description ILIKE '%' || sqlc.narg('query') || '%'))
-  AND (sqlc.narg('project_slug')::text IS NULL OR p.slug = sqlc.narg('project_slug'))
-  AND (sqlc.narg('state_filter')::text IS NULL OR
-       CASE sqlc.narg('state_filter')
-           WHEN 'pending' THEN t.state != 'done'
-           WHEN 'done' THEN t.state = 'done'
-           ELSE true
-       END)
-  AND (sqlc.narg('completed_after')::timestamptz IS NULL OR t.completed_at >= sqlc.narg('completed_after'))
-  AND (sqlc.narg('completed_before')::timestamptz IS NULL OR t.completed_at < sqlc.narg('completed_before'))
-ORDER BY
-    CASE WHEN t.state != 'done' THEN 0 ELSE 1 END,
-    CASE WHEN t.state != 'done' THEN
-        CASE WHEN t.due IS NOT NULL THEN 0 ELSE 1 END
-    ELSE 2 END,
-    t.due ASC NULLS LAST,
-    t.completed_at DESC NULLS LAST,
-    t.updated_at ASC
-LIMIT sqlc.arg('max_results');
+WHERE (t.title ILIKE '%' || @query || '%' OR t.description ILIKE '%' || @query || '%')
+  AND (
+        (t.state = 'done' AND t.completed_at >= @since)
+     OR (t.state IN ('archived', 'dismissed') AND t.updated_at >= @since)
+     OR ((t.recur_weekdays IS NOT NULL OR t.recur_interval IS NOT NULL)
+         AND t.state NOT IN ('done', 'archived', 'dismissed')
+         AND t.last_completed_on IS NOT NULL
+         AND t.last_completed_on >= @since::date)
+      )
+ORDER BY resolved_at DESC NULLS LAST
+LIMIT @max_results;
 
 -- === Recurring todo item queries ===
 
diff --git a/internal/todo/recurring.go b/internal/todo/recurring.go
index b9a7bffd0..e5aa6635f 100644
--- a/internal/todo/recurring.go
+++ b/internal/todo/recurring.go
@@ -34,6 +34,21 @@ func (s *Store) RecurringItemsDueToday(ctx context.Context, today time.Time) ([]
 	return items, nil
 }
 
+// AllRecurringItems returns every active recurring todo's schedule, for the
+// routines overview — the manage-all view, distinct from the due-today list.
+// See AllRecurringTodoItems in query.sql.
+func (s *Store) AllRecurringItems(ctx context.Context) ([]Item, error) {
+	rows, err := s.q.AllRecurringTodoItems(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("listing all recurring todo items: %w", err)
+	}
+	items := make([]Item, len(rows))
+	for i := range rows {
+		items[i] = rowToItem(&rows[i])
+	}
+	return items, nil
+}
+
 // Recurrence is the schedule passed to SetRecurrence: weekday-mode (Weekdays
 // non-nil) or interval-mode (Interval and Unit non-nil), or all-nil to clear.
 // The caller validates the combination; chk_todo_recurrence is the backstop.
diff --git a/internal/todo/todo.go b/internal/todo/todo.go
index 08b88c44e..7f5065139 100644
--- a/internal/todo/todo.go
+++ b/internal/todo/todo.go
@@ -106,6 +106,26 @@ func (s *Store) Items(ctx context.Context) ([]Item, error) {
 	return items, nil
 }
 
+// CompletedItemsOn returns the todos completed on the given day, for the Today
+// dashboard's done-today count and list: one-time todos finished within
+// [dayStart, dayEnd) plus recurring todos whose occurrence was stamped on today.
+// See CompletedTodoItemsOn in query.sql.
+func (s *Store) CompletedItemsOn(ctx context.Context, today, dayStart, dayEnd time.Time) ([]Item, error) {
+	rows, err := s.q.CompletedTodoItemsOn(ctx, db.CompletedTodoItemsOnParams{
+		DayStart: &dayStart,
+		DayEnd:   &dayEnd,
+		Today:    today,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("listing todos completed on %s: %w", today.Format(time.DateOnly), err)
+	}
+	items := make([]Item, len(rows))
+	for i := range rows {
+		items[i] = rowToItem(&rows[i])
+	}
+	return items, nil
+}
+
 // ItemByID returns a single todo item by its ID.
 func (s *Store) ItemByID(ctx context.Context, id uuid.UUID) (*Item, error) {
 	r, err := s.q.TodoItemByID(ctx, id)
@@ -403,28 +423,15 @@ type PendingDetail struct {
 	UpdatedAt     time.Time `json:"updated_at"`
 }
 
-// SearchDetail is a search hit with project context.
-type SearchDetail struct {
-	ID            uuid.UUID  `json:"id"`
-	Title         string     `json:"title"`
-	State         State      `json:"state"`
-	Due           *time.Time `json:"due,omitempty"`
-	ProjectTitle  string     `json:"project_title"`
-	ProjectSlug   string     `json:"project_slug"`
-	Energy        *string    `json:"energy,omitempty"`
-	Priority      *string    `json:"priority,omitempty"`
-	RecurInterval *int32     `json:"recur_interval,omitempty"`
-	RecurUnit     *string    `json:"recur_unit,omitempty"`
-	CompletedAt   *time.Time `json:"completed_at,omitempty"`
-	Description   string     `json:"description,omitempty"`
-	CreatedAt     time.Time  `json:"created_at"`
-	UpdatedAt     time.Time  `json:"updated_at"`
-}
-
-// CompletedDetail is a recently completed todo with project context.
-type CompletedDetail struct {
+// ResolvedDetail is a resolved ("已了結") todo with project context for the
+// Complete tab: a one-time todo done, a todo dropped (archived/dismissed), or a
+// recurring routine's recent occurrence. State carries the kind so the front
+// end can badge it; CompletedAt holds the per-kind resolution instant (done →
+// completed_at, dropped → updated_at, recurring → last_completed_on).
+type ResolvedDetail struct {
 	ID           uuid.UUID  `json:"id"`
 	Title        string     `json:"title"`
+	State        State      `json:"state"`
 	CompletedAt  *time.Time `json:"completed_at,omitempty"`
 	ProjectTitle string     `json:"project_title"`
 }