@winspan/claude-forge 8.50.6 → 8.51.0

package/tests/unit/storage/tasks-getById.test.ts

@@ -0,0 +1,343 @@
+/**
+ * H1 storage: tasks detail PK 直查 / JOIN 接口
+ *
+ * 覆盖：
+ *   - getTask 命中 / null
+ *   - getTask 通过 LEFT JOIN sessions 取 project_path
+ *   - queryEventsByTaskId JOIN 正确性 + timestamp ASC 排序 + limit
+ *   - queryInjectionsByTaskId event_id 关联
+ *   - querySkillInvocationsByTaskWindow 时间窗包含/排除
+ *   - querySkillInvocationsByTaskWindow end_time IS NULL 时取 now_ms
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import type { ForgeEvent } from '../../../src/core/types.js';
+
+const SESSION = 'sess-t';
+const PROJECT = '/tmp/proj-t';
+
+/** Map a friendly short id to a deterministic-per-test UUID. */
+const idMap = new Map<string, string>();
+function uid(short: string): string {
+  let v = idMap.get(short);
+  if (!v) {
+    v = randomUUID();
+    idMap.set(short, v);
+  }
+  return v;
+}
+function resetIdMap() { idMap.clear(); }
+
+function makeEvent(overrides: Partial<ForgeEvent> & { event_id: string; timestamp: string }): ForgeEvent {
+  return {
+    event_id: overrides.event_id,
+    session_id: overrides.session_id ?? SESSION,
+    project_path: overrides.project_path ?? PROJECT,
+    timestamp: overrides.timestamp,
+    hook_type: overrides.hook_type ?? 'UserPromptSubmit',
+    user_prompt: overrides.user_prompt ?? 'hi',
+    ...overrides,
+  } as ForgeEvent;
+}
+
+function makeInv(overrides: {
+  id: string;
+  skill_id: string;
+  timestamp: number;
+  session_id?: string;
+}) {
+  return {
+    id: overrides.id,
+    route_request_id: null,
+    session_id: overrides.session_id ?? SESSION,
+    agent_id: null,
+    skill_id: overrides.skill_id,
+    invocation_type: 'dynamic' as const,
+    reason: null,
+    workflow: null,
+    phase: null,
+    feature_slug: null,
+    artifact_path: null,
+    depth: 0,
+    success: 1 as 0 | 1,
+    error: null,
+    timestamp: overrides.timestamp,
+  };
+}
+
+/** 让 sessions 表有这条 session_id（写一条事件就会 upsertSession） */
+function seedSession(storage: SQLiteStorage, sessionId: string, projectPath: string) {
+  storage.writeEvent(makeEvent({
+    event_id: randomUUID(),
+    session_id: sessionId,
+    project_path: projectPath,
+    timestamp: '2026-01-01T00:00:00.000Z',
+    hook_type: 'UserPromptSubmit',
+    user_prompt: 'seed',
+  }));
+}
+
+describe('storage.getTask', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-tasks-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+    resetIdMap();
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('未知 taskId 返回 null', () => {
+    expect(storage.getTask('no-such-task')).toBeNull();
+  });
+
+  it('命中：返回 TaskRecord，含 LEFT JOIN 来的 project_path', () => {
+    seedSession(storage, SESSION, PROJECT);
+    storage.writeTask({
+      id: 't1',
+      session_id: SESSION,
+      title: 'Build something',
+      start_time: '2026-01-01T10:00:00.000Z',
+    });
+
+    const t = storage.getTask('t1');
+    expect(t).not.toBeNull();
+    expect(t!.id).toBe('t1');
+    expect(t!.session_id).toBe(SESSION);
+    expect(t!.title).toBe('Build something');
+    expect(t!.start_time).toBe('2026-01-01T10:00:00.000Z');
+    expect(t!.status).toBe('active');
+    expect(t!.event_count).toBe(0);
+    expect(t!.project_path).toBe(PROJECT);
+  });
+
+  it('session 不存在时 project_path 为 undefined（LEFT JOIN）', () => {
+    storage.writeTask({
+      id: 't-orphan',
+      session_id: 'missing-session',
+      title: 'Orphan',
+      start_time: '2026-01-01T10:00:00.000Z',
+    });
+    const t = storage.getTask('t-orphan');
+    expect(t).not.toBeNull();
+    expect(t!.project_path).toBeUndefined();
+  });
+});
+
+describe('storage.queryEventsByTaskId', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-tasks-evt-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+    resetIdMap();
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('未知 taskId 返回 []', () => {
+    expect(storage.queryEventsByTaskId('nope')).toEqual([]);
+  });
+
+  it('JOIN 仅返回 link 过的事件，且按 timestamp ASC 排序', () => {
+    seedSession(storage, SESSION, PROJECT);
+    storage.writeTask({
+      id: 't1', session_id: SESSION, title: 'T', start_time: '2026-01-01T10:00:00.000Z',
+    });
+
+    // 写 3 条事件，乱序 timestamp
+    storage.writeEvent(makeEvent({ event_id: uid('e3'), timestamp: '2026-01-01T10:30:00.000Z', hook_type: 'PostToolUse' }));
+    storage.writeEvent(makeEvent({ event_id: uid('e1'), timestamp: '2026-01-01T10:10:00.000Z', hook_type: 'PreToolUse' }));
+    storage.writeEvent(makeEvent({ event_id: uid('e2'), timestamp: '2026-01-01T10:20:00.000Z', hook_type: 'Stop' }));
+    // 一条不 link 的事件
+    storage.writeEvent(makeEvent({ event_id: uid('e-unlinked'), timestamp: '2026-01-01T10:15:00.000Z', hook_type: 'Notification' }));
+
+    storage.linkEventToTask('t1', uid('e1'));
+    storage.linkEventToTask('t1', uid('e2'));
+    storage.linkEventToTask('t1', uid('e3'));
+
+    const evts = storage.queryEventsByTaskId('t1');
+    expect(evts.map(e => e.event_id)).toEqual([uid('e1'), uid('e2'), uid('e3')]);
+    // 未 link 的不出现
+    expect(evts.find(e => e.event_id === uid('e-unlinked'))).toBeUndefined();
+    // hook_type 字段被正确还原
+    expect(evts[0].hook_type).toBe('PreToolUse');
+  });
+
+  it('limit 生效', () => {
+    seedSession(storage, SESSION, PROJECT);
+    storage.writeTask({
+      id: 't1', session_id: SESSION, title: 'T', start_time: '2026-01-01T10:00:00.000Z',
+    });
+    for (let i = 0; i < 5; i++) {
+      const short = `e${i}`;
+      const id = uid(short);
+      storage.writeEvent(makeEvent({ event_id: id, timestamp: `2026-01-01T10:0${i}:00.000Z` }));
+      storage.linkEventToTask('t1', id);
+    }
+    const evts = storage.queryEventsByTaskId('t1', { limit: 3 });
+    expect(evts).toHaveLength(3);
+    expect(evts.map(e => e.event_id)).toEqual([uid('e0'), uid('e1'), uid('e2')]);
+  });
+});
+
+describe('storage.queryInjectionsByTaskId', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-tasks-inj-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+    resetIdMap();
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('未知 taskId 返回 []', () => {
+    expect(storage.queryInjectionsByTaskId('nope')).toEqual([]);
+  });
+
+  it('仅返回 event_id 关联到 task 的 injections，按 timestamp ASC', () => {
+    seedSession(storage, SESSION, PROJECT);
+    storage.writeTask({
+      id: 't1', session_id: SESSION, title: 'T', start_time: '2026-01-01T10:00:00.000Z',
+    });
+
+    // 两条 link 到 t1 的事件
+    storage.writeEvent(makeEvent({ event_id: uid('e1'), timestamp: '2026-01-01T10:10:00.000Z' }));
+    storage.writeEvent(makeEvent({ event_id: uid('e2'), timestamp: '2026-01-01T10:20:00.000Z' }));
+    // 一条未 link 的事件
+    storage.writeEvent(makeEvent({ event_id: uid('e-other'), timestamp: '2026-01-01T10:15:00.000Z' }));
+    storage.linkEventToTask('t1', uid('e1'));
+    storage.linkEventToTask('t1', uid('e2'));
+
+    storage.writeInjection({
+      id: 'i2', event_id: uid('e2'), session_id: SESSION,
+      timestamp: '2026-01-01T10:20:01.000Z',
+      source_handler: 'h', injection_type: 'systemMessage', content: 'b',
+    });
+    storage.writeInjection({
+      id: 'i1', event_id: uid('e1'), session_id: SESSION,
+      timestamp: '2026-01-01T10:10:01.000Z',
+      source_handler: 'h', injection_type: 'additionalContext', content: 'a',
+    });
+    // 未关联到 t1 的 injection
+    storage.writeInjection({
+      id: 'i-other', event_id: uid('e-other'), session_id: SESSION,
+      timestamp: '2026-01-01T10:15:01.000Z',
+      source_handler: 'h', injection_type: 'reason', content: 'x',
+    });
+
+    const injs = storage.queryInjectionsByTaskId('t1');
+    expect(injs.map(i => i.id)).toEqual(['i1', 'i2']);
+    expect(injs[0].event_id).toBe(uid('e1'));
+    expect(injs[1].injection_type).toBe('systemMessage');
+  });
+});
+
+describe('storage.querySkillInvocationsByTaskWindow', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-tasks-skill-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+    resetIdMap();
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('未知 taskId 返回 []', () => {
+    expect(storage.querySkillInvocationsByTaskWindow('nope')).toEqual([]);
+  });
+
+  it('时间窗：仅包含 [start_time, end_time] 内 且 session 匹配 的 invocations，按 timestamp ASC', () => {
+    seedSession(storage, SESSION, PROJECT);
+    // task: 2026-01-01T10:00:00Z .. 2026-01-01T11:00:00Z
+    const startMs = Date.UTC(2026, 0, 1, 10, 0, 0);
+    const endMs = Date.UTC(2026, 0, 1, 11, 0, 0);
+    storage.writeTask({
+      id: 't1', session_id: SESSION, title: 'T',
+      start_time: '2026-01-01T10:00:00.000Z',
+    });
+    storage.updateTask('t1', { end_time: '2026-01-01T11:00:00.000Z' });
+
+    // 之前（排除）
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-before', skill_id: 'tdd', timestamp: startMs - 1000,
+    }));
+    // 边界 start（包含）
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-start', skill_id: 'tdd', timestamp: startMs,
+    }));
+    // 中间（包含）
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-mid', skill_id: 'debug', timestamp: startMs + 30 * 60 * 1000,
+    }));
+    // 边界 end（包含；implementation 给 end 加了 +999ms 容差）
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-end', skill_id: 'tdd', timestamp: endMs,
+    }));
+    // 之后（排除）
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-after', skill_id: 'tdd', timestamp: endMs + 5000,
+    }));
+    // 不同 session（排除）
+    seedSession(storage, 'other-sess', PROJECT);
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-other-session', skill_id: 'tdd', timestamp: startMs + 60000, session_id: 'other-sess',
+    }));
+
+    const invs = storage.querySkillInvocationsByTaskWindow('t1');
+    expect(invs.map(i => i.id)).toEqual(['inv-start', 'inv-mid', 'inv-end']);
+  });
+
+  it('end_time IS NULL → 取 now_ms 参数作为上界', () => {
+    seedSession(storage, SESSION, PROJECT);
+    const startMs = Date.UTC(2026, 0, 1, 10, 0, 0);
+    storage.writeTask({
+      id: 't-open', session_id: SESSION, title: 'Active',
+      start_time: '2026-01-01T10:00:00.000Z',
+    });
+    // 不 updateTask end_time → 保持 NULL
+
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-in-window', skill_id: 'tdd', timestamp: startMs + 60000,
+    }));
+    storage.writeSkillInvocation(makeInv({
+      id: 'inv-past-now', skill_id: 'tdd', timestamp: startMs + 999_000,
+    }));
+
+    // now_ms = startMs + 120_000 → inv-past-now 落在窗外
+    const invs = storage.querySkillInvocationsByTaskWindow('t-open', {
+      now_ms: startMs + 120_000,
+    });
+    expect(invs.map(i => i.id)).toEqual(['inv-in-window']);
+
+    // now_ms = startMs + 999_999 → 两条都在
+    const invs2 = storage.querySkillInvocationsByTaskWindow('t-open', {
+      now_ms: startMs + 999_999,
+    });
+    expect(invs2.map(i => i.id)).toEqual(['inv-in-window', 'inv-past-now']);
+  });
+});

package/tests/unit/storage/tasks-stale-gc.test.ts

@@ -0,0 +1,86 @@
+/**
+ * 单测：completeStaleActiveTasks
+ *
+ * 覆盖：
+ *   - 空表返回 0
+ *   - 1 idle 超阈值 + 1 未超：只关超的那条
+ *   - status='completed' 的 task 不被改动
+ *   - end_time IS NULL 的 task 不被纳入 GC
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+
+const SESSION = 'sess-gc-test';
+
+function openStorage(tmp: string): SQLiteStorage {
+  return new SQLiteStorage(join(tmp, 'data.db'));
+}
+
+describe('completeStaleActiveTasks', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-stale-gc-'));
+    storage = openStorage(tmp);
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('空表返回 0', () => {
+    expect(storage.completeStaleActiveTasks(10)).toBe(0);
+  });
+
+  it('1 idle 超阈值 + 1 未超：只关超的那条', () => {
+    // 写 2 条 active task
+    storage.writeTask({ id: 'old-task', session_id: SESSION, title: 'old', start_time: '2026-01-01T00:00:00.000Z' });
+    storage.writeTask({ id: 'new-task', session_id: SESSION, title: 'new', start_time: '2026-01-01T01:00:00.000Z' });
+
+    // 用 DB 直接操作设置 end_time，让 old-task idle 15 分钟前，new-task 仅 3 分钟前
+    const db = storage.getDatabase();
+    db.prepare(`UPDATE tasks SET end_time = datetime('now', '-15 minutes') WHERE id = ?`).run('old-task');
+    db.prepare(`UPDATE tasks SET end_time = datetime('now', '-3 minutes') WHERE id = ?`).run('new-task');
+
+    const changed = storage.completeStaleActiveTasks(10);
+    expect(changed).toBe(1);
+
+    const oldTask = storage.getTask('old-task');
+    expect(oldTask?.status).toBe('completed');
+
+    const newTask = storage.getTask('new-task');
+    expect(newTask?.status).toBe('active');
+  });
+
+  it('status=completed 的 task 不被改动', () => {
+    storage.writeTask({ id: 'done-task', session_id: SESSION, title: 'done', start_time: '2026-01-01T00:00:00.000Z' });
+    storage.updateTask('done-task', { status: 'completed' });
+
+    // 设置很久以前的 end_time
+    const db = storage.getDatabase();
+    db.prepare(`UPDATE tasks SET end_time = datetime('now', '-60 minutes') WHERE id = ?`).run('done-task');
+
+    const changed = storage.completeStaleActiveTasks(10);
+    expect(changed).toBe(0);
+
+    const task = storage.getTask('done-task');
+    expect(task?.status).toBe('completed');
+  });
+
+  it('end_time IS NULL 的 task 不被纳入 GC', () => {
+    // 写 active task，end_time 保持 NULL（从未 linkEventToTask）
+    storage.writeTask({ id: 'null-end', session_id: SESSION, title: 'null-end', start_time: '2026-01-01T00:00:00.000Z' });
+
+    const changed = storage.completeStaleActiveTasks(10);
+    expect(changed).toBe(0);
+
+    const task = storage.getTask('null-end');
+    expect(task?.status).toBe('active');
+  });
+});

package/tests/unit/token-usage.test.ts

@@ -29,7 +29,7 @@ describe('Token Usage Tracking', () => {
   });
 
   it('should record token usage', () => {
-    storage.recordTokenUsage({
+    storage.writeTokenUsage({
       session_id: 'test-session-1',
       input_tokens: 100,
       output_tokens: 200,
@@ -46,13 +46,13 @@ describe('Token Usage Tracking', () => {
   it('should accumulate token usage across multiple calls', () => {
     const sessionId = 'test-session-2';
 
-    storage.recordTokenUsage({
+    storage.writeTokenUsage({
       session_id: sessionId,
       input_tokens: 100,
       output_tokens: 200,
     });
 
-    storage.recordTokenUsage({
+    storage.writeTokenUsage({
       session_id: sessionId,
       input_tokens: 50,
       output_tokens: 100,
@@ -67,7 +67,7 @@ describe('Token Usage Tracking', () => {
   it('should list token usage records', () => {
     const sessionId = 'test-session-4';
 
-    storage.recordTokenUsage({
+    storage.writeTokenUsage({
       session_id: sessionId,
       input_tokens: 100,
       output_tokens: 200,
@@ -75,7 +75,7 @@ describe('Token Usage Tracking', () => {
       tool_name: 'Task',
     });
 
-    storage.recordTokenUsage({
+    storage.writeTokenUsage({
       session_id: sessionId,
       input_tokens: 50,
       output_tokens: 100,
@@ -125,7 +125,7 @@ describe('Token Usage Tracking', () => {
   it('should handle missing methodology_execution_id', () => {
     const sessionId = 'test-session-7';
 
-    storage.recordTokenUsage({
+    storage.writeTokenUsage({
       session_id: sessionId,
       input_tokens: 100,
       output_tokens: 200,

package/tests/unit/web/navigation-back-contract.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Safety-net: TaskDetail back-navigation filter preservation contract
+ *
+ * harness/safety-net:tasks-detail-back-loses-filters
+ *
+ * Root cause: TaskDetail.tsx used <Link to="/tasks"> (hard absolute path),
+ * discarding any query string the user had on the Tasks page (project filter,
+ * page number, search, etc.).
+ *
+ * Fix strategy: Tasks.tsx passes { state: { from: location.pathname + location.search } }
+ * when navigating to a detail view.  TaskDetail reads that state via a pure
+ * helper resolveBackTo(state) and uses the result as the Link target.
+ *
+ * This file tests resolveBackTo in isolation — no DOM, no React, no router.
+ * All tests must be GREEN before the utility is created (they lock behavior)
+ * and remain green after (they verify the implementation).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { resolveBackTo } from '../../../web/src/utils/navigation';
+
+// ── (inline reference implementation removed — now importing from real module) ─
+
+// ── Safety-net: stable baseline behaviour (must pass BEFORE the fix) ─────────
+
+describe('resolveBackTo – safety-net (harness/safety-net:tasks-detail-back-loses-filters)', () => {
+  describe('fallback path — no navigation state', () => {
+    it('returns /tasks when state is null', () => {
+      expect(resolveBackTo(null)).toBe('/tasks');
+    });
+
+    it('returns /tasks when state is undefined', () => {
+      expect(resolveBackTo(undefined)).toBe('/tasks');
+    });
+
+    it('returns /tasks when state is an empty object (no from key)', () => {
+      expect(resolveBackTo({})).toBe('/tasks');
+    });
+
+    it('returns /tasks when state.from is undefined', () => {
+      expect(resolveBackTo({ from: undefined })).toBe('/tasks');
+    });
+
+    it('returns /tasks when state.from is an empty string', () => {
+      expect(resolveBackTo({ from: '' })).toBe('/tasks');
+    });
+
+    it('returns the supplied fallback when state is null', () => {
+      expect(resolveBackTo(null, '/custom')).toBe('/custom');
+    });
+
+    it('returns the supplied fallback when state has no from', () => {
+      expect(resolveBackTo({}, '/other')).toBe('/other');
+    });
+  });
+
+  describe('happy path — navigation state carries from URL', () => {
+    it('returns state.from when it is a non-empty string', () => {
+      const state = { from: '/tasks?project=foo&page=2' };
+      expect(resolveBackTo(state)).toBe('/tasks?project=foo&page=2');
+    });
+
+    it('preserves query string with multiple project params', () => {
+      const qs = '/tasks?project=alpha&project=beta&preset=24h';
+      expect(resolveBackTo({ from: qs })).toBe(qs);
+    });
+
+    it('preserves page number in query string', () => {
+      expect(resolveBackTo({ from: '/tasks?page=5' })).toBe('/tasks?page=5');
+    });
+
+    it('preserves search param in query string', () => {
+      expect(resolveBackTo({ from: '/tasks?search=my+task' })).toBe('/tasks?search=my+task');
+    });
+
+    it('works when from is just /tasks with no query string', () => {
+      expect(resolveBackTo({ from: '/tasks' })).toBe('/tasks');
+    });
+  });
+
+  describe('type safety — state.from must be a string', () => {
+    it('returns fallback when state.from is a number', () => {
+      expect(resolveBackTo({ from: 42 })).toBe('/tasks');
+    });
+
+    it('returns fallback when state.from is an array', () => {
+      expect(resolveBackTo({ from: ['/tasks'] })).toBe('/tasks');
+    });
+
+    it('returns fallback when state.from is an object', () => {
+      expect(resolveBackTo({ from: { path: '/tasks' } })).toBe('/tasks');
+    });
+
+    it('returns fallback when state.from is null', () => {
+      expect(resolveBackTo({ from: null })).toBe('/tasks');
+    });
+
+    it('returns fallback when state is a primitive (number)', () => {
+      expect(resolveBackTo(42 as unknown)).toBe('/tasks');
+    });
+
+    it('returns fallback when state is a string', () => {
+      expect(resolveBackTo('/tasks' as unknown)).toBe('/tasks');
+    });
+  });
+
+  describe('navigation state construction — Tasks.tsx side', () => {
+    /**
+     * These tests lock the format of the state object that Tasks.tsx must produce.
+     * They act as a contract between the navigator (Tasks) and the consumer (TaskDetail).
+     */
+
+    it('from value = pathname + search reproduces the original URL exactly', () => {
+      const pathname = '/tasks';
+      const search = '?project=foo&page=2';
+      const from = pathname + search;
+      // TaskDetail receives this exact value back
+      expect(resolveBackTo({ from })).toBe('/tasks?project=foo&page=2');
+    });
+
+    it('from value when search is empty string yields just the pathname', () => {
+      const pathname = '/tasks';
+      const search = '';
+      const from = pathname + search; // '/tasks'
+      expect(resolveBackTo({ from })).toBe('/tasks');
+    });
+
+    it('round-trips a complex filter state without mutation', () => {
+      const original = '/tasks?project=my-project&preset=7d&size=100&page=3';
+      const state = { from: original };
+      expect(resolveBackTo(state)).toBe(original);
+    });
+  });
+});