From edff9a2f8e44419c8b68902af805d8242cc278ef Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 07:10:11 +0000
Subject: [PATCH 01/12] feat(server): add lucia v2 compatible password hashing
 utilities

Ports lucia v2's scrypt-based hash/verify and random string generation
so existing password hashes stay valid without a data migration, ahead
of removing the lucia dependency itself.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 src/lib/server/password.test.ts | 109 ++++++++++++++++++++++++++++++++
 src/lib/server/password.ts      |  55 ++++++++++++++++
 src/lib/server/random.test.ts   |  28 ++++++++
 src/lib/server/random.ts        |  20 ++++++
 4 files changed, 212 insertions(+)
 create mode 100644 src/lib/server/password.test.ts
 create mode 100644 src/lib/server/password.ts
 create mode 100644 src/lib/server/random.test.ts
 create mode 100644 src/lib/server/random.ts

diff --git a/src/lib/server/password.test.ts b/src/lib/server/password.test.ts
new file mode 100644
index 000000000..8ae9c9df6
--- /dev/null
+++ b/src/lib/server/password.test.ts
@@ -0,0 +1,109 @@
+import { describe, test, expect } from 'vitest';
+
+import { hashPassword, verifyPassword } from './password';
+
+// Fixtures generated with lucia v2 (`generateLuciaPasswordHash` from 'lucia/utils') before removing
+// lucia, so these hashes are the compatibility anchor. Regenerate with:
+//   import { generateLuciaPasswordHash } from 'lucia/utils';
+//   for (const p of ['Ch0kuda1', 'AtC0derN0viSteps', 'Ｃｈ０ｋｕｄａ１']) console.log(await generateLuciaPasswordHash(p));
+//
+// - 'Ch0kuda1': the seed password (authSchema-compliant, prod-compatible anchor)
+// - 'AtC0derN0viSteps': a second compliant password (rules out an accidental single match)
+// - 'Ｃｈ０ｋｕｄａ１': out of the app input domain (authSchema is ASCII-only); NFKC-normalizes to
+//   'Ch0kuda1', so verifying it with the half-width input proves the normalize step exists.
+const LUCIA_FIXTURES = {
+  ascii1: {
+    password: 'Ch0kuda1',
+    hash: 's2:idsv8a6pec9boqr1:05e7bdf0828585f6a8ffbcfe04837524993eaa22df5c769df0388dd4c4d9f71bad9b51452167f22d5d17cea4595cae0d01528b01ca2a4b3c48cbad5668b9671d',
+  },
+  ascii2: {
+    password: 'AtC0derN0viSteps',
+    hash: 's2:jky3g008bt42uobf:f1ad5f5fa1920891f5812d578b5db26da43c0258433df37edd144e53383b71a60ed3cd43f0c87e55035d116bdc575ce38fec96127ebf030afbb02179acbba0af',
+  },
+  fullWidth: {
+    password: 'Ｃｈ０ｋｕｄａ１',
+    hash: 's2:pxgjkm74zjfu1am5:e87a0132275c95eaee49b8f4ef6806d177877a557e1b2a1c074fb34531951a8b8db6a3ac7c212e02b6caa4737c9d7b4b93ce48e4d57c4bb7dbc34fb09d51c20f',
+  },
+} as const;
+
+describe('hashPassword', () => {
+  test('produces the s2:{16-char salt}:{128-char hex} format', async () => {
+    const hash = await hashPassword('Ch0kuda1');
+    expect(hash).toMatch(/^s2:[a-z0-9]{16}:[0-9a-f]{128}$/);
+  });
+
+  test('round-trips: a freshly hashed password verifies against its own hash', async () => {
+    const hash = await hashPassword('AtC0derN0viSteps');
+    expect(await verifyPassword('AtC0derN0viSteps', hash)).toBe(true);
+  });
+
+  test('uses a random salt so the same password hashes to different values', async () => {
+    const first = await hashPassword('Ch0kuda1');
+    const second = await hashPassword('Ch0kuda1');
+    expect(first).not.toBe(second);
+  });
+});
+
+describe('verifyPassword', () => {
+  describe('lucia v2 compatibility (byte-for-byte)', () => {
+    test('accepts the seed password against its lucia-generated hash', async () => {
+      expect(await verifyPassword(LUCIA_FIXTURES.ascii1.password, LUCIA_FIXTURES.ascii1.hash)).toBe(
+        true,
+      );
+    });
+
+    test('accepts a second compliant password against its lucia-generated hash', async () => {
+      expect(await verifyPassword(LUCIA_FIXTURES.ascii2.password, LUCIA_FIXTURES.ascii2.hash)).toBe(
+        true,
+      );
+    });
+  });
+
+  describe('NFKC normalization guard (out of app input domain)', () => {
+    test('accepts the full-width input against its own hash', async () => {
+      expect(
+        await verifyPassword(LUCIA_FIXTURES.fullWidth.password, LUCIA_FIXTURES.fullWidth.hash),
+      ).toBe(true);
+    });
+
+    test('accepts the half-width input against the full-width hash (normalize exists)', async () => {
+      expect(await verifyPassword('Ch0kuda1', LUCIA_FIXTURES.fullWidth.hash)).toBe(true);
+    });
+
+    test('accepts the full-width input against the half-width hash (normalize is symmetric)', async () => {
+      expect(await verifyPassword('Ｃｈ０ｋｕｄａ１', LUCIA_FIXTURES.ascii1.hash)).toBe(true);
+    });
+  });
+
+  describe('returns false without throwing', () => {
+    test('wrong password against a valid hash', async () => {
+      expect(await verifyPassword('wrongPassword1', LUCIA_FIXTURES.ascii1.hash)).toBe(false);
+    });
+
+    test('legacy two-part {salt}:{hash} format (lucia v1)', async () => {
+      const [, salt, hash] = LUCIA_FIXTURES.ascii1.hash.split(':');
+      expect(await verifyPassword('Ch0kuda1', `${salt}:${hash}`)).toBe(false);
+    });
+
+    test('bcrypt $2a$ format', async () => {
+      expect(
+        await verifyPassword(
+          'Ch0kuda1',
+          '$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy',
+        ),
+      ).toBe(false);
+    });
+
+    test('empty stored hash', async () => {
+      expect(await verifyPassword('Ch0kuda1', '')).toBe(false);
+    });
+
+    test('malformed hash with too few parts (s2:saltonly)', async () => {
+      expect(await verifyPassword('Ch0kuda1', 's2:saltonly')).toBe(false);
+    });
+
+    test('empty password against a valid hash', async () => {
+      expect(await verifyPassword('', LUCIA_FIXTURES.ascii1.hash)).toBe(false);
+    });
+  });
+});
diff --git a/src/lib/server/password.ts b/src/lib/server/password.ts
new file mode 100644
index 000000000..487cf3209
--- /dev/null
+++ b/src/lib/server/password.ts
@@ -0,0 +1,55 @@
+import { scrypt, timingSafeEqual, type BinaryLike, type ScryptOptions } from 'node:crypto';
+import { promisify } from 'node:util';
+
+import { generateRandomString } from './random';
+
+// Explicit type args select scrypt's options overload; a bare promisify(scrypt) resolves to the
+// 3-arg signature and rejects the maxmem options object.
+const scryptAsync = promisify<BinaryLike, BinaryLike, number, ScryptOptions, Buffer>(scrypt);
+
+// lucia v2 compatible parameters. 128 * N * r = 32MiB hits the default maxmem, so raise it to 64MiB.
+const SCRYPT_OPTIONS = { N: 16384, r: 16, p: 1, maxmem: 64 * 1024 * 1024 };
+const KEY_LENGTH = 64;
+const SALT_LENGTH = 16;
+const HASH_VERSION = 's2';
+
+/** Generates a lucia v2 compatible password hash: `s2:{salt}:{hash}`. */
+export const hashPassword = async (password: string): Promise<string> => {
+  const salt = generateRandomString(SALT_LENGTH);
+  const hash = await computeHash(password, salt);
+
+  return `${HASH_VERSION}:${salt}:${hash}`;
+};
+
+/** Verifies a password against a stored hash. Unknown formats (v1 two-part, bcrypt $2a) return false. */
+export const verifyPassword = async (password: string, storedHash: string): Promise<boolean> => {
+  const parts = storedHash.split(':');
+
+  if (parts.length !== 3 || parts[0] !== HASH_VERSION) {
+    return false;
+  }
+
+  const [, salt, expectedHash] = parts;
+  const actualHash = await computeHash(password, salt);
+  const expectedBuffer = Buffer.from(expectedHash, 'hex');
+  const actualBuffer = Buffer.from(actualHash, 'hex');
+
+  // timingSafeEqual throws on length mismatch, so check length first
+  if (expectedBuffer.length !== actualBuffer.length) {
+    return false;
+  }
+
+  return timingSafeEqual(expectedBuffer, actualBuffer);
+};
+
+const computeHash = async (password: string, salt: string): Promise<string> => {
+  // NFKC-normalize so visually identical unicode inputs hash identically (lucia v2 behavior)
+  const derivedKey = await scryptAsync(
+    password.normalize('NFKC'),
+    salt,
+    KEY_LENGTH,
+    SCRYPT_OPTIONS,
+  );
+
+  return derivedKey.toString('hex');
+};
diff --git a/src/lib/server/random.test.ts b/src/lib/server/random.test.ts
new file mode 100644
index 000000000..0372b482a
--- /dev/null
+++ b/src/lib/server/random.test.ts
@@ -0,0 +1,28 @@
+import { describe, test, expect } from 'vitest';
+
+import { generateRandomString } from './random';
+
+const ALPHABET_PATTERN = /^[a-z0-9]+$/;
+
+describe('generateRandomString', () => {
+  test.each([16, 15, 40])('returns a string of the requested length (%i)', (length) => {
+    expect(generateRandomString(length)).toHaveLength(length);
+  });
+
+  test('returns only characters from the 36-char [a-z0-9] alphabet', () => {
+    // 1000 samples across the lengths lucia v2 uses (salt / user id / session id)
+    for (let i = 0; i < 1000; i++) {
+      expect(generateRandomString(40)).toMatch(ALPHABET_PATTERN);
+    }
+  });
+
+  test('returns a different value on each call (no collisions)', () => {
+    const values = new Set<string>();
+
+    for (let i = 0; i < 1000; i++) {
+      values.add(generateRandomString(40));
+    }
+
+    expect(values.size).toBe(1000);
+  });
+});
diff --git a/src/lib/server/random.ts b/src/lib/server/random.ts
new file mode 100644
index 000000000..9197fc61e
--- /dev/null
+++ b/src/lib/server/random.ts
@@ -0,0 +1,20 @@
+// Ported from lucia v2's generateRandomString (lucia/dist/utils/crypto.js). lucia's signature takes
+// an optional `alphabet` param, but every call site — lucia's own (salt / user id / session id) and
+// ours — uses this default 36-char alphabet, so it is inlined instead of kept as an unused param.
+const ALPHABET = 'abcdefghijklmnopqrstuvwxyz1234567890';
+
+/** lucia v2 compatible random string (used for salts, user ids, and session ids). */
+export const generateRandomString = (length: number): string => {
+  const randomUint32Values = new Uint32Array(length);
+  crypto.getRandomValues(randomUint32Values);
+  const u32Max = 0xffffffff;
+  let result = '';
+
+  // bound the loop by the array length (lucia's exact condition), not the raw `length` argument
+  for (let i = 0; i < randomUint32Values.length; i++) {
+    const rand = randomUint32Values[i] / (u32Max + 1);
+    result += ALPHABET[Math.floor(ALPHABET.length * rand)];
+  }
+
+  return result;
+};

From a290c2a63ce8545ed6cd3b3c4e727296ec1827ad Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 07:33:26 +0000
Subject: [PATCH 02/12] feat(server): add lucia v2 compatible session
 management

Reimplements lucia v2's session create/validate/invalidate semantics
(24h active + 14d idle window, idle-triggered renewal without id
rotation, idempotent delete) directly against Prisma, continuing the
lucia dependency removal alongside the password hashing utilities.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 src/lib/server/session.test.ts | 202 +++++++++++++++++++++++++++++++++
 src/lib/server/session.ts      |  95 ++++++++++++++++
 2 files changed, 297 insertions(+)
 create mode 100644 src/lib/server/session.test.ts
 create mode 100644 src/lib/server/session.ts

diff --git a/src/lib/server/session.test.ts b/src/lib/server/session.test.ts
new file mode 100644
index 000000000..7f2ff9eee
--- /dev/null
+++ b/src/lib/server/session.test.ts
@@ -0,0 +1,202 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
+
+import { Prisma, Roles } from '@prisma/client';
+
+vi.mock('$lib/server/database', () => ({
+  default: {
+    session: {
+      create: vi.fn(),
+      findUnique: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    },
+  },
+}));
+
+import db from '$lib/server/database';
+import { createSession, validateSession, invalidateSession, SESSION_COOKIE_NAME } from './session';
+
+const mockDb = db as unknown as {
+  session: {
+    create: ReturnType<typeof vi.fn>;
+    findUnique: ReturnType<typeof vi.fn>;
+    update: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+  };
+};
+
+// lucia v2 defaults, duplicated here so assertions pin literal periods rather than the impl's constants
+const ACTIVE_PERIOD_MS = 1000 * 60 * 60 * 24; // 24h
+const IDLE_PERIOD_MS = 1000 * 60 * 60 * 24 * 14; // 14d
+
+// fixed clock so expiration math is deterministic under fake timers
+const NOW = new Date('2026-07-15T00:00:00.000Z').getTime();
+
+const SESSION_ID = 'a'.repeat(40);
+const USER = { id: 'abcdefghij12345', username: 'guest', role: Roles.USER };
+
+// active_expires / idle_expires MUST be BigInt here: Prisma returns them as bigint, so a Number mock
+// would hide a missing Number() conversion in the implementation.
+const buildSessionRow = (activeExpires: number, idleExpires: number) => ({
+  id: SESSION_ID,
+  user_id: USER.id,
+  active_expires: BigInt(activeExpires),
+  idle_expires: BigInt(idleExpires),
+  user: { id: USER.id, username: USER.username, role: USER.role },
+});
+
+// a fully-active session (both deadlines well in the future); shared by the two active-state cases
+const activeSessionRow = () =>
+  buildSessionRow(NOW + ACTIVE_PERIOD_MS, NOW + ACTIVE_PERIOD_MS + IDLE_PERIOD_MS);
+
+const mockFindUnique = (row: ReturnType<typeof buildSessionRow> | null) =>
+  mockDb.session.findUnique.mockResolvedValue(row);
+
+const buildPrismaError = (code: string, message: string) =>
+  new Prisma.PrismaClientKnownRequestError(message, { code, clientVersion: '5.0.0' });
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.useFakeTimers();
+  vi.setSystemTime(NOW);
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe('createSession', () => {
+  test('creates a row with a 40-char [a-z0-9] id and lucia v2 expirations', async () => {
+    const result = await createSession(USER.id);
+
+    expect(result.sessionId).toMatch(/^[a-z0-9]{40}$/);
+    // expirations are written as Number (not BigInt), matching the previous lucia adapter
+    expect(mockDb.session.create).toHaveBeenCalledWith({
+      data: {
+        id: result.sessionId,
+        user_id: USER.id,
+        active_expires: NOW + ACTIVE_PERIOD_MS,
+        idle_expires: NOW + ACTIVE_PERIOD_MS + IDLE_PERIOD_MS,
+      },
+    });
+  });
+
+  test('returns the idle-period expiry as the cookie expiry Date', async () => {
+    const result = await createSession(USER.id);
+
+    expect(result.idlePeriodExpiresAt).toEqual(new Date(NOW + ACTIVE_PERIOD_MS + IDLE_PERIOD_MS));
+  });
+});
+
+describe('validateSession', () => {
+  describe('active session (now <= active_expires)', () => {
+    test('returns the session and user without updating or deleting', async () => {
+      mockFindUnique(activeSessionRow());
+
+      const result = await validateSession(SESSION_ID);
+
+      expect(result).toEqual({
+        sessionId: SESSION_ID,
+        user: { userId: USER.id, username: USER.username, role: USER.role },
+      });
+      expect(mockDb.session.update).not.toHaveBeenCalled();
+      expect(mockDb.session.delete).not.toHaveBeenCalled();
+    });
+
+    test('reads the session and user in a single findUnique with include: { user: true }', async () => {
+      mockFindUnique(activeSessionRow());
+
+      await validateSession(SESSION_ID);
+
+      expect(mockDb.session.findUnique).toHaveBeenCalledWith({
+        where: { id: SESSION_ID },
+        include: { user: true },
+      });
+    });
+
+    test('treats now === active_expires as active (no write) — lucia > comparison', async () => {
+      mockFindUnique(buildSessionRow(NOW, NOW + IDLE_PERIOD_MS));
+
+      const result = await validateSession(SESSION_ID);
+
+      expect(result).not.toBeNull();
+      expect(mockDb.session.update).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('idle session (active_expires < now <= idle_expires)', () => {
+    test('extends both expirations on the same id without deleting', async () => {
+      mockFindUnique(buildSessionRow(NOW - 1000, NOW + IDLE_PERIOD_MS));
+
+      const result = await validateSession(SESSION_ID);
+
+      expect(result).not.toBeNull();
+      expect(mockDb.session.update).toHaveBeenCalledWith({
+        where: { id: SESSION_ID },
+        data: {
+          active_expires: NOW + ACTIVE_PERIOD_MS,
+          idle_expires: NOW + ACTIVE_PERIOD_MS + IDLE_PERIOD_MS,
+        },
+      });
+      expect(mockDb.session.delete).not.toHaveBeenCalled();
+    });
+
+    test('treats now === idle_expires as idle (extends) — lucia > comparison', async () => {
+      mockFindUnique(buildSessionRow(NOW - IDLE_PERIOD_MS, NOW));
+
+      await validateSession(SESSION_ID);
+
+      expect(mockDb.session.update).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('dead session (now > idle_expires)', () => {
+    test('returns null and keeps the row (no update, no delete)', async () => {
+      mockFindUnique(buildSessionRow(NOW - IDLE_PERIOD_MS - ACTIVE_PERIOD_MS, NOW - 1));
+
+      const result = await validateSession(SESSION_ID);
+
+      expect(result).toBeNull();
+      expect(mockDb.session.update).not.toHaveBeenCalled();
+      expect(mockDb.session.delete).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('missing session', () => {
+    test('returns null when the row does not exist', async () => {
+      mockFindUnique(null);
+
+      expect(await validateSession(SESSION_ID)).toBeNull();
+    });
+  });
+});
+
+describe('invalidateSession', () => {
+  test('deletes the session row by id', async () => {
+    mockDb.session.delete.mockResolvedValue(buildSessionRow(NOW, NOW));
+
+    await invalidateSession(SESSION_ID);
+
+    expect(mockDb.session.delete).toHaveBeenCalledWith({ where: { id: SESSION_ID } });
+  });
+
+  test('swallows P2025 (row already gone) for logout idempotency', async () => {
+    const error = buildPrismaError('P2025', 'Record to delete does not exist.');
+    mockDb.session.delete.mockRejectedValue(error);
+
+    await expect(invalidateSession(SESSION_ID)).resolves.toBeUndefined();
+  });
+
+  test('re-throws Prisma errors other than P2025', async () => {
+    const error = buildPrismaError('P2003', 'Foreign key constraint failed.');
+    mockDb.session.delete.mockRejectedValue(error);
+
+    await expect(invalidateSession(SESSION_ID)).rejects.toBe(error);
+  });
+});
+
+describe('SESSION_COOKIE_NAME', () => {
+  test('matches the lucia v2 cookie name so existing sessions stay valid', () => {
+    expect(SESSION_COOKIE_NAME).toBe('auth_session');
+  });
+});
diff --git a/src/lib/server/session.ts b/src/lib/server/session.ts
new file mode 100644
index 000000000..a85910661
--- /dev/null
+++ b/src/lib/server/session.ts
@@ -0,0 +1,95 @@
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
+import type { Roles } from '@prisma/client';
+
+import client from '$lib/server/database';
+import { generateRandomString } from '$lib/server/random';
+
+// lucia v2 defaults: active 24h, idle +14d
+const ACTIVE_PERIOD_MS = 1000 * 60 * 60 * 24;
+const IDLE_PERIOD_MS = 1000 * 60 * 60 * 24 * 14;
+const SESSION_ID_LENGTH = 40;
+
+export const SESSION_COOKIE_NAME = 'auth_session';
+
+export type SessionCookieData = { sessionId: string; idlePeriodExpiresAt: Date };
+
+export type ValidatedSession = {
+  sessionId: string;
+  user: { userId: string; username: string; role: Roles };
+};
+
+export const createSession = async (userId: string): Promise<SessionCookieData> => {
+  const sessionId = generateRandomString(SESSION_ID_LENGTH);
+  const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(Date.now());
+
+  await client.session.create({
+    data: {
+      id: sessionId,
+      user_id: userId,
+      active_expires: activePeriodExpiresAt.getTime(),
+      idle_expires: idlePeriodExpiresAt.getTime(),
+    },
+  });
+
+  return { sessionId, idlePeriodExpiresAt };
+};
+
+export const validateSession = async (sessionId: string): Promise<ValidatedSession | null> => {
+  const session = await client.session.findUnique({
+    where: { id: sessionId },
+    include: { user: true },
+  });
+
+  if (!session) {
+    return null;
+  }
+
+  const now = Date.now();
+
+  // lucia v2: expired only when now is strictly past the deadline; dead rows are kept (no cleanup)
+  if (now > Number(session.idle_expires)) {
+    return null;
+  }
+
+  if (now > Number(session.active_expires)) {
+    // idle state: extend expirations keeping the same id (no rotation, cookie untouched)
+    const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(now);
+
+    await client.session.update({
+      where: { id: sessionId },
+      data: {
+        active_expires: activePeriodExpiresAt.getTime(),
+        idle_expires: idlePeriodExpiresAt.getTime(),
+      },
+    });
+  }
+
+  return {
+    sessionId: session.id,
+    user: {
+      userId: session.user.id,
+      username: session.user.username,
+      role: session.user.role,
+    },
+  };
+};
+
+export const invalidateSession = async (sessionId: string): Promise<void> => {
+  try {
+    await client.session.delete({ where: { id: sessionId } });
+  } catch (error) {
+    // P2025 (row already gone): swallow for logout idempotency, same as the lucia adapter
+    if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
+      return;
+    }
+
+    throw error;
+  }
+};
+
+const computeExpirations = (now: number) => {
+  const activePeriodExpiresAt = new Date(now + ACTIVE_PERIOD_MS);
+  const idlePeriodExpiresAt = new Date(activePeriodExpiresAt.getTime() + IDLE_PERIOD_MS);
+
+  return { activePeriodExpiresAt, idlePeriodExpiresAt };
+};

From 280edf78a89034c19fec066226a13387ef2fd595 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 11:22:31 +0000
Subject: [PATCH 03/12] feat(server): wire self-managed session/auth into hooks
 and app.d.ts

Adds createAuthRequest as a lucia-free replacement for
auth.handleRequest(event), backed by the new session service
(validateSession) and session cookie constants. Wires it into
hooks.server.ts and retypes app.d.ts's Locals.auth accordingly.
The lucia import in auth.ts is still present pending full removal.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 src/app.d.ts                |   2 +-
 src/hooks.server.ts         |   6 +-
 src/lib/server/auth.test.ts | 127 ++++++++++++++++++++++++++++++++++++
 src/lib/server/auth.ts      |  66 +++++++++++++++++++
 4 files changed, 197 insertions(+), 4 deletions(-)
 create mode 100644 src/lib/server/auth.test.ts

diff --git a/src/app.d.ts b/src/app.d.ts
index 22e732c7a..845182fb8 100644
--- a/src/app.d.ts
+++ b/src/app.d.ts
@@ -7,7 +7,7 @@ declare global {
   namespace App {
     // interface Error {}
     interface Locals {
-      auth: import('lucia').AuthRequest;
+      auth: import('$lib/server/auth').AuthRequest;
       user: {
         id: string;
         name: string;
diff --git a/src/hooks.server.ts b/src/hooks.server.ts
index 5fb9430a8..1f33289f2 100644
--- a/src/hooks.server.ts
+++ b/src/hooks.server.ts
@@ -1,14 +1,14 @@
 // See:
-// https://lucia-auth.com/getting-started/sveltekit/
 // https://github.com/joysofcode/sveltekit-deploy
 // https://tech-blog.rakus.co.jp/entry/20230209/sveltekit
-import { auth } from '$lib/server/auth';
 import type { Handle } from '@sveltejs/kit';
 
+import { createAuthRequest } from '$lib/server/auth';
+
 import * as userService from '$lib/services/users';
 
 export const handle: Handle = async ({ event, resolve }) => {
-  event.locals.auth = auth.handleRequest(event);
+  event.locals.auth = createAuthRequest(event);
   const session = await event.locals.auth.validate();
 
   if (!session) {
diff --git a/src/lib/server/auth.test.ts b/src/lib/server/auth.test.ts
new file mode 100644
index 000000000..3bcc18b57
--- /dev/null
+++ b/src/lib/server/auth.test.ts
@@ -0,0 +1,127 @@
+import { describe, test, expect, beforeEach, vi } from 'vitest';
+
+import type { RequestEvent } from '@sveltejs/kit';
+import { Roles } from '@prisma/client';
+
+// dev = false so `secure: !dev` resolves to true (the production-relevant cookie flag)
+vi.mock('$app/environment', () => ({ dev: false }));
+
+vi.mock('$lib/server/session', () => ({
+  SESSION_COOKIE_NAME: 'auth_session',
+  validateSession: vi.fn(),
+}));
+
+// auth.ts still initializes lucia in Phase 3, which pulls in the database client; stub it out
+vi.mock('$lib/server/database', () => ({
+  default: { session: {}, key: {}, user: {} },
+}));
+
+import { createAuthRequest } from './auth';
+import { validateSession, SESSION_COOKIE_NAME } from '$lib/server/session';
+
+const mockValidateSession = validateSession as unknown as ReturnType<typeof vi.fn>;
+
+const VALID_SESSION = {
+  sessionId: 'a'.repeat(40),
+  user: { userId: 'abcdefghij12345', username: 'guest', role: Roles.USER },
+};
+
+const createMockEvent = (cookieValue?: string) => {
+  const cookies = {
+    get: vi.fn().mockReturnValue(cookieValue),
+    set: vi.fn(),
+    delete: vi.fn(),
+  };
+
+  return { cookies } as unknown as RequestEvent & {
+    cookies: {
+      get: ReturnType<typeof vi.fn>;
+      set: ReturnType<typeof vi.fn>;
+      delete: ReturnType<typeof vi.fn>;
+    };
+  };
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('createAuthRequest', () => {
+  describe('validate', () => {
+    test('returns null and skips validateSession when no cookie is present', async () => {
+      const event = createMockEvent(undefined);
+      const auth = createAuthRequest(event);
+
+      expect(await auth.validate()).toBeNull();
+      expect(mockValidateSession).not.toHaveBeenCalled();
+    });
+
+    test('returns the validated session for a present, valid cookie', async () => {
+      mockValidateSession.mockResolvedValue(VALID_SESSION);
+      const event = createMockEvent(VALID_SESSION.sessionId);
+      const auth = createAuthRequest(event);
+
+      expect(await auth.validate()).toEqual(VALID_SESSION);
+      expect(mockValidateSession).toHaveBeenCalledWith(VALID_SESSION.sessionId);
+    });
+
+    test('caches within the request: a second validate() does not re-query', async () => {
+      mockValidateSession.mockResolvedValue(VALID_SESSION);
+      const event = createMockEvent(VALID_SESSION.sessionId);
+      const auth = createAuthRequest(event);
+
+      await auth.validate();
+      await auth.validate();
+
+      expect(mockValidateSession).toHaveBeenCalledOnce();
+    });
+
+    test('clears the stale cookie and returns null when the session is invalid', async () => {
+      mockValidateSession.mockResolvedValue(null);
+      const event = createMockEvent('stale-session-id');
+      const auth = createAuthRequest(event);
+
+      expect(await auth.validate()).toBeNull();
+      expect(event.cookies.delete).toHaveBeenCalledWith(SESSION_COOKIE_NAME, { path: '/' });
+    });
+  });
+
+  describe('setSession', () => {
+    test('sets the cookie with lucia v2 attributes for a session', () => {
+      const event = createMockEvent();
+      const auth = createAuthRequest(event);
+      const idlePeriodExpiresAt = new Date('2026-07-29T00:00:00.000Z');
+
+      auth.setSession({ sessionId: VALID_SESSION.sessionId, idlePeriodExpiresAt });
+
+      expect(event.cookies.set).toHaveBeenCalledWith(SESSION_COOKIE_NAME, VALID_SESSION.sessionId, {
+        path: '/',
+        httpOnly: true,
+        sameSite: 'lax',
+        secure: true, // !dev, with dev mocked to false
+        expires: idlePeriodExpiresAt,
+      });
+    });
+
+    test('deletes the cookie when passed null', () => {
+      const event = createMockEvent();
+      const auth = createAuthRequest(event);
+
+      auth.setSession(null);
+
+      expect(event.cookies.delete).toHaveBeenCalledWith(SESSION_COOKIE_NAME, { path: '/' });
+    });
+
+    test('invalidates the request cache so the next validate() re-queries', async () => {
+      mockValidateSession.mockResolvedValue(VALID_SESSION);
+      const event = createMockEvent(VALID_SESSION.sessionId);
+      const auth = createAuthRequest(event);
+
+      await auth.validate();
+      auth.setSession(null);
+      await auth.validate();
+
+      expect(mockValidateSession).toHaveBeenCalledTimes(2);
+    });
+  });
+});
diff --git a/src/lib/server/auth.ts b/src/lib/server/auth.ts
index 1743d4b8e..488100fa6 100644
--- a/src/lib/server/auth.ts
+++ b/src/lib/server/auth.ts
@@ -5,7 +5,15 @@ import { lucia } from 'lucia';
 import { sveltekit } from 'lucia/middleware';
 import { dev } from '$app/environment';
 import { prisma } from '@lucia-auth/adapter-prisma';
+import type { RequestEvent } from '@sveltejs/kit';
+
 import client from '$lib/server/database';
+import {
+  SESSION_COOKIE_NAME,
+  validateSession,
+  type SessionCookieData,
+  type ValidatedSession,
+} from '$lib/server/session';
 
 export const auth = lucia({
   env: dev ? 'DEV' : 'PROD',
@@ -23,3 +31,61 @@ export const auth = lucia({
 });
 
 export type Auth = typeof auth;
+
+export type AuthRequest = {
+  validate: () => Promise<ValidatedSession | null>;
+  setSession: (session: SessionCookieData | null) => void;
+};
+
+/**
+ * Request-scoped auth handle that replaces lucia's `auth.handleRequest(event)`.
+ * Reads/writes the session cookie and delegates session lookup to the self-managed session service.
+ */
+export const createAuthRequest = (event: RequestEvent): AuthRequest => {
+  let validatePromise: Promise<ValidatedSession | null> | null = null;
+
+  const setSessionCookie = (session: SessionCookieData | null): void => {
+    if (session) {
+      event.cookies.set(SESSION_COOKIE_NAME, session.sessionId, {
+        path: '/',
+        httpOnly: true,
+        sameSite: 'lax',
+        secure: !dev,
+        expires: session.idlePeriodExpiresAt,
+      });
+    } else {
+      event.cookies.delete(SESSION_COOKIE_NAME, { path: '/' });
+    }
+  };
+
+  return {
+    validate: () => {
+      // request-scoped cache: hooks and route guards both call validate() on every request
+      if (validatePromise) {
+        return validatePromise;
+      }
+
+      validatePromise = (async () => {
+        const sessionId = event.cookies.get(SESSION_COOKIE_NAME);
+
+        if (!sessionId) {
+          return null;
+        }
+
+        const session = await validateSession(sessionId);
+
+        if (!session) {
+          setSessionCookie(null); // clear the stale cookie (lucia v2 behavior)
+        }
+
+        return session;
+      })();
+
+      return validatePromise;
+    },
+    setSession: (session) => {
+      validatePromise = null;
+      setSessionCookie(session);
+    },
+  };
+};

From de8e2a71b32a01ce38e754ace1109452fa4b2958 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 12:47:48 +0000
Subject: [PATCH 04/12] refactor(auth): remove lucia dependency, run auth on
 self-managed session/credentials

Replaces lucia's createUser/createSession/useKey/invalidateSession
calls in the login, signup, and logout routes with the new
credentials service (registerUser/authenticateUser) and session
service (createSession/invalidateSession) added in prior commits.
Drops @lucia-auth/adapter-prisma and lucia from package.json/lockfile,
removes the lucia auth() export, and cleans up now-stale lucia
references in schema.prisma, database.ts, app.d.ts, and auth.md.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .claude/rules/auth.md                         |  11 +-
 package.json                                  |   2 -
 pnpm-lock.yaml                                |  24 ---
 prisma/schema.prisma                          |  10 +-
 prisma/seed.ts                                |   7 +-
 src/app.d.ts                                  |  14 --
 .../services/atcoder_verification.test.ts     |   3 +-
 .../auth/services/credentials.test.ts         | 157 ++++++++++++++++++
 src/features/auth/services/credentials.ts     |  52 ++++++
 src/lib/server/auth.test.ts                   |   5 -
 src/lib/server/auth.ts                        |  24 ---
 src/lib/server/database.ts                    |   1 -
 src/routes/(auth)/login/+page.server.ts       |  33 ++--
 src/routes/(auth)/logout/+page.server.ts      |   7 +-
 src/routes/(auth)/signup/+page.server.ts      |  42 +----
 src/routes/+layout.server.ts                  |   2 -
 src/routes/+page.server.ts                    |   2 -
 src/routes/+page.svelte                       |   2 -
 18 files changed, 245 insertions(+), 153 deletions(-)
 create mode 100644 src/features/auth/services/credentials.test.ts
 create mode 100644 src/features/auth/services/credentials.ts

diff --git a/.claude/rules/auth.md b/.claude/rules/auth.md
index 6fc8c9b5b..a287e753e 100644
--- a/.claude/rules/auth.md
+++ b/.claude/rules/auth.md
@@ -10,10 +10,11 @@ paths:
 
 # Authentication
 
-## Lucia v2
+## Self-Managed Session Auth
 
-- Session validation in `src/hooks.server.ts`
-- Session data attached to `event.locals.user`
+Auth is a self-managed implementation (no external auth library), kept compatible with the retired lucia v2 so existing sessions and password hashes stay valid. See `## Key Files` for the module map.
+
+- Session validation in `src/hooks.server.ts`; session data attached to `event.locals.user`
 - User properties: `id`, `name`, `role`, `atcoder_name`, `is_validated`
 
 ## Protected Routes
@@ -30,7 +31,9 @@ paths:
 
 ## Key Files
 
-- `src/lib/server/auth.ts`: Lucia configuration
+- `src/lib/server/auth.ts`: `createAuthRequest` (request-scoped session handle)
+- `src/lib/server/session.ts` / `src/lib/server/password.ts`: self-managed session + password crypto
+- `src/features/auth/services/credentials.ts`: `registerUser` / `authenticateUser`
 - `src/hooks.server.ts`: Global request handler
 - `src/features/auth/services/session.ts`:
   - `getLoggedInUser(locals, url?)` — returns logged-in user or redirects to `/login`
diff --git a/package.json b/package.json
index a32e1b8f4..0d2c597e4 100644
--- a/package.json
+++ b/package.json
@@ -73,12 +73,10 @@
   "dependencies": {
     "@dnd-kit/helpers": "0.5.0",
     "@dnd-kit/svelte": "0.5.0",
-    "@lucia-auth/adapter-prisma": "3.0.2",
     "@lucide/svelte": "1.24.0",
     "@prisma/client": "5.22.0",
     "@types/node": "25.9.5",
     "debug": "4.4.3",
-    "lucia": "2.7.7",
     "p-queue": "9.3.1",
     "playwright": "1.61.1",
     "svelte-eslint-parser": "1.8.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fb2924319..15d5808c5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -33,9 +33,6 @@ importers:
       '@dnd-kit/svelte':
         specifier: 0.5.0
         version: 0.5.0(svelte@5.56.4(@typescript-eslint/types@8.64.0))
-      '@lucia-auth/adapter-prisma':
-        specifier: 3.0.2
-        version: 3.0.2(@prisma/client@5.22.0(prisma@5.22.0))(lucia@2.7.7)
       '@lucide/svelte':
         specifier: 1.24.0
         version: 1.24.0(svelte@5.56.4(@typescript-eslint/types@8.64.0))
@@ -48,9 +45,6 @@ importers:
       debug:
         specifier: 4.4.3
         version: 4.4.3
-      lucia:
-        specifier: 2.7.7
-        version: 2.7.7
       p-queue:
         specifier: 9.3.1
         version: 9.3.1
@@ -763,13 +757,6 @@ packages:
   '@jridgewell/trace-mapping@0.3.31':
     resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
-  '@lucia-auth/adapter-prisma@3.0.2':
-    resolution: {integrity: sha512-EyJWZene1/zasPwPctv8wwNErZt5mwwm5JATbhg+kXr3R8pbC7lJfVzDTAeeFClVH5k/FywRcsBl3JkPaNIcow==}
-    deprecated: This package has been deprecated. Please see https://lucia-auth.com/lucia-v3/migrate.
-    peerDependencies:
-      '@prisma/client': ^4.2.0 || ^5.0.0
-      lucia: ^2.0.0
-
   '@lucide/svelte@1.24.0':
     resolution: {integrity: sha512-yXwewA7ANQ5hfaSDrvsecosWjZn5RglzeXUZRSnxeANBskpNwblOkEJTqD0ujDdNKIKL8E9eVc2U/P3ziJr7OA==}
     peerDependencies:
@@ -2909,10 +2896,6 @@ packages:
     resolution: {integrity: sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==}
     engines: {node: '>=12'}
 
-  lucia@2.7.7:
-    resolution: {integrity: sha512-Hy1nMcLquLl3yDvV9zYA9fSBGUDy/Fw2zEUw2Ia4iGdk/O+hI/TvQ1tAfED/U1WE/c5DT1hEger3m7qIx1qbUg==}
-    deprecated: This package has been deprecated. Please see https://lucia-auth.com/lucia-v3/migrate.
-
   luxon@3.7.2:
     resolution: {integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==}
     engines: {node: '>=12'}
@@ -4481,11 +4464,6 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
-  '@lucia-auth/adapter-prisma@3.0.2(@prisma/client@5.22.0(prisma@5.22.0))(lucia@2.7.7)':
-    dependencies:
-      '@prisma/client': 5.22.0(prisma@5.22.0)
-      lucia: 2.7.7
-
   '@lucide/svelte@1.24.0(svelte@5.56.4(@typescript-eslint/types@8.64.0))':
     dependencies:
       svelte: 5.56.4(@typescript-eslint/types@8.64.0)
@@ -6689,8 +6667,6 @@ snapshots:
 
   lru-cache@7.18.3: {}
 
-  lucia@2.7.7: {}
-
   luxon@3.7.2: {}
 
   magic-string@0.30.21:
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 9c518fbfe..1dde3079e 100755
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -31,13 +31,9 @@ datasource db {
   directUrl = env("DIRECT_URL")
 }
 
-// Note: Lucia v3 + v3 Prisma adaperでは、全てのフィールドがキャメルケースであることが要求されている。
-//       段階的に移行を進めるため、modelを追加・修正する場合は、キャメルケースで記述する。
-// See:
-// https://lucia-auth.com/upgrade-v3/prisma/postgresql
-
-// See:
-// https://lucia-auth.com/database-adapters/prisma/
+// Note: write new models and fields in camelCase.
+//       The snake_case fields on User / Session / Key are legacy (from the old lucia adapter);
+//       kept as-is to avoid a DB migration.
 model User {
   id         String   @id @unique
   // here you can add custom fields for your user
diff --git a/prisma/seed.ts b/prisma/seed.ts
index 03070452b..f94de65c7 100755
--- a/prisma/seed.ts
+++ b/prisma/seed.ts
@@ -19,7 +19,7 @@ import {
   defineWorkBookFactory,
 } from './.fabbrica';
 import PQueue from 'p-queue';
-import { generateLuciaPasswordHash } from 'lucia/utils';
+import { hashPassword } from '../src/lib/server/password';
 
 import { getTaskGrade } from '../src/lib/types/task';
 import type { PlacementCreate } from '../src/features/workbooks/types/workbook_placement';
@@ -62,7 +62,6 @@ const QUEUE_CONCURRENCY = {
 
 // See:
 // https://github.com/TeemuKoivisto/sveltekit-monorepo-template/blob/main/packages/db/prisma/seed.ts
-// https://lucia-auth.com/basics/keys/#password-hashing
 // https://www.prisma.io/docs/reference/api-reference/prisma-client-reference#findunique
 // https://github.com/sindresorhus/p-queue
 async function main() {
@@ -119,8 +118,6 @@ async function addUsers() {
   console.log('Finished adding users.');
 }
 
-// See:
-// https://lucia-auth.com/reference/lucia/modules/utils/#generateluciapasswordhash
 async function addUser(
   user: (typeof users)[number],
   password: string,
@@ -132,7 +129,7 @@ async function addUser(
     username: user.name,
     role: user.role,
   });
-  const hashed_password = await generateLuciaPasswordHash(password);
+  const hashed_password = await hashPassword(password);
 
   await keyFactory.create({
     user: { connect: currentUser },
diff --git a/src/app.d.ts b/src/app.d.ts
index 845182fb8..16eef8e48 100644
--- a/src/app.d.ts
+++ b/src/app.d.ts
@@ -21,19 +21,5 @@ declare global {
   }
 }
 
-// See:
-// https://lucia-auth.com/getting-started/sveltekit/
-/// <reference types="lucia" />
-declare global {
-  namespace Lucia {
-    type Auth = import('$lib/server/auth').Auth;
-    type UserAttributes = {
-      username: string;
-      role: Roles;
-    };
-    // type SessionAttributes = {};
-  }
-}
-
 // THIS IS IMPORTANT!!!
 export {};
diff --git a/src/features/account/services/atcoder_verification.test.ts b/src/features/account/services/atcoder_verification.test.ts
index 929d1f0a7..1f63c872d 100644
--- a/src/features/account/services/atcoder_verification.test.ts
+++ b/src/features/account/services/atcoder_verification.test.ts
@@ -42,7 +42,8 @@ type UserWithAtCoderAccount = Awaited<ReturnType<typeof prisma.user.findUniqueOr
 // ---------------------------------------------------------------------------
 
 const SAMPLE_TIMESTAMP = new Date('2024-01-01T00:00:00Z');
-// Lucia (auth library) auto-generates User.id in UUID format
+// The auth service generates User.id as a 15-char [a-z0-9] random string; this fixture predates
+// that and uses a UUID, which is fine here since these tests never assert the id format.
 const SAMPLE_USER_ID = '550e8400-e29b-41d4-a716-446655440000';
 const SAMPLE_USERNAME = 'alice';
 const SAMPLE_HANDLE = 'alice_ac';
diff --git a/src/features/auth/services/credentials.test.ts b/src/features/auth/services/credentials.test.ts
new file mode 100644
index 000000000..ee91fb346
--- /dev/null
+++ b/src/features/auth/services/credentials.test.ts
@@ -0,0 +1,157 @@
+import { describe, test, expect, beforeEach, vi } from 'vitest';
+
+import { Prisma } from '@prisma/client';
+
+vi.mock('$lib/server/database', () => ({
+  default: {
+    $transaction: vi.fn(),
+    user: {
+      create: vi.fn(),
+    },
+    key: {
+      create: vi.fn(),
+      findUnique: vi.fn(),
+    },
+  },
+}));
+
+vi.mock('$lib/server/password', () => ({
+  hashPassword: vi.fn(),
+  verifyPassword: vi.fn(),
+}));
+
+import db from '$lib/server/database';
+import { hashPassword, verifyPassword } from '$lib/server/password';
+import { registerUser, authenticateUser } from './credentials';
+
+const mockDb = db as unknown as {
+  $transaction: ReturnType<typeof vi.fn>;
+  user: { create: ReturnType<typeof vi.fn> };
+  key: { create: ReturnType<typeof vi.fn>; findUnique: ReturnType<typeof vi.fn> };
+};
+
+const mockHashPassword = hashPassword as unknown as ReturnType<typeof vi.fn>;
+const mockVerifyPassword = verifyPassword as unknown as ReturnType<typeof vi.fn>;
+
+// realistic values: mixed-case username so the lowercased key id is exercised
+const USERNAME = 'Chokudai';
+const KEY_ID = 'username:chokudai';
+const PASSWORD = 'Ch0kuda1';
+const HASHED_PASSWORD = 's2:0123456789abcdef:' + 'a'.repeat(128);
+
+const buildPrismaError = (code: string, message: string) =>
+  new Prisma.PrismaClientKnownRequestError(message, { code, clientVersion: '5.0.0' });
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('registerUser', () => {
+  describe('successful case', () => {
+    test('creates the user and key in a single transaction and returns the new user id', async () => {
+      mockHashPassword.mockResolvedValue(HASHED_PASSWORD);
+      mockDb.$transaction.mockResolvedValue([]);
+
+      const result = await registerUser(USERNAME, PASSWORD);
+
+      // user id is a lucia v2 compatible 15-char [a-z0-9] random string
+      expect(result).not.toBeNull();
+      const userId = result!.userId;
+      expect(userId).toMatch(/^[a-z0-9]{15}$/);
+
+      // the same generated id is used for the user row and the key's user_id
+      expect(mockDb.user.create).toHaveBeenCalledWith({
+        data: { id: userId, username: USERNAME },
+      });
+      expect(mockDb.key.create).toHaveBeenCalledWith({
+        data: { id: KEY_ID, user_id: userId, hashed_password: HASHED_PASSWORD },
+      });
+
+      // both writes run atomically via $transaction
+      expect(mockDb.$transaction).toHaveBeenCalledOnce();
+    });
+
+    test('lowercases the username for the key id but keeps the original case for the user row', async () => {
+      mockHashPassword.mockResolvedValue(HASHED_PASSWORD);
+      mockDb.$transaction.mockResolvedValue([]);
+
+      await registerUser(USERNAME, PASSWORD);
+
+      expect(mockDb.user.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ username: USERNAME }),
+      });
+      expect(mockDb.key.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ id: KEY_ID }),
+      });
+    });
+  });
+
+  describe('error cases', () => {
+    test('returns null when the username is already taken (P2002)', async () => {
+      mockHashPassword.mockResolvedValue(HASHED_PASSWORD);
+      mockDb.$transaction.mockRejectedValue(
+        buildPrismaError('P2002', 'Unique constraint failed on the fields: (`username`)'),
+      );
+
+      expect(await registerUser(USERNAME, PASSWORD)).toBeNull();
+    });
+
+    test('re-throws Prisma errors other than P2002', async () => {
+      mockHashPassword.mockResolvedValue(HASHED_PASSWORD);
+      const error = buildPrismaError('P2003', 'Foreign key constraint failed.');
+      mockDb.$transaction.mockRejectedValue(error);
+
+      await expect(registerUser(USERNAME, PASSWORD)).rejects.toBe(error);
+    });
+  });
+});
+
+describe('authenticateUser', () => {
+  describe('successful case', () => {
+    test('returns the user id when the key exists and the password verifies', async () => {
+      mockDb.key.findUnique.mockResolvedValue({
+        id: KEY_ID,
+        user_id: 'abcdefghij12345',
+        hashed_password: HASHED_PASSWORD,
+      });
+      mockVerifyPassword.mockResolvedValue(true);
+
+      const result = await authenticateUser(USERNAME, PASSWORD);
+
+      expect(result).toEqual({ userId: 'abcdefghij12345' });
+      expect(mockDb.key.findUnique).toHaveBeenCalledWith({ where: { id: KEY_ID } });
+      expect(mockVerifyPassword).toHaveBeenCalledWith(PASSWORD, HASHED_PASSWORD);
+    });
+  });
+
+  describe('error cases', () => {
+    test('returns null when no key exists for the username (does not check the password)', async () => {
+      mockDb.key.findUnique.mockResolvedValue(null);
+
+      expect(await authenticateUser(USERNAME, PASSWORD)).toBeNull();
+      expect(mockVerifyPassword).not.toHaveBeenCalled();
+    });
+
+    test('returns null when the key has no hashed_password (does not check the password)', async () => {
+      mockDb.key.findUnique.mockResolvedValue({
+        id: KEY_ID,
+        user_id: 'abcdefghij12345',
+        hashed_password: null,
+      });
+
+      expect(await authenticateUser(USERNAME, PASSWORD)).toBeNull();
+      expect(mockVerifyPassword).not.toHaveBeenCalled();
+    });
+
+    test('returns null when the password does not match', async () => {
+      mockDb.key.findUnique.mockResolvedValue({
+        id: KEY_ID,
+        user_id: 'abcdefghij12345',
+        hashed_password: HASHED_PASSWORD,
+      });
+      mockVerifyPassword.mockResolvedValue(false);
+
+      expect(await authenticateUser(USERNAME, PASSWORD)).toBeNull();
+    });
+  });
+});
diff --git a/src/features/auth/services/credentials.ts b/src/features/auth/services/credentials.ts
new file mode 100644
index 000000000..c2d0a78bd
--- /dev/null
+++ b/src/features/auth/services/credentials.ts
@@ -0,0 +1,52 @@
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
+
+import client from '$lib/server/database';
+import { hashPassword, verifyPassword } from '$lib/server/password';
+import { generateRandomString } from '$lib/server/random';
+
+const USER_ID_LENGTH = 15; // lucia v2 createUser default
+
+const buildKeyId = (username: string): string => `username:${username.toLowerCase()}`;
+
+/** Creates a user with a password key. Returns null when the username is already taken. */
+export const registerUser = async (
+  username: string,
+  password: string,
+): Promise<{ userId: string } | null> => {
+  const userId = generateRandomString(USER_ID_LENGTH);
+  const hashedPassword = await hashPassword(password);
+
+  try {
+    await client.$transaction([
+      client.user.create({ data: { id: userId, username } }),
+      client.key.create({
+        data: { id: buildKeyId(username), user_id: userId, hashed_password: hashedPassword },
+      }),
+    ]);
+  } catch (error) {
+    // P2002 on user.username or key.id both mean the username is taken
+    if (error instanceof PrismaClientKnownRequestError && error.code === 'P2002') {
+      return null;
+    }
+
+    throw error;
+  }
+
+  return { userId };
+};
+
+/** Returns the user id for valid credentials, or null (missing user and wrong password are indistinguishable). */
+export const authenticateUser = async (
+  username: string,
+  password: string,
+): Promise<{ userId: string } | null> => {
+  const key = await client.key.findUnique({ where: { id: buildKeyId(username) } });
+
+  if (!key || key.hashed_password === null) {
+    return null;
+  }
+
+  const isValid = await verifyPassword(password, key.hashed_password);
+
+  return isValid ? { userId: key.user_id } : null;
+};
diff --git a/src/lib/server/auth.test.ts b/src/lib/server/auth.test.ts
index 3bcc18b57..63394b690 100644
--- a/src/lib/server/auth.test.ts
+++ b/src/lib/server/auth.test.ts
@@ -11,11 +11,6 @@ vi.mock('$lib/server/session', () => ({
   validateSession: vi.fn(),
 }));
 
-// auth.ts still initializes lucia in Phase 3, which pulls in the database client; stub it out
-vi.mock('$lib/server/database', () => ({
-  default: { session: {}, key: {}, user: {} },
-}));
-
 import { createAuthRequest } from './auth';
 import { validateSession, SESSION_COOKIE_NAME } from '$lib/server/session';
 
diff --git a/src/lib/server/auth.ts b/src/lib/server/auth.ts
index 488100fa6..34053f0f2 100644
--- a/src/lib/server/auth.ts
+++ b/src/lib/server/auth.ts
@@ -1,13 +1,6 @@
-// See:
-// https://lucia-auth.com/getting-started/sveltekit/
-// https://lucia-auth.com/database-adapters/prisma/
-import { lucia } from 'lucia';
-import { sveltekit } from 'lucia/middleware';
 import { dev } from '$app/environment';
-import { prisma } from '@lucia-auth/adapter-prisma';
 import type { RequestEvent } from '@sveltejs/kit';
 
-import client from '$lib/server/database';
 import {
   SESSION_COOKIE_NAME,
   validateSession,
@@ -15,23 +8,6 @@ import {
   type ValidatedSession,
 } from '$lib/server/session';
 
-export const auth = lucia({
-  env: dev ? 'DEV' : 'PROD',
-  middleware: sveltekit(),
-  adapter: prisma(client),
-
-  // https://lucia-auth.com/reference/lucia/interfaces/#user
-  getUserAttributes: (userData) => {
-    return {
-      userId: userData.id,
-      username: userData.username,
-      role: userData.role,
-    };
-  },
-});
-
-export type Auth = typeof auth;
-
 export type AuthRequest = {
   validate: () => Promise<ValidatedSession | null>;
   setSession: (session: SessionCookieData | null) => void;
diff --git a/src/lib/server/database.ts b/src/lib/server/database.ts
index bf0316f5b..f63d939d2 100644
--- a/src/lib/server/database.ts
+++ b/src/lib/server/database.ts
@@ -1,5 +1,4 @@
 // See:
-// https://lucia-auth.com/getting-started/sveltekit/
 // https://www.reddit.com/r/sveltejs/comments/ozt7mk/sveltekit_with_prisma_fix/?rdt=38249
 import Prisma, * as PrismaScope from '@prisma/client';
 
diff --git a/src/routes/(auth)/login/+page.server.ts b/src/routes/(auth)/login/+page.server.ts
index 88ae77c45..0e6f15285 100644
--- a/src/routes/(auth)/login/+page.server.ts
+++ b/src/routes/(auth)/login/+page.server.ts
@@ -1,12 +1,9 @@
-// See:
-// https://lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit/
-
 // This route uses centralized helpers with fallback validation strategies.
 // See src/lib/utils/auth_forms.ts for the current form handling approach.
 import { fail, redirect } from '@sveltejs/kit';
-import { LuciaError } from 'lucia';
 
-import { auth } from '$lib/server/auth';
+import { createSession } from '$lib/server/session';
+import { authenticateUser } from '$features/auth/services/credentials';
 
 import { initializeAuthForm, validateAuthFormWithFallback } from '$lib/utils/auth_forms';
 import { isSameOriginRedirect } from '$lib/utils/url';
@@ -39,25 +36,11 @@ export const actions: Actions = {
     }
 
     try {
-      // find user by key
-      // and validate password
-      const key = await auth.useKey(
-        'username',
-        form.data.username.toLowerCase(),
-        form.data.password,
-      );
-      const session = await auth.createSession({
-        userId: key.userId,
-        attributes: {},
-      });
+      // find the user by username and validate the password
+      const authenticated = await authenticateUser(form.data.username, form.data.password);
 
-      locals.auth.setSession(session); // set session cookie
-    } catch (e) {
-      if (
-        e instanceof LuciaError &&
-        (e.message === 'AUTH_INVALID_KEY_ID' || e.message === 'AUTH_INVALID_PASSWORD')
-      ) {
-        // user does not exist or invalid password
+      // null means the user does not exist or the password is wrong (indistinguishable by design)
+      if (!authenticated) {
         return fail(BAD_REQUEST, {
           form: {
             ...form,
@@ -67,6 +50,10 @@ export const actions: Actions = {
         });
       }
 
+      const session = await createSession(authenticated.userId);
+      locals.auth.setSession(session); // set session cookie
+    } catch {
+      // unexpected failure (e.g. DB error); invalid credentials already map to null above
       return fail(INTERNAL_SERVER_ERROR, {
         form: {
           ...form,
diff --git a/src/routes/(auth)/logout/+page.server.ts b/src/routes/(auth)/logout/+page.server.ts
index 584940ce0..d16f20e37 100644
--- a/src/routes/(auth)/logout/+page.server.ts
+++ b/src/routes/(auth)/logout/+page.server.ts
@@ -1,8 +1,7 @@
-// See:
-// https://lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit/
-import { auth } from '$lib/server/auth';
 import { fail, redirect } from '@sveltejs/kit';
 
+import { invalidateSession } from '$lib/server/session';
+
 import { SEE_OTHER, UNAUTHORIZED } from '$lib/constants/http-response-status-codes';
 import { HOME_PAGE } from '$lib/constants/navbar-links';
 
@@ -20,7 +19,7 @@ export const actions: Actions = {
       return fail(UNAUTHORIZED);
     }
 
-    await auth.invalidateSession(session.sessionId); // invalidate session
+    await invalidateSession(session.sessionId); // invalidate session
     locals.auth.setSession(null); // remove cookie
 
     redirect(SEE_OTHER, HOME_PAGE);
diff --git a/src/routes/(auth)/signup/+page.server.ts b/src/routes/(auth)/signup/+page.server.ts
index ac0c0415b..22e757149 100644
--- a/src/routes/(auth)/signup/+page.server.ts
+++ b/src/routes/(auth)/signup/+page.server.ts
@@ -1,13 +1,9 @@
-// See:
-// https://lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit/
-
 // This route uses centralized helpers with fallback validation strategies.
 // See src/lib/utils/auth_forms.ts for the current form handling approach.
 import { fail, redirect } from '@sveltejs/kit';
-import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
-import { LuciaError } from 'lucia';
 
-import { auth } from '$lib/server/auth';
+import { createSession } from '$lib/server/session';
+import { registerUser } from '$features/auth/services/credentials';
 
 import { initializeAuthForm, validateAuthFormWithFallback } from '$lib/utils/auth_forms';
 import { isSameOriginRedirect } from '$lib/utils/url';
@@ -41,34 +37,10 @@ export const actions: Actions = {
     }
 
     try {
-      const user = await auth.createUser({
-        key: {
-          providerId: 'username', // auth method
-          providerUserId: form.data.username.toLowerCase(), // unique id when using "username" auth method
-          password: form.data.password, // hashed by Lucia
-        },
-        attributes: {
-          username: form.data.username,
-        },
-      });
+      const registered = await registerUser(form.data.username, form.data.password);
 
-      const session = await auth.createSession({
-        userId: user.userId,
-        attributes: {},
-      });
-
-      locals.auth.setSession(session); // set session cookie
-    } catch (e) {
-      // this part depends on the database you're using
-      // check for unique constraint error in user table
-      // See:
-      // https://www.prisma.io/docs/reference/api-reference/error-reference#prismaclientknownrequesterror
-      // https://www.prisma.io/docs/concepts/components/prisma-client/handling-exceptions-and-errors
-      // https://lucia-auth.com/basics/error-handling/
-      if (
-        (e instanceof PrismaClientKnownRequestError && e.code === 'P2002') ||
-        (e instanceof LuciaError && e.message === 'AUTH_DUPLICATE_KEY_ID')
-      ) {
+      // null means the username is already taken (duplicate user or key)
+      if (!registered) {
         return fail(BAD_REQUEST, {
           form: {
             ...form,
@@ -78,6 +50,10 @@ export const actions: Actions = {
         });
       }
 
+      const session = await createSession(registered.userId);
+      locals.auth.setSession(session); // set session cookie
+    } catch {
+      // unexpected failure (e.g. DB error); registerUser already maps duplicates to null above
       return fail(INTERNAL_SERVER_ERROR, {
         form: {
           ...form,
diff --git a/src/routes/+layout.server.ts b/src/routes/+layout.server.ts
index 8b1f291ee..712255d78 100644
--- a/src/routes/+layout.server.ts
+++ b/src/routes/+layout.server.ts
@@ -4,8 +4,6 @@ import {
   TWITTER_HANDLE_NAME,
 } from '$lib/constants/product-info';
 
-// See:
-// https://lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit/
 import { Roles } from '$lib/types/user';
 
 const getBaseMetaTags = (url: URL) => {
diff --git a/src/routes/+page.server.ts b/src/routes/+page.server.ts
index d066a3b5e..670e22ab4 100644
--- a/src/routes/+page.server.ts
+++ b/src/routes/+page.server.ts
@@ -1,5 +1,3 @@
-// See:
-// https://lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit/
 import type { PageServerLoad } from './$types';
 import { Roles } from '$lib/types/user';
 
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 829adea84..db2b9a39f 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -1,5 +1,3 @@
-<!-- See: -->
-<!-- https://lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit/ -->
 <script lang="ts">
   import { Heading, Button, Carousel } from 'flowbite-svelte';
   import ArrowRight from '@lucide/svelte/icons/arrow-right';

From ffad3706eac4aad1d793240de307fa1f4681efa0 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 12:52:12 +0000
Subject: [PATCH 05/12] docs: update CONTRIBUTING.md to reflect lucia removal

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 CONTRIBUTING.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 31068f5a0..df11b70c6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -37,8 +37,8 @@
   - [Vitest](https://vitest.dev/): 単体テスト (ユーティリティ、コンポーネント)
   - [Playwright](https://playwright.dev/): e2eテスト
   - [Nock](https://github.com/nock/nock): API 統合テスト用の HTTP モック
-- 認証ライブラリ
-  - [Lucia](https://lucia-auth.com/)
+- 認証
+  - 自前実装（セッション管理・パスワードハッシュ）。旧 [Lucia](https://lucia-auth.com/) v2 のセッション / パスワード形式に準拠（互換性維持のため、cookie 名・ハッシュ形式は安易に変更しないこと）
 - ORM
   - [Prisma](https://www.prisma.io/)
 - バリデーション

From 447b617e28ef1d06f9e1fed44f530d9f3975f95b Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 13:22:48 +0000
Subject: [PATCH 06/12] chore: clean up remaining lucia references and add
 removal plan doc

Updates stale "Lucia" wording in e2e comments, drops the removed
@lucia-auth/adapter-prisma package from vite's test.deps.exclude, and
aligns seed.ts's key id casing with credentials.ts's buildKeyId
(toLowerCase, not toLocaleLowerCase). Adds the lucia removal plan doc.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 e2e/problems_cache.spec.ts | 6 +++---
 prisma/seed.ts             | 2 +-
 vite.config.ts             | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/e2e/problems_cache.spec.ts b/e2e/problems_cache.spec.ts
index de61c5c9f..1c28c9b4d 100644
--- a/e2e/problems_cache.spec.ts
+++ b/e2e/problems_cache.spec.ts
@@ -19,9 +19,9 @@ test.describe('anonymous /problems response', () => {
     expect(headers['cache-control']).toContain('stale-while-revalidate=600');
 
     // set-cookie makes a response ineligible for CDN caching.
-    // Lucia must not attach a session cookie to anonymous requests.
-    // If this assertion fails after a Lucia upgrade, verify it does not
-    // set cookies on unauthenticated requests.
+    // The auth layer must not attach a session cookie to anonymous requests.
+    // If this assertion fails, verify the session handling does not set cookies
+    // on unauthenticated requests.
     expect(headers['set-cookie']).toBeUndefined();
   });
 });
diff --git a/prisma/seed.ts b/prisma/seed.ts
index f94de65c7..40e3dbba9 100755
--- a/prisma/seed.ts
+++ b/prisma/seed.ts
@@ -133,7 +133,7 @@ async function addUser(
 
   await keyFactory.create({
     user: { connect: currentUser },
-    id: 'username:' + user.name.toLocaleLowerCase(),
+    id: 'username:' + user.name.toLowerCase(),
     hashed_password: hashed_password,
   });
 }
diff --git a/vite.config.ts b/vite.config.ts
index f1c220a99..0d77361b3 100755
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -5,7 +5,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   plugins: [tailwindcss(), sveltekit()],
   optimizeDeps: {
-    exclude: ['@prisma/client', '@lucia-auth/adapter-prisma'],
+    exclude: ['@prisma/client'],
   },
   test: {
     include: [

From a5ada6e777c26e9ade77494302cc3f350c7660e2 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 13:27:56 +0000
Subject: [PATCH 07/12] fix(server): handle concurrent session deletion during
 idle renewal

validateSession's renewal update could race with a concurrent logout
deleting the same row between findUnique and update, surfacing an
unhandled P2025 as a 500. Treat that case as an expired/gone session
instead.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 src/lib/server/session.test.ts | 18 ++++++++++++++++++
 src/lib/server/session.ts      | 24 +++++++++++++++++-------
 2 files changed, 35 insertions(+), 7 deletions(-)

diff --git a/src/lib/server/session.test.ts b/src/lib/server/session.test.ts
index 7f2ff9eee..09ad8679c 100644
--- a/src/lib/server/session.test.ts
+++ b/src/lib/server/session.test.ts
@@ -148,6 +148,24 @@ describe('validateSession', () => {
 
       expect(mockDb.session.update).toHaveBeenCalledOnce();
     });
+
+    test('returns null when the row is deleted concurrently during extension (P2025)', async () => {
+      // race: another request (logout / account deletion) deletes the row between findUnique and update
+      mockFindUnique(buildSessionRow(NOW - 1000, NOW + IDLE_PERIOD_MS));
+      mockDb.session.update.mockRejectedValue(
+        buildPrismaError('P2025', 'Record to update not found.'),
+      );
+
+      expect(await validateSession(SESSION_ID)).toBeNull();
+    });
+
+    test('re-throws update errors other than P2025', async () => {
+      mockFindUnique(buildSessionRow(NOW - 1000, NOW + IDLE_PERIOD_MS));
+      const error = buildPrismaError('P2003', 'Foreign key constraint failed.');
+      mockDb.session.update.mockRejectedValue(error);
+
+      await expect(validateSession(SESSION_ID)).rejects.toBe(error);
+    });
   });
 
   describe('dead session (now > idle_expires)', () => {
diff --git a/src/lib/server/session.ts b/src/lib/server/session.ts
index a85910661..d84b315c1 100644
--- a/src/lib/server/session.ts
+++ b/src/lib/server/session.ts
@@ -55,13 +55,23 @@ export const validateSession = async (sessionId: string): Promise<ValidatedSessi
     // idle state: extend expirations keeping the same id (no rotation, cookie untouched)
     const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(now);
 
-    await client.session.update({
-      where: { id: sessionId },
-      data: {
-        active_expires: activePeriodExpiresAt.getTime(),
-        idle_expires: idlePeriodExpiresAt.getTime(),
-      },
-    });
+    try {
+      await client.session.update({
+        where: { id: sessionId },
+        data: {
+          active_expires: activePeriodExpiresAt.getTime(),
+          idle_expires: idlePeriodExpiresAt.getTime(),
+        },
+      });
+    } catch (error) {
+      // P2025: the row was deleted concurrently (e.g. logout) between findUnique and update.
+      // Treat the session as gone (unauthenticated) instead of surfacing a 500.
+      if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
+        return null;
+      }
+
+      throw error;
+    }
   }
 
   return {

From ea4bc3d9e3194244e969126d1a27bbe09b209c87 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 13:28:32 +0000
Subject: [PATCH 08/12] docs(dev-notes): add remove-lucia-v2 plan and survey

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../2026-07-05/remove-lucia-v2/plan.md        | 510 ++++++++++++++++++
 .../2026-07-05/remove-lucia-v2/survey.md      | 230 ++++++++
 2 files changed, 740 insertions(+)
 create mode 100644 docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
 create mode 100644 docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md

diff --git a/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md b/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
new file mode 100644
index 000000000..d46a55de8
--- /dev/null
+++ b/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
@@ -0,0 +1,510 @@
+# lucia v2 剥がし: 実装計画
+
+> **For agentic workers:** 実装開始にはユーザーの明示的な同意が必要(計画承認 ≠ 実装開始)。実装時は superpowers:executing-plans または superpowers:subagent-driven-development を使用し、チェックボックスで進捗を管理すること。
+
+**Goal:** EOL の `lucia@2.7.7` + `@lucia-auth/adapter-prisma@3.0.2` を、DB マイグレーションゼロ・既存パスワード/ログイン中セッション完全互換で自前実装に置換する。
+
+**Issue:** [#3855](https://github.com/AtCoder-NoviSteps/AtCoderNoviSteps/issues/3855)(#682 から参照) / **ブランチ:** `#3855`(作成済み) / **PR:** 1 本(フェーズ = コミット単位)
+
+**調査・設計判断・却下代替案:** [survey.md](./survey.md) 参照(本計画は survey の設計方針 10 項目を前提とする。重複記載しない)
+
+---
+
+## 本計画での追加決定(survey からの差分)
+
+| 項目                                    | 決定                                                                                           | 理由                                                                                                                                                               |
+| --------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `validateSession` のクエリ数            | `include: { user: true }` の **1 クエリに統合**(現行 adapter は 2 クエリ)                      | 返す値は同一で挙動不変。全リクエストのホットパスで DB 1 往復削減。survey で「任意の最適化」と評価済み                                                              |
+| 新規モジュールのテスト配置              | **co-located**(`src/lib/server/password.test.ts` 等)                                           | vite.config は対応済み。`src/test/` は「existing tests (phase transition)」で新規追加は避ける方向                                                                  |
+| signup / login のドメインロジック置き場 | ルート直書きではなく **`src/features/auth/services/credentials.ts`** を新設                    | survey Phase 4 は「ルートで `prisma.$transaction`」としていたが、プロジェクトルール(prisma-db.md「ルートハンドラに直接 Prisma 禁止・CRUD はサービス層」)に従い修正 |
+| cookie 生成の置き場                     | `SESSION_COOKIE_NAME` は session.ts、cookie の set/delete は auth.ts の `createAuthRequest` 内 | session.ts を framework 非依存(cookies API を持ち込まない)に保つ                                                                                                   |
+| 乱数ユーティリティ                      | `src/lib/server/random.ts` を新設                                                              | salt(16 字)/ user ID(15 字)/ session ID(40 字)の 3 箇所で共用                                                                                                      |
+
+## 互換性仕様(実装が参照する正確な値・node_modules 実読で確定)
+
+- **乱数**: アルファベット `abcdefghijklmnopqrstuvwxyz1234567890`(36 字)。salt 16 字 / user ID 15 字 / session ID 40 字
+- **パスワード**: `s2:{salt}:{hash}`。入力を `normalize('NFKC')` → scrypt(N=16384, r=16, p=1, dkLen=64)→ hex。比較は定数時間(**長さ不一致は事前チェックで false**)。`s2:` 以外の形式(2 パート・`$2a` 等)は一律 false。`node:crypto` の scrypt は **`maxmem: 64 * 1024 * 1024` を明示**(既定 32MiB に抵触)
+- **期限判定**: 期限切れは `now > expires` のとき(**等値はまだ有効**)。active: `now <= active_expires` / idle: `active_expires < now <= idle_expires` / dead: `now > idle_expires`
+- **期限値**: 作成・延長とも `active_expires = now + 24h`、`idle_expires = active_expires + 14d`(ms epoch)。idle 延長は**同一 ID のまま UPDATE のみ**。dead でも**行削除しない**
+- **cookie**: 名前 `auth_session` / 値 = セッション ID / `path: '/'`, `httpOnly: true`, `sameSite: 'lax'`, `secure: !dev`, `expires: idlePeriodExpiresAt`。無効時はクリア、idle 延長時は**触らない**
+- **BigInt**: `active_expires` / `idle_expires` の読み取りは `bigint` → 比較前に `Number()` 変換。書き込みは Number のままで可(現行 adapter と同じ)
+
+## ファイルマップ
+
+| 種別   | パス                                                                | 内容                                                                                                                                                                       |
+| ------ | ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 新規   | `src/lib/server/random.ts` + `random.test.ts`                       | `generateRandomString(length)`                                                                                                                                             |
+| 新規   | `src/lib/server/password.ts` + `password.test.ts`                   | `hashPassword` / `verifyPassword`(**相対 import のみ** — seed から tsx で使うため `$lib` alias 禁止)                                                                       |
+| 新規   | `src/lib/server/session.ts` + `session.test.ts`                     | `createSession` / `validateSession` / `invalidateSession` / `SESSION_COOKIE_NAME`                                                                                          |
+| 変更   | `src/lib/server/auth.ts` + `auth.test.ts`(新規)                     | `createAuthRequest` 追加(Phase 3)→ lucia 初期化削除(Phase 4)                                                                                                               |
+| 変更   | `src/hooks.server.ts`                                               | `auth.handleRequest` → `createAuthRequest`                                                                                                                                 |
+| 変更   | `src/app.d.ts`                                                      | `Locals.auth` 型差し替え(Phase 3)→ `Lucia` namespace 削除(Phase 4)                                                                                                         |
+| 新規   | `src/features/auth/services/credentials.ts` + `credentials.test.ts` | `registerUser` / `authenticateUser`                                                                                                                                        |
+| 変更   | `src/routes/(auth)/signup/+page.server.ts`                          | `auth.createUser` → `registerUser` + `createSession`                                                                                                                       |
+| 変更   | `src/routes/(auth)/login/+page.server.ts`                           | `auth.useKey` → `authenticateUser` + `createSession`                                                                                                                       |
+| 変更   | `src/routes/(auth)/logout/+page.server.ts`                          | `auth.invalidateSession` → `invalidateSession`                                                                                                                             |
+| 変更   | `prisma/seed.ts`                                                    | `generateLuciaPasswordHash` → 相対 import の `hashPassword`                                                                                                                |
+| 変更   | `package.json`                                                      | `lucia` / `@lucia-auth/adapter-prisma` 削除                                                                                                                                |
+| 変更   | コメント棚卸し                                                      | `database.ts` / `hooks.server.ts` / `+page.server.ts` / `+layout.server.ts` / `+page.svelte` / auth ルート 3 本 / `atcoder_verification.test.ts` / `.claude/rules/auth.md` |
+| 無変更 | `src/routes/users/edit/+page.server.ts`                             | `locals.auth.setSession(null)` は新 API と同形状(確認のみ)                                                                                                                 |
+| 無変更 | `prisma/schema.prisma` / migrations                                 | **DB 変更ゼロ**                                                                                                                                                            |
+
+各フェーズ完了時に `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 全通過を確認してからコミットする。
+
+---
+
+## Phase 1: 互換性フィクスチャ + 乱数 + パスワードユーティリティ(TDD)
+
+**互換性の錨。lucia が残っているうちにフィクスチャを固定する。**
+
+**フィクスチャ選定の前提**: `authSchema`(`src/lib/zod/schema.ts`)のパスワード規則は半角英数字のみ(`[a-zA-Z\d]{8,128}` + 大小英字・数字各 1 以上)で、**初回実装(2023-09)から不変**(git 確認済み)。signup / login とも同スキーマで検証してから crypto 層に到達するため、**非 ASCII パスワードは prod のハッシュにも `verifyPassword` への入力にも存在し得ない**。よってフィクスチャは (a) スキーマ準拠の実在パスワード = 互換性の錨、(b) スキーマ外の全角ベクタ = `normalize('NFKC')` の実装漏れ検出専用(ASCII ベクタは normalize の有無で結果が変わらないため、これが唯一の検出手段)の 2 系統のみとする。
+
+- [ ] 1-1. lucia でフィクスチャ生成(実装前に必ず実行):
+
+```bash
+pnpm exec tsx -e '
+import { generateLuciaPasswordHash } from "lucia/utils";
+// "Ch0kuda1": seed の実パスワード(スキーマ準拠・prod 互換の錨)
+// "AtC0derN0viSteps": スキーマ準拠のもう 1 本(単発の偶然一致を排除)
+// "Ｃｈ０ｋｕｄａ１": スキーマ外。NFKC 正規化の実装漏れ検出専用ガード
+const passwords = ["Ch0kuda1", "AtC0derN0viSteps", "Ｃｈ０ｋｕｄａ１"];
+for (const p of passwords) {
+  console.log(JSON.stringify(p), await generateLuciaPasswordHash(p));
+}
+'
+```
+
+出力された 3 ハッシュを `password.test.ts` の fixture 定数として貼り付ける(生成コマンドと上記の選定理由をコメントで残す)。`Ｃｈ０ｋｕｄａ１`(全角)は NFKC 正規化で `Ch0kuda1` と同一になるため、**半角入力で検証が通ること**が normalize 実装の存在証明になる(アプリの入力ドメイン外だが、lucia アルゴリズム等価性の担保として意図的に含める)。
+
+- [ ] 1-2. `src/lib/server/random.test.ts` を書く(失敗を確認):
+  - 指定長の文字列を返す(16 / 15 / 40)
+  - 全文字が `[a-z0-9]`(36 字アルファベット)に含まれる(1000 回生成で検証)
+  - 呼び出しごとに異なる値(衝突しない)
+- [ ] 1-3. `src/lib/server/random.ts` を実装 → テスト通過:
+
+```typescript
+const DEFAULT_ALPHABET = 'abcdefghijklmnopqrstuvwxyz1234567890';
+
+/** lucia v2 compatible random string (used for salts, user ids, and session ids). */
+export const generateRandomString = (length: number, alphabet = DEFAULT_ALPHABET): string => {
+  const randomUint32Values = new Uint32Array(length);
+  crypto.getRandomValues(randomUint32Values);
+  const u32Max = 0xffffffff;
+  let result = '';
+
+  for (let i = 0; i < length; i++) {
+    const rand = randomUint32Values[i] / (u32Max + 1);
+    result += alphabet[Math.floor(alphabet.length * rand)];
+  }
+
+  return result;
+};
+```
+
+- [ ] 1-4. `src/lib/server/password.test.ts` を書く(失敗を確認)。ケース:
+  - 自己ラウンドトリップ: `hashPassword` → `verifyPassword` が true / 生成形式が `^s2:[a-z0-9]{16}:[0-9a-f]{128}$`
+  - **lucia フィクスチャ 3 本の検証一致**(`verifyPassword('Ch0kuda1', fixture)` === true 等。定数時間比較が 128 字 hex 全一致を要求するため、これがバイト互換の機械的証明になる)
+  - NFKC ガード(入力ドメイン外・normalize 実装漏れ検出専用): 全角生成フィクスチャに半角入力 `Ch0kuda1` で true(逆も true)
+  - 拒否系(全て false・throw しない。stored hash の形式契約 = survey 設計方針 9-10 の固定): パスワード不一致 / 旧 2 パート形式 `{salt}:{hash}` / bcrypt `$2a$...` / 空文字ハッシュ / 部品数不正 `s2:saltonly` / 空パスワード vs 正規ハッシュ
+- [ ] 1-5. `src/lib/server/password.ts` を実装 → テスト通過。**`./random` 相対 import + node 組み込みのみ**(`$lib` alias を使うと Phase 4 の seed(tsx 実行)が壊れる):
+
+```typescript
+import { scrypt, timingSafeEqual } from 'node:crypto';
+import { promisify } from 'node:util';
+
+import { generateRandomString } from './random';
+
+const scryptAsync = promisify(scrypt);
+
+// lucia v2 compatible parameters. 128 * N * r = 32MiB hits the default maxmem, so raise it to 64MiB.
+const SCRYPT_OPTIONS = { N: 16384, r: 16, p: 1, maxmem: 64 * 1024 * 1024 };
+const KEY_LENGTH = 64;
+const SALT_LENGTH = 16;
+const HASH_VERSION = 's2';
+
+/** Generates a lucia v2 compatible password hash: `s2:{salt}:{hash}`. */
+export const hashPassword = async (password: string): Promise<string> => {
+  const salt = generateRandomString(SALT_LENGTH);
+  const hash = await computeHash(password, salt);
+
+  return `${HASH_VERSION}:${salt}:${hash}`;
+};
+
+/** Verifies a password against a stored hash. Unknown formats (v1 two-part, bcrypt $2a) return false. */
+export const verifyPassword = async (password: string, storedHash: string): Promise<boolean> => {
+  const parts = storedHash.split(':');
+
+  if (parts.length !== 3 || parts[0] !== HASH_VERSION) {
+    return false;
+  }
+
+  const [, salt, expectedHash] = parts;
+  const actualHash = await computeHash(password, salt);
+  const expectedBuffer = Buffer.from(expectedHash, 'hex');
+  const actualBuffer = Buffer.from(actualHash, 'hex');
+
+  // timingSafeEqual throws on length mismatch, so check length first
+  if (expectedBuffer.length !== actualBuffer.length) {
+    return false;
+  }
+
+  return timingSafeEqual(expectedBuffer, actualBuffer);
+};
+
+const computeHash = async (password: string, salt: string): Promise<string> => {
+  // NFKC-normalize so visually identical unicode inputs hash identically (lucia v2 behavior)
+  const derivedKey = (await scryptAsync(
+    password.normalize('NFKC'),
+    salt,
+    KEY_LENGTH,
+    SCRYPT_OPTIONS,
+  )) as Buffer;
+
+  return derivedKey.toString('hex');
+};
+```
+
+- [ ] 1-6. `pnpm test:unit` / `pnpm check` / `pnpm lint` 通過を確認
+- [ ] 1-7. コミット: `feat(auth): add lucia v2 compatible password and random utilities`
+
+## Phase 2: セッションサービス(TDD)
+
+- [ ] 2-1. `src/lib/server/session.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')`(default export をモック)+ `vi.useFakeTimers()` + `vi.setSystemTime`。**モックの `active_expires` / `idle_expires` は必ず `BigInt` で返す**(Number を返すモックでは変換漏れを検出できない)。ケース:
+  - `createSession`: 40 字 `[a-z0-9]` の ID / `active_expires = now + 24h`・`idle_expires = now + 24h + 14d` で create される / 戻り値 `{ sessionId, idlePeriodExpiresAt }`
+  - `validateSession` active(`now <= active_expires`): update / delete が**呼ばれない**、`{ sessionId, user: { userId, username, role } }` を返す
+  - `validateSession` idle(`active_expires < now <= idle_expires`): **同一 ID** に update(新期限値をアサート)、delete は呼ばれない
+  - `validateSession` dead(`now > idle_expires`): null 返し、**update / delete とも呼ばれない**(行は残す)
+  - `validateSession` 境界値: `now === active_expires` は active(書き込みなし)/ `now === idle_expires` は idle(延長)— lucia の `>` 比較の再現
+  - `validateSession` 行なし: null
+  - `findUnique` が `include: { user: true }` で呼ばれる(1 クエリ)
+  - `invalidateSession`: delete が呼ばれる / **P2025 は握りつぶす**(`PrismaClientKnownRequestError` を mockRejectedValue)/ P2025 以外は re-throw
+- [ ] 2-2. `src/lib/server/session.ts` を実装 → テスト通過:
+
+```typescript
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
+import type { Roles } from '@prisma/client';
+
+import client from '$lib/server/database';
+import { generateRandomString } from '$lib/server/random';
+
+// lucia v2 defaults: active 24h, idle +14d
+const ACTIVE_PERIOD_MS = 1000 * 60 * 60 * 24;
+const IDLE_PERIOD_MS = 1000 * 60 * 60 * 24 * 14;
+const SESSION_ID_LENGTH = 40;
+
+export const SESSION_COOKIE_NAME = 'auth_session';
+
+export type SessionCookieData = { sessionId: string; idlePeriodExpiresAt: Date };
+
+export type ValidatedSession = {
+  sessionId: string;
+  user: { userId: string; username: string; role: Roles };
+};
+
+const computeExpirations = (now: number) => {
+  const activePeriodExpiresAt = new Date(now + ACTIVE_PERIOD_MS);
+  const idlePeriodExpiresAt = new Date(activePeriodExpiresAt.getTime() + IDLE_PERIOD_MS);
+
+  return { activePeriodExpiresAt, idlePeriodExpiresAt };
+};
+
+export const createSession = async (userId: string): Promise<SessionCookieData> => {
+  const sessionId = generateRandomString(SESSION_ID_LENGTH);
+  const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(Date.now());
+
+  await client.session.create({
+    data: {
+      id: sessionId,
+      user_id: userId,
+      active_expires: activePeriodExpiresAt.getTime(),
+      idle_expires: idlePeriodExpiresAt.getTime(),
+    },
+  });
+
+  return { sessionId, idlePeriodExpiresAt };
+};
+
+export const validateSession = async (sessionId: string): Promise<ValidatedSession | null> => {
+  const session = await client.session.findUnique({
+    where: { id: sessionId },
+    include: { user: true },
+  });
+
+  if (!session) {
+    return null;
+  }
+
+  const now = Date.now();
+
+  // lucia v2: expired only when now is strictly past the deadline; dead rows are kept (no cleanup)
+  if (now > Number(session.idle_expires)) {
+    return null;
+  }
+
+  if (now > Number(session.active_expires)) {
+    // idle state: extend expirations keeping the same id (no rotation, cookie untouched)
+    const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(now);
+
+    await client.session.update({
+      where: { id: sessionId },
+      data: {
+        active_expires: activePeriodExpiresAt.getTime(),
+        idle_expires: idlePeriodExpiresAt.getTime(),
+      },
+    });
+  }
+
+  return {
+    sessionId: session.id,
+    user: {
+      userId: session.user.id,
+      username: session.user.username,
+      role: session.user.role,
+    },
+  };
+};
+
+export const invalidateSession = async (sessionId: string): Promise<void> => {
+  try {
+    await client.session.delete({ where: { id: sessionId } });
+  } catch (error) {
+    // P2025 (row already gone): swallow for logout idempotency, same as the lucia adapter
+    if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
+      return;
+    }
+
+    throw error;
+  }
+};
+```
+
+- [ ] 2-3. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
+- [ ] 2-4. コミット: `feat(auth): add self-managed session service compatible with lucia v2`
+
+## Phase 3: locals.auth 互換オブジェクト + hooks + 型
+
+**注意: lucia の `auth` export と `app.d.ts` の `Lucia` namespace はこのフェーズでは削除しない**(auth ルート 3 本が Phase 4 まで使用。消すと本フェーズで `pnpm check` / `build` が落ちる)。
+
+- [ ] 3-1. `src/lib/server/auth.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/session')` + `vi.mock('$lib/server/database')`(Phase 3 時点では auth.ts が lucia 初期化のため database を import している)+ cookies(get/set/delete)をスパイにしたモック event。ケース:
+  - cookie なし: null を返し `validateSession` は呼ばれない
+  - 有効セッション: セッションを返す / **2 回目の `validate()` で `validateSession` が再度呼ばれない**(リクエスト内キャッシュ)
+  - 無効セッション(cookie あり): null を返し `cookies.delete(SESSION_COOKIE_NAME, { path: '/' })` が呼ばれる
+  - `setSession(session)`: `cookies.set` が正確な属性(`path: '/'`, `httpOnly: true`, `sameSite: 'lax'`, `secure: !dev`, `expires: idlePeriodExpiresAt`)で呼ばれる
+  - `setSession(null)`: `cookies.delete` が呼ばれる
+  - `setSession` 後の `validate()` はキャッシュを使わず再検証する
+- [ ] 3-2. `src/lib/server/auth.ts` に **追加**(lucia 初期化はそのまま残す)→ テスト通過:
+
+```typescript
+import type { RequestEvent } from '@sveltejs/kit';
+import { dev } from '$app/environment';
+
+import {
+  SESSION_COOKIE_NAME,
+  validateSession,
+  type SessionCookieData,
+  type ValidatedSession,
+} from '$lib/server/session';
+
+export type AuthRequest = {
+  validate: () => Promise<ValidatedSession | null>;
+  setSession: (session: SessionCookieData | null) => void;
+};
+
+export const createAuthRequest = (event: RequestEvent): AuthRequest => {
+  let validatePromise: Promise<ValidatedSession | null> | null = null;
+
+  const setSessionCookie = (session: SessionCookieData | null): void => {
+    if (session) {
+      event.cookies.set(SESSION_COOKIE_NAME, session.sessionId, {
+        path: '/',
+        httpOnly: true,
+        sameSite: 'lax',
+        secure: !dev,
+        expires: session.idlePeriodExpiresAt,
+      });
+    } else {
+      event.cookies.delete(SESSION_COOKIE_NAME, { path: '/' });
+    }
+  };
+
+  return {
+    validate: () => {
+      // request-scoped cache: hooks and route guards both call validate() on every request
+      if (validatePromise) {
+        return validatePromise;
+      }
+
+      validatePromise = (async () => {
+        const sessionId = event.cookies.get(SESSION_COOKIE_NAME);
+
+        if (!sessionId) {
+          return null;
+        }
+
+        const session = await validateSession(sessionId);
+
+        if (!session) {
+          setSessionCookie(null); // clear the stale cookie (lucia v2 behavior)
+        }
+
+        return session;
+      })();
+
+      return validatePromise;
+    },
+    setSession: (session) => {
+      validatePromise = null;
+      setSessionCookie(session);
+    },
+  };
+};
+```
+
+設計メモ: idle 延長は `validateSession` 内で完結し `setSession` を経由しないため、cookie は自動的に「延長時は触らない」(v2 と同挙動)。lucia の `storedSessionId === sessionId` early-return ガードは呼び出し経路上不要になるため実装しない。
+
+- [ ] 3-3. `src/hooks.server.ts`: `event.locals.auth = auth.handleRequest(event);` → `event.locals.auth = createAuthRequest(event);` に差し替え(import も変更。以降のロジック不変)。lucia-auth.com へのコメントリンクをこのタイミングで削除
+- [ ] 3-4. `src/app.d.ts`: `auth: import('lucia').AuthRequest;` → `auth: import('$lib/server/auth').AuthRequest;`。**`Lucia` namespace と `/// <reference types="lucia" />` は残す**
+- [ ] 3-5. `pnpm test:unit`(サービス層ガード・ルートのテストが**無変更で**通ることを確認)/ `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
+- [ ] 3-6. コミット: `feat(auth): replace lucia AuthRequest with self-managed createAuthRequest`
+
+## Phase 4: 認証ルート置換 + seed 置換 + 依存削除
+
+- [ ] 4-1. `src/features/auth/services/credentials.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')` + `vi.mock('$lib/server/password')`。ケース:
+  - `registerUser` 成功: `$transaction` で user(15 字 `[a-z0-9]` ID)+ key(`id: 'username:{小文字}'`, `hashed_password`)が作成され `{ userId }` を返す
+  - `registerUser` P2002(username / key.id どちら由来でも): null を返す
+  - `registerUser` その他のエラー: re-throw
+  - `authenticateUser` 成功: `key.findUnique({ where: { id: 'username:{小文字}' } })` → `verifyPassword` true → `{ userId }`
+  - `authenticateUser` key なし / `hashed_password` が null / パスワード不一致: いずれも null(現行の「ユーザー不在とパスワード誤りを同一応答」仕様の維持)
+- [ ] 4-2. `src/features/auth/services/credentials.ts` を実装 → テスト通過:
+
+```typescript
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
+
+import client from '$lib/server/database';
+import { hashPassword, verifyPassword } from '$lib/server/password';
+import { generateRandomString } from '$lib/server/random';
+
+const USER_ID_LENGTH = 15; // lucia v2 createUser default
+
+const buildKeyId = (username: string): string => `username:${username.toLowerCase()}`;
+
+/** Creates a user with a password key. Returns null when the username is already taken. */
+export const registerUser = async (
+  username: string,
+  password: string,
+): Promise<{ userId: string } | null> => {
+  const userId = generateRandomString(USER_ID_LENGTH);
+  const hashedPassword = await hashPassword(password);
+
+  try {
+    await client.$transaction([
+      client.user.create({ data: { id: userId, username } }),
+      client.key.create({
+        data: { id: buildKeyId(username), user_id: userId, hashed_password: hashedPassword },
+      }),
+    ]);
+  } catch (error) {
+    // P2002 on user.username or key.id both mean the username is taken
+    if (error instanceof PrismaClientKnownRequestError && error.code === 'P2002') {
+      return null;
+    }
+
+    throw error;
+  }
+
+  return { userId };
+};
+
+/** Returns the user id for valid credentials, or null (missing user and wrong password are indistinguishable). */
+export const authenticateUser = async (
+  username: string,
+  password: string,
+): Promise<{ userId: string } | null> => {
+  const key = await client.key.findUnique({ where: { id: buildKeyId(username) } });
+
+  if (!key || key.hashed_password === null) {
+    return null;
+  }
+
+  const isValid = await verifyPassword(password, key.hashed_password);
+
+  return isValid ? { userId: key.user_id } : null;
+};
+```
+
+- [ ] 4-3. `signup/+page.server.ts` を置換: `auth.createUser` + `LuciaError` 分岐 → `registerUser`。null なら現行の重複メッセージで 400(**文言は一字一句維持** — E2E が文言依存)、成功なら `createSession(userId)` → `locals.auth.setSession(session)`。予期しないエラーは catch で現行の 500 メッセージ。lucia import(`LuciaError` / `auth`)を削除
+- [ ] 4-4. `login/+page.server.ts` を置換: `auth.useKey` + `LuciaError` 分岐 → `authenticateUser`。null なら現行のログイン失敗メッセージで 400、成功なら `createSession` + `setSession`。エラー文言・応答の同一性を維持。lucia import を削除
+- [ ] 4-5. `logout/+page.server.ts` を置換: `auth.invalidateSession(session.sessionId)` → `invalidateSession(session.sessionId)`($lib/server/session から import)。`setSession(null)` はそのまま
+- [ ] 4-6. `users/edit/+page.server.ts`: 変更不要を確認(`locals.auth.setSession(null)` のみ = cookie クリア。session 行は `onDelete: Cascade` で削除される)
+- [ ] 4-7. `prisma/seed.ts`: `import { generateLuciaPasswordHash } from 'lucia/utils'` → `import { hashPassword } from '../src/lib/server/password'`(相対パス)。`pnpm db:seed` が tsx で通ることを確認
+- [ ] 4-8. `src/lib/server/auth.ts` から lucia 初期化(`lucia()` / `Auth` 型 / lucia import 3 本)を削除。`src/app.d.ts` から `Lucia` namespace と `/// <reference types="lucia" />` を削除
+- [ ] 4-9. `package.json` から `lucia` / `@lucia-auth/adapter-prisma` を削除 → `pnpm install`
+- [ ] 4-10. 残存参照の棚卸し: `grep -rin lucia src prisma docs .claude --include='*.{ts,svelte,md}'` で確認し、以下を更新:
+  - `src/lib/server/database.ts` / `src/routes/+page.server.ts` / `+page.svelte` / `+layout.server.ts` / auth ルート 3 本のコメント内 lucia-auth.com リンクを削除
+  - `src/features/account/services/atcoder_verification.test.ts:45` のコメント(「Lucia が UUID を生成」は不正確)→ 「auth service generates a 15-char random id」に修正
+  - `.claude/rules/auth.md` の「Lucia v2」セクションを自前実装の説明(`src/lib/server/session.ts` / `password.ts` / `createAuthRequest`)に書き換え
+  - `src/routes/forgot_password/+page.svelte` の lucia example リンクは**残す**(将来のパスワードリセット設計の参考リンクであり本移行と無関係)
+- [ ] 4-11. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
+- [ ] 4-12. コミット: `feat(auth): replace lucia in auth routes and seed, drop lucia dependencies`
+
+## Phase 5: 検証 + 仕上げ
+
+- [ ] 5-1. `pnpm test:e2e` 全通過(signin / redirect_after_login / user_edit / votes / workbook 系。※signup の E2E は存在しないため 5-3 の実機確認で担保)
+- [ ] 5-2. **セッション継続の実機確認**: Phase 3 直前のコミットを checkout → `pnpm dev` → シードユーザー(`guest` / `Ch0kuda1`)でログイン → サーバ停止 → ブランチ先頭を checkout → `pnpm dev` → リロードで**ログイン状態が維持**されること(cookie 名・値が devtools で不変であること)
+- [ ] 5-3. **パスワード互換 + signup の実機確認**: 移行後コードでシードユーザーの再ログイン成功 / 新規ユーザー作成 → ログアウト → 再ログイン成功 / 既存ユーザー名で signup → 重複メッセージ(400)/ 誤パスワードでログイン失敗(400)/ 二重ログアウトで 500 にならないこと
+- [ ] 5-4. `pnpm format` → 差分があればコミットに含める
+- [ ] 5-5. `coderabbit review --plain` を実行し、critical / high / potential_issue(medium)の所見を本ファイル末尾の `## CodeRabbit Findings` に記録(**修正はユーザー判断。無断で直さない**)
+- [ ] 5-6. AGENTS.md の必須リファクタサイクル: 新規の学び・残タスクを本ファイルに追記 → `/session-close`
+
+## リスクと対策
+
+survey.md の「リスクと対策」表を参照。本計画で追加されるリスクは 1 点:
+
+- **サービス層化(credentials.ts)に伴う挙動差**: ルート直書きからの移し替えでエラー変換の粒度が変わる(LuciaError → null 返し)。対策: Phase 4 のユニットテストで「重複 = null」「その他 = re-throw」の境界を固定し、ルート側の応答コード・文言を現行と突き合わせて確認(5-3)
+
+## ロールバック
+
+DB 変更ゼロのため、本番障害時は直前リリースの再デプロイのみで完全に戻る。ローカルはフェーズ単位のコミットを revert。
+
+## CodeRabbit Findings
+
+`coderabbit review --plain`(v0.6.5、branch `#3855` = staging から 5 commits)実行。全 36 findings のうち大半は本移行と無関係の未追跡ファイル(`docs/ui-mock/`・他 dev-notes)に対するもの。以下は**本ブランチが変更したファイル**に限定して抽出(重大度は CodeRabbit の Major/Minor 表記)。**修正は未実施。ユーザー判断待ち。**
+
+**⚠️ 追記(lucia@2.7.7 実ソース検証後)**: 下記 A-1 / A-3 について、npm から `lucia@2.7.7` の tarball を取得し `dist/auth/request.js`・`dist/auth/index.js` を実読して裏取りした。結論は各項に反映済み。CodeRabbit の A-1 指摘は **lucia v2 挙動の理解として誤り**だった(初版の私の記録も CodeRabbit を過信しており誤り。訂正済み)。
+
+### A. ソース（Major）
+
+- **[auth.ts:51-57] idle 延長時に Cookie の `expires` を再発行しない** → **v2 と完全一致。互換性の観点では問題なし(CodeRabbit 指摘は v2 挙動の誤認)**
+  - 実ソース検証: lucia v2 `validateSession`(`dist/auth/index.js`)は idle 時 **同一 session ID のまま** `updateSession` で期限延長し `fresh: true` を返す。`AuthRequest.validate`(`dist/auth/request.js`)は `session.fresh` で `maybeSetSession(session)` を呼ぶが、`setSession`/`setSessionCookie` は先頭に `if (this.storedSessionId === sessionId) return;` ガードを持つ。idle 延長は ID 不変のためこのガードで **必ず early-return し、Cookie は再発行されない**。→ 本実装(idle 時 cookie を触らない)は **byte-for-byte で v2 同挙動**。survey.md line 99 / 175 の記述が正しい。
+  - ただし v2 由来の **既知の制約**は残る: Cookie の expires は発行時固定のため、継続利用でも **ログインから最長 ~15 日で再ログインが必要**(cookie 層でのスライディング更新がない)。これは survey.md line 175 が「残課題」として明記済み。修正は v2 互換性を意図的に破る強化であり、本移行のスコープ外。**回帰でもバグでもない**。
+
+- **[session.ts:58-64] 並行ログアウト時の P2025 で 500** → ✅ **修正済み(ロバスト性優先)** — idle 延長の `update` を try/catch し、`P2025`(findUnique〜update 間で行が削除された競合)は `null`(未認証)を返す。それ以外は re-throw。テスト 2 本追加(P2025→null / P2003→re-throw)。
+  - 📝 補足: lucia v2 も `adapter.updateSession` を try/catch せず同じ競合を持っていた(回帰ではない)。本修正は v2 挙動からの意図的な改善(500 回避)。
+
+- **[credentials.ts:45-49] 無効認証のタイミング差（Security）** → **v2 と一致。本移行による回帰なし。ユーザー名列挙の水準は不変**
+  - 実ソース検証: lucia v2 `useKey`(`dist/auth/index.js`)も `getKey` が無ければ **ハッシュ検証せず即 `AUTH_INVALID_KEY_ID` を throw**。既存ユーザーの誤パスワード時のみハッシュを実行する。→ 本実装の分岐は v2 と同一で、タイミング側チャネルは **移行前から存在**していた。
+  - 📝 さらに signup は重複ユーザー名で専用メッセージ(400)を返すため、**ユーザー名列挙は元から signup 経由で可能**。したがって本移行でセキュリティ水準は変わらない。定数時間化(ダミーハッシュ)は独立した強化であり、旧コードにも等しく当てはまる任意対応。
+
+- **[credentials.test.ts:128-143] 上記に対応するテスト（Security）** — 「欠損キー時に `verifyPassword` を呼ばない」= v2 と同じ挙動を固定するテスト。定数時間化を採用する場合のみ期待値変更が必要。上記 credentials.ts:45 と一体で判断。
+
+### B. ソース（Minor）→ ✅ 修正済み
+
+- **[credentials.ts:9 / seed.ts] `toLowerCase()` と `toLocaleLowerCase()` の不一致** — seed 側を `toLowerCase()` に統一(本セッションで修正)。
+  - 📝 補足: username は zod `authSchema` で `[a-zA-Z\d]`(ASCII のみ)に制限済みのため元々実害はなかったが、一貫性のため統一。
+
+### C. 計画・ドキュメント
+
+- **[plan.md:442-446] `grep --include='*.{ts,svelte,md}'` の brace 展開が効かない** — grep は `{ts,svelte,md}` を展開しない。実際の 4-10 実行では `--include` を使わず全拡張子を対象にしたためこの点での取りこぼしは無かったが、計画記載のコマンドは誤り(かつ 4-10 は `src prisma .claude/rules` に対象を絞ったため D の漏れが発生)。`rg -g` 複数指定か拡張子ごとの `--include` に修正。
+
+### D. 5-5 スイープで追加検出した residual lucia 参照 → ✅ 修正済み（4-10 の grep が `src prisma .claude/rules` のみを対象にしていた漏れ）
+
+- **[vite.config.ts:8]** `optimizeDeps.exclude` の死んだ `@lucia-auth/adapter-prisma` を削除。
+- **[e2e/problems_cache.spec.ts:22-24]** stale な Lucia コメントを self-managed auth の説明に修正。
+- (root の CONTRIBUTING.md は本セッションで対応済み)
+
+### 対応方針メモ（実ソース検証後）
+
+- **A-1 / A-3 は対応不要**(v2 と byte 互換。CodeRabbit の指摘は v2 挙動の誤認)。A-1 の「~15 日で再ログイン」は survey.md 既知の残課題で、直すなら v2 互換を意図的に破る別タスク。
+- **B / D は修正済み**。
+- **A-2(P2025)** は ✅ **修正済み**(ロバスト性優先で P2025→null 化)。
+- C(grep コマンド)は計画ドキュメントの軽微な訂正。nitpick 相当は PR CI に委譲。
diff --git a/docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md b/docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md
new file mode 100644
index 000000000..fb8387749
--- /dev/null
+++ b/docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md
@@ -0,0 +1,230 @@
+# lucia v2 剥がし: 影響範囲調査と互換性維持移行計画
+
+> **For agentic workers:** 実装開始にはユーザーの明示的な同意が必要(計画承認 ≠ 実装開始)。実装時は superpowers:executing-plans または superpowers:subagent-driven-development を使用。
+
+**Goal:** EOL となった `lucia@2.7.7` + `@lucia-auth/adapter-prisma@3.0.2` を、**DB マイグレーションゼロ・既存パスワード/ログイン中セッション完全互換**で自前セッション実装に置換し、Prisma 本体アップデート(5.22 固定の解消)のブロッカーを除去する。
+
+**関連:** [lucia deprecation 告知](https://github.com/lucia-auth/lucia/discussions/1707) / [#682](https://github.com/AtCoder-NoviSteps/AtCoderNoviSteps/issues/682)(lucia は対象外と明記 → 本作業は**新規 issue を作成**して #682 から参照) / 移行参考例: [the-road-to-next-app#9](https://github.com/rwieruch/the-road-to-next-app/pull/9)
+
+---
+
+## 調査結果(影響範囲)
+
+lucia API の呼び出しは**実質 7 ファイルに集約**されており、影響範囲は限定的。
+
+| ファイル                                   | 使用 API                                                                                              |
+| ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
+| `src/lib/server/auth.ts`                   | `lucia()` 初期化(prisma adapter, sveltekit middleware, getUserAttributes)                             |
+| `src/hooks.server.ts`                      | `auth.handleRequest(event)` → `locals.auth` / `validate()`                                            |
+| `src/app.d.ts`                             | `Locals.auth: import('lucia').AuthRequest`、`Lucia` namespace                                         |
+| `src/routes/(auth)/signup/+page.server.ts` | `createUser` / `createSession` / `setSession` / `LuciaError`(AUTH_DUPLICATE_KEY_ID)                   |
+| `src/routes/(auth)/login/+page.server.ts`  | `useKey` / `createSession` / `setSession` / `LuciaError`(AUTH_INVALID_KEY_ID / AUTH_INVALID_PASSWORD) |
+| `src/routes/(auth)/logout/+page.server.ts` | `invalidateSession` / `setSession(null)`                                                              |
+| `src/routes/users/edit/+page.server.ts`    | `setSession(null)`(アカウント削除後)                                                                  |
+| `prisma/seed.ts`                           | `generateLuciaPasswordHash`(`lucia/utils`)                                                            |
+
+- `locals.auth.validate()` の呼び出しは約 25 ファイルにあるが、大半は `getLoggedInUser` / `validateAdminAccess` 等のサービス層ガード(`src/features/auth/services/`)経由。**locals API の形状を維持すればこれらは全て無変更**
+- 未使用 API: `deleteUser` / `updateKeyPassword` / `createKey` / `invalidateAllUserSessions` / OAuth / 2FA / パスワードリセット → 再実装不要
+- アカウント削除は `db.user.delete` + `onDelete: Cascade` で lucia 非依存(変更不要)
+- ユニットテストは lucia 本体でなく `locals.auth.validate` をモック → **形状維持ならテストも無変更**
+- E2E(signin / redirect_after_login / user_edit 等)はシードユーザーで実ログイン → そのまま回帰安全網になる
+
+### prisma adapter の実装調査(2026-07-11 追記)
+
+`@lucia-auth/adapter-prisma@3.0.2`(`dist/prisma.js`、実質 230 行)を全読し、lucia core の呼び出しと突き合わせた結果、**adapter は隠れたロジックゼロの薄い CRUD ラッパーで安全に剥がせる**と確定。暗号処理・状態・独自スキーマ要求は一切なし。
+
+全 15 メソッド中、本アプリのホットパスに乗るのは 7 つのみ:
+
+| アプリの呼び出し箇所                         | lucia core 経由で呼ばれる adapter メソッド                          |
+| -------------------------------------------- | ------------------------------------------------------------------- |
+| `locals.auth.validate()`(hooks 全リクエスト) | `getSession` → `getUser`(2 クエリ)、idle 延長時のみ `updateSession` |
+| signup `createUser`                          | `setUser(user, key)` — `$transaction` で user + key 同時 create     |
+| signup/login `createSession`                 | `getUser` + `setSession`(並列)                                      |
+| login `useKey`                               | `getKey`                                                            |
+| logout `invalidateSession`                   | `deleteSession`                                                     |
+
+未使用: `deleteUser` / `updateUser` / `getSessionsByUserId` / `deleteSessionsByUserId` / `setKey` / `deleteKey` / `deleteKeysByUserId` / `updateKey` / `getKeysByUserId`。
+
+adapter が担う「CRUD 以外」の責務は 3 つだけで、全て自前実装で吸収可能:
+
+1. **BigInt → Number 変換**(`transformPrismaSession`): schema の `active_expires` / `idle_expires` は `BigInt` 型。Prisma の読み取りは `bigint` を返すため、自前 `validateSession` でも `Number()` 変換してから期限比較が必要。書き込みは lucia core が Number をそのまま渡しており(prod で実証済み)、ms epoch は 2^53 未満なので精度問題なし
+2. **Prisma エラー → LuciaError 変換**:
+   - `P2002`(setUser)→ `AUTH_DUPLICATE_KEY_ID`。ただし変換条件は ``message.includes('`id`')`` の部分一致のみで、`username` 列の P2002 は生の Prisma エラーのまま素通し。signup ルートは既に両方を catch している(`signup/+page.server.ts:68-69`)ため、Phase 4 の「P2002 ハンドリングに一本化」で完全にカバーされる
+   - `P2025`(deleteSession)→ **握りつぶし**。⚠️ logout ルートは catch なしで `invalidateSession` を呼ぶため、二重ログアウト等で行が既に無い場合、自前実装でも P2025 を握りつぶさないと 500 になる(Phase 2 に反映済み)
+   - `P2003`(setSession)→ `AUTH_INVALID_USER_ID`。signup では user 作成直後にセッション作成するため実質発生不能。再現不要
+3. **モデル名・列名のハードコード**(`client["user"]` / `user_id` / `hashed_password` 等): schema が snake_case に固定されている根本原因。剥がせば命名自由になるが、本移行は互換最優先でスキーマ無変更
+
+補足: adapter は `getSessionAndUser`(session + user の 1 クエリ取得)を未実装のため、現行 validate はコールドパスで毎回 2 クエリ。自前実装で `include: { user: true }` にすれば 1 クエリに減らせる(挙動不変の最適化・任意)。
+
+## 互換性判定: 完全互換で剥がし可能(根拠は実測値)
+
+node_modules の lucia 2.7.7 実装を直読して以下を確定した。全て標準 `node:crypto` で再現可能(デプロイ先は Vercel serverless = Node ランタイム)。
+
+### パスワードハッシュ(`lucia/dist/utils/crypto.js`)
+
+- 形式: `s2:{salt}:{hash}`。salt = 16 文字 `[a-z0-9]`、hash = scrypt(**N=16384, r=16, p=1, dkLen=64**) の hex
+- 入力は **NFKC 正規化**(`password.normalize('NFKC')`)、比較は constant-time(lucia は手書き XOR ループ。`timingSafeEqual` で置換する場合は**長さ不一致で throw するため事前の長さチェック必須**)
+- 旧 2 パート形式 `{salt}:{hash}`(lucia v1 由来、r=8)フォールバック: **実装しない**。git 履歴確認(ffe902d8、2023-09-20 の初回導入コミット)で本プロジェクトは lucia `^2.6.0` から開始しており、v1 形式ハッシュは prod に存在し得ない(2026-07-05 レビューで削除決定)
+- bcrypt 形式(`$2a` 始まり、v2 beta 期のみ)は lucia が `AUTH_OUTDATED_PASSWORD` を throw(login では 500 応答)するが、自前実装では**未知形式として false を返す**(400 のログイン失敗に統一。互換の唯一の意図的逸脱、実害なし)
+- ⚠️ `node:crypto` の `scrypt` は要 `maxmem` 指定(128×N×r = 32MiB が既定上限に抵触。**64MiB を明示**)
+
+### セッション(`lucia/dist/auth/index.js`, `request.js`)
+
+- ID: 40 文字ランダム `[a-z0-9]`、`session` テーブルに**平文**保存(トークンハッシュ化なし)
+- 期限: `active_expires` = 発行 +24h、`idle_expires` = active +14 日(ms epoch, BigInt)
+- 検証: idle 超過 → 無効(**行削除なし**・cookie クリアのみ。期限切れ行は DB に残留する — v2 は v1 の autoDatabaseCleanup を廃止済み)/ active 内 → 有効(書き込みなし)/ idle 内 → **同一 ID のまま期限を延長**(UPDATE のみ。ID ローテーション無し)。延長時、`AuthRequest.setSession` は同一 ID のため early return し **cookie は再セットされない** → cookie の Expires は発行時の idle_expires で固定(= 継続利用でも発行から最長 15 日でブラウザ側 cookie が消え再ログイン)。**この 2 点とも v2 の実挙動どおり再現する**(2026-07-05 レビューで決定。行削除・cookie 延長は挙動変更となるため見送り、残課題へ)
+- リクエスト内キャッシュ: `validate()` は同一リクエストで 2 回目以降キャッシュを返す(hooks + ルートの二重呼び出しで DB を 2 度叩かない)
+
+### Cookie(`lucia/dist/auth/cookie.js`)
+
+- 名前 `auth_session` / 値 = セッション ID / `path=/`, `httpOnly`, `sameSite=lax`, `secure`(PROD のみ) / `expires` = idle_expires(永続 cookie)
+
+### その他
+
+- ユーザー ID: `createUser` が 15 文字ランダム `[a-z0-9]` を生成 → 同形式を踏襲
+- Key: `key.id` = `username:{小文字化ユーザー名}`、`hashed_password` 列 → テーブル・形式そのまま使用
+- CSRF: lucia の origin チェックは SvelteKit 標準の `checkOrigin`(既定有効・無効化されていないことを確認済み)が同等機能を提供 → 削除して安全。補強確認: `+server.ts` に POST/PUT/PATCH/DELETE はゼロ(全て GET)のため、保護対象はフォーム action のみ = checkOrigin の守備範囲に完全に収まる
+
+**結論: schema.prisma・migration・cookie 名・ハッシュ形式・セッション行を一切変えずに剥がせる。デプロイしてもユーザーは誰もログアウトされず、パスワードもそのまま通る。**
+
+## 設計方針(ユーザー決定事項)
+
+1. **移行先 = 自前セッション実装・スキーマ無変更**(lucia 作者公認の後継パターン。`sv create` の「lucia」テンプレートもライブラリ非依存の同方式)
+2. **既存ログイン中セッションは完全維持**(v2 の active/idle 二重期限セマンティクスを再現)
+3. **scrypt 互換を継続**(新規ユーザーも `s2:` 形式。追加依存ゼロ、DB 内ハッシュ形式が単一)
+4. **Prisma 本体アップデートは別 PR**(本移行は「挙動不変で剥がす」に限定)
+5. **locals API は同形状を維持**(`locals.auth = { validate, setSession }`。呼び出し側約 25 ファイル+テストは無変更。validate 戻り値の実利用フィールドは `sessionId` / `user.userId` / `user.username` / `user.role` のみと grep で全数確認済み)
+6. **新規 issue を作成**して管理(#682 から参照)
+7. **期限切れセッション行は削除しない**(v2 実挙動どおり。掃除は残課題)
+8. **idle 延長時に cookie は再セットしない**(v2 実挙動どおり。cookie 期限延長は残課題)
+9. **旧 2 パート形式フォールバックは実装しない**(v2.6 開始のため対象ハッシュが存在し得ない。`s2:` のみ検証、未知形式は false)
+10. **bcrypt `$2a` は false 返し**(500 → 400 の意図的逸脱として明記)
+
+### oslo / @oslojs の採用評価(不採用)
+
+- `oslo` パッケージ本体は **2025-01 に deprecated**(後継は `@oslojs/*`)
+- `@oslojs/crypto`(1.0.1, 最終更新 2024-09)は sha/hmac/ecdsa 等の「ランタイム非依存プリミティブ」で、**scrypt を含まない** → 本件のハッシュ互換には使えない
+- `@oslojs` の存在意義は `node:crypto` が無いエッジランタイム向け。本プロジェクトは Node ランタイムなので `node:crypto`(scrypt / randomBytes / timingSafeEqual / sha256 全部入り)で完結
+- sv テンプレートが `@oslojs/crypto` を使うのは「セッショントークンを sha256 でハッシュ化して保存する」新方式のため。本件は lucia v2 の平文 ID 形式を維持するので不要
+- → **依存ゼロが本移行の目的に最も整合**。将来トークンハッシュ化等の強化をする場合も `node:crypto` で足りる
+
+## 却下した代替案
+
+1. **新スキーマへ刷新**(the-road-to-next#9 の完全踏襲: token ハッシュ保存 + key 廃止): DB 破壊的変更+データ移行が必要で「互換最優先」に反する。終着点の綺麗さより安全性
+2. **別ライブラリ(better-auth / Auth.js)**: 独自スキーマ強制で破壊的変更が不可避。username+password のみの要件に過剰。「ライブラリ作者都合の EOL」リスクを再び抱える
+3. **argon2 への lazy 移行**: 二重検証パス+依存追加+移行状態の混在。scrypt は OWASP 許容関数であり現時点で YAGNI(将来必要なら検証側の形式分岐に追加するだけ)
+4. **locals.session/user 式への再設計を同時実施**: ルート約 25 ファイル+テストの大量修正が最高リスク PR に混入する。必要なら後続の独立リファクタとして起案
+
+## フェーズ計画
+
+各フェーズで `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 全通過を維持。1 ブランチ 1 PR(フェーズはコミット単位)。
+
+### Phase 1: 互換性フィクスチャ + パスワードユーティリティ(TDD)
+
+- **lucia が残っているうちに** `generateLuciaPasswordHash` で既知パスワード(シードの `Ch0kuda1` 等)のハッシュを生成し、テストフィクスチャとして固定(互換性の錨)
+- `src/lib/server/password.ts`(新規): `hashPassword` / `verifyPassword`。`s2:` 形式再現(NFKC / N=16384, r=16, p=1, dkLen=64 / maxmem 64MiB / `timingSafeEqual`(長さ不一致は事前チェックで false))。**`s2:` 以外の形式(旧 2 パート・bcrypt `$2a` 含む)は一律 false**
+- テスト: 自己ラウンドトリップ + **lucia 生成フィクスチャの検証一致** + 不一致/形式不正(2 パート・`$2a`・空文字)の拒否
+
+### Phase 2: セッションサービス(TDD)
+
+- `src/lib/server/session.ts`(新規): `createSession(userId)` / `validateSession(sessionId)` / `invalidateSession(sessionId)` + cookie 生成ヘルパー。v2 セマンティクス(24h/14d、idle 内は同一 ID で延長=UPDATE のみ、**idle 超過は null 返しのみで行削除しない**)と cookie 属性を上記実測値どおり実装
+- **BigInt 変換**: `active_expires` / `idle_expires` は Prisma が `bigint` で返すため、期限比較の前に `Number()` 変換必須(書き込みは Number のままで可 — 現行 adapter と同じ)
+- **`invalidateSession` は P2025 を握りつぶす**(logout の冪等性。現行 adapter の deleteSession と同挙動。logout ルートは catch なしで呼ぶため、握りつぶさないと二重ログアウトで 500)
+- テスト: `vi.mock('$lib/server/database')` で active(書き込みなし)/ idle 延長(UPDATE のみ・DELETE なし)/ 期限切れ(null 返し・**DELETE が呼ばれないことを検証**)/ 行なし の 4 状態を網羅。時刻は `vi.useFakeTimers`。加えて **invalidateSession の P2025 握りつぶし**と **BigInt を返す mock での期限比較**(Number を返す mock だと変換漏れを見逃す)を含める
+
+### Phase 3: locals.auth 互換オブジェクト + hooks + 型
+
+- `src/lib/server/auth.ts` に `createAuthRequest(event)` を**追加**: `{ validate, setSession }` を返す(validate はリクエスト内キャッシュ付き)。**lucia の `auth` export はこの時点では削除しない**(signup / login / logout ルートが Phase 4 まで使用。消すと本フェーズのコミットで `pnpm check` / `build` が落ちる)
+- 返すセッション形状は現行利用箇所に合わせ `{ sessionId, user: { userId, username, role } }` を維持。**無効セッション時は cookie クリア、idle 延長時は cookie を触らない**(v2 の `storedSessionId === sessionId` ガードと同挙動)
+- Phase 3〜4 の間は lucia の `createSession` が返す Session オブジェクトが自前 `setSession` に渡るため、cookie 生成は `sessionId` と `idlePeriodExpiresAt`(Date)のみ参照する(Phase 2 の自前セッションにも同名フィールドを持たせて Phase 4 の差し替えを無変更にする)
+- `src/hooks.server.ts`: `auth.handleRequest(event)` → `createAuthRequest(event)` に差し替え(以降のロジック不変)
+- `src/app.d.ts`: `Locals.auth` の型のみ `import('lucia').AuthRequest` → 自前型に置換。**`Lucia` namespace と `/// <reference types="lucia" />` は削除しない**(lucia インスタンスの型解決に必要。削除は Phase 4)
+- サービス層ガード・ルート約 25 ファイルは**無変更**であることを test:unit で確認
+
+### Phase 4: 認証ルート置換 + seed 置換 + 依存削除
+
+- signup: `auth.createUser` → `prisma.$transaction`(user + key 作成。userId は 15 文字 `[a-z0-9]`、key.id は `username:{小文字}`)。重複は既存の P2002 ハンドリングに一本化(`LuciaError` 分岐削除)。**ユーザー向けメッセージは現行文言を厳守**(E2E が文言依存)
+- login: `auth.useKey` → key 取得 + `verifyPassword`。エラーメッセージ・挙動(キー無し/パスワード不一致を同一応答にしている現行仕様)を維持
+- logout: `invalidateSession`(行削除)+ cookie クリアヘルパーへ置換
+- users/edit(アカウント削除): **cookie クリアのみ**(session 行は `user.delete` の `onDelete: Cascade` で消えるため `invalidateSession` は呼ばない — 調査結果表のとおり現行も `setSession(null)` のみ)
+- `prisma/seed.ts`: `generateLuciaPasswordHash` → 自前 `hashPassword`(seed からの import は `$lib` alias 不可のため相対パス。tsx 実行で通ることを確認)
+- `src/lib/server/auth.ts` の lucia 初期化 export 削除、`src/app.d.ts` の `Lucia` namespace / `/// <reference types="lucia" />` 削除(Phase 3 から繰り延べた分)
+- `package.json` から `lucia` / `@lucia-auth/adapter-prisma` 削除 → `pnpm install` → リポジトリ全体 grep で残存 import ゼロ確認(コメント内の言及も棚卸し)
+
+### Phase 5: 検証 + 仕上げ
+
+- `pnpm test:e2e` 全通過(signin / signup 系 / redirect_after_login / user_edit / votes / workbooks)
+- **セッション継続の実機確認**: 移行前コードで dev 起動 → ログイン → cookie 保持のまま移行後コードで再起動 → ログイン状態が維持されること
+- **パスワード互換の実機確認**: 移行前に作成したユーザー(シード含む)で移行後にログイン成功すること
+- `pnpm format` → `coderabbit review --plain` → critical/high/medium 所見を本ファイル `## CodeRabbit Findings` に記録(修正はユーザー判断)
+
+## リスクと対策
+
+| リスク                                                  | 対策                                                                                                               |
+| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| scrypt パラメータの再現ミス → 全ユーザーログイン不能    | Phase 1 の lucia 生成フィクスチャ照合テストで機械的に担保。maxmem 未指定エラーはテストで即検出                     |
+| セッション期限判定の再現ミス → 意図しない一斉ログアウト | Phase 2 で 4 状態を fake timer で網羅。Phase 5 で実機のセッション継続確認                                          |
+| CSRF 保護の喪失                                         | SvelteKit `checkOrigin`(既定有効)が同等機能を提供済みであることを確認済み。無効化しないこと                        |
+| 本番デプロイ後の障害                                    | DB 変更ゼロのため**ロールバック = 直前リリースへの再デプロイのみ**で完結(切り戻し容易性が本方式の最大の利点)       |
+| ~~prod に lucia v1 時代の旧形式ハッシュが残存~~         | **解消済み**: git 履歴(ffe902d8)で lucia `^2.6.0` からの開始を確認 → v1 形式は存在し得ず、フォールバック自体を削除 |
+
+## 残課題(本移行に含めない後続作業)
+
+- Prisma 5.22 → 6/7 アップデート(本移行完了で解禁。別 issue / 別 PR)
+- **期限切れセッション行の掃除**(v2 は削除しないため現行 prod にも死に行が蓄積中。定期削除 or 検証時削除を別途検討)
+- **idle 延長時の cookie 期限延長**(v2 は再セットしないため継続利用でも発行から最長 15 日で要再ログイン。延長するとセッション寿命が実質無期限化するためトレードオフ判断が必要)
+- `locals.session` / `locals.user` 式への locals API 再設計(任意。full-codebase-refactoring 計画との整合を取って起案)
+- `key` テーブル廃止・`user` へのパスワード列統合等のスキーマ整理(任意。互換要件が解けた後)
+- パスワードリセット機能(別 PR。下記補遺参照)
+
+## QA: 理解確認と批判的レビュー(2026-07-15 追記)
+
+ソース根拠: `lucia/dist/auth/index.js` / `lucia/dist/utils/crypto.js` / `@lucia-auth/adapter-prisma/dist/prisma.js`。
+
+- **呼び出しチェーン**: `app → lucia core(公開 API)→ adapter(CRUD)` で正しい。例: `auth.createUser` は core 側で userId 生成(15 文字)+パスワードハッシュ化を行い、`adapter.setUser(user, key)` に渡す(`auth/index.js:160-180`)。通常の利用では意識不要だが、剥がしでは **core のロジックと adapter の CRUD の両方**を自前実装が吸収する(Phase 4 で 2 層を Prisma 直呼びに畳む)
+- **メソッド名の差異(createUser vs setUser)**: 名前衝突の回避ではなく**レイヤ分離**。公開 API はドメイン語彙(create / use / invalidate)、adapter インターフェースは全 DB アダプタ共通のストレージ語彙(get / set / update / delete)。公開 1 メソッドが adapter 1〜n 呼び出しに対応する(createSession → getUser + setSession)
+- **salt**: パスワードごとに生成するランダム値(16 文字 `[a-z0-9]`)で、ハッシュ入力に混ぜる。目的は「同じパスワードでも毎回異なるハッシュ」にしてレインボーテーブル(事前計算)攻撃を無効化すること。**秘密ではない**ため `s2:{salt}:{hash}` に平文で埋め込まれる。ユーザー間の一意性保証は不要(十分ランダムであればよい)
+- **暗号化ではなくハッシュ(一方向)**: 復号は存在しない。検証は「入力パスワード + 保存済み salt で scrypt を再計算 → 保存済みハッシュと定数時間比較」
+- **NFKC 正規化**: 同じ見た目の文字列でも Unicode 表現が複数あり得る(全角/半角、合成/分解済み文字)ため、バイト列を一意化してからハッシュする。実務上の含意は 1 つ: **自前 verify でも必ず正規化する**(漏れると非 ASCII パスワードが照合不能になる)。**(2026-07-15 補正)** `authSchema` のパスワード規則は初回実装(2023-09)から半角英数字限定のため、非 ASCII パスワードは prod のハッシュにも login 入力にも存在し得ない(signup / login とも zod 検証後に crypto 層へ到達)。normalize は実害回避ではなく**アルゴリズム忠実性(lucia 等価)の担保**として維持する
+- **scrypt パラメータ**: scrypt は決定的アルゴリズム(RFC 7914)。同一入力 + 同一 (N, r, p, dkLen) なら出力は**バイト単位で一致する(「可能性が高い」ではなく保証)**。リスクは自前実装側のミス(node:crypto のパラメータ名対応、maxmem、hex 変換、NFKC 漏れ)に集中し、Phase 1 のフィクスチャテストはそれを機械検出する仕組み。担保するのは「冪等性」ではなく**互換性(等価性)**。salt がランダムなため生成ハッシュ同士の直接比較はできず、「lucia 生成ハッシュを自前 verify が受理する」形で検証する(固定 salt の hex 直接比較テストを足すとさらに強い)
+- **セッション ID の平文保存**: ID は 40 文字ランダム(約 207 bit)のサーバ生成トークンで、低エントロピーかつ使い回されるパスワードとは脅威モデルが異なるため平文でも許容範囲。残るリスクは「DB 読み取り漏洩 → セッション乗っ取り」で、新方式(sv テンプレート等)が sha256 保存するのはこのため。ただし**トークンハッシュ化は後からでも無停止で移行可能**(既存行を一括ハッシュ化しても cookie は平文トークンのままで、検証側がハッシュして照合すればよい)。「互換性のため永久に仕方ない」ではなく「本移行では挙動不変を優先して見送り」が正確
+- **bcrypt `$2a`**: 本プロジェクト導入前の仕様ではなく、**lucia 自身の v2 beta 期の遺物**(crypto.js に `TODO: remove in v3` 付きでガードが残る)。本プロジェクトは stable `^2.6.0` 開始のため該当ハッシュは存在し得ない。「対処しておく」というより、自前 verify の自然な設計(未知形式 → false)が到達不能ケースを覆うだけ。500 → 400 は唯一の意図的逸脱として記録済み
+- **フェーズ理解の補正**: Phase 2 は新規サービスの作成 + テストのみで**配線はしない**(validate 系の切替は Phase 3、create/invalidate 系は Phase 4)。lucia と adapter の依存削除は Phase 4 の完了後ではなく **Phase 4 の内部タスク**。Phase 5 が E2E + 実機確認(セッション継続・パスワード互換)
+- **⚠️ Phase 3 の順序問題(レビュー指摘・要修正)**: Phase 3 時点では signup / login / logout ルートがまだ lucia の `auth` インスタンス(`createUser` / `useKey` 等)を使うため、`auth.ts` の lucia 初期化 export と `app.d.ts` の `Lucia` namespace は **Phase 4 完了まで削除できない**(消すと Phase 3 コミットで `pnpm check` / `build` が落ちる)。対応案: (i) Phase 3 は `createAuthRequest` を**追加**して hooks を差し替えるに留め、lucia export と型削除を Phase 4 に移す(推奨)、(ii) Phase 3+4 を 1 コミットに統合 → **(i) を採用しフェーズ本文修正済み(2026-07-15)**
+
+---
+
+## 補遺: パスワードリセット機能の追加容易性(批判的レビュー・2026-07-05)
+
+**問い:** lucia 剥がしが成功すれば、パスワードリセット追加は「比較的容易」と考えてよいか?
+
+**回答: 半分正しい。** 剥がしは前提整備として有効だが、リセットの主障壁はもともと lucia ではない。難所は「本人確認チャネル」と「トークン基盤+レート制限」で、これらは剥がし後も丸ごと残る。ただし本プロジェクト固有の事情(後述の AtCoder 連携チャネル)を使う設計なら「比較的容易」評価は妥当。
+
+### 剥がしが効く部分(正の効果)
+
+- Phase 1-2 で作る `hashPassword` / セッションサービスがそのまま再利用でき、パスワード更新は `key.hashed_password` の UPDATE 1 本 + 全セッション削除(`deleteMany`)1 本で完結する
+- EOL ライブラリの上に新機能を積まずに済む(先に剥がす順序判断自体は正しい)
+- トークンテーブル等のスキーマ設計が lucia アダプタの命名制約から自由になる(schema.prisma の方針どおり新規モデルは camelCase で書ける)
+
+### 剥がしでは解決しない部分(過大評価に注意)
+
+1. **本人確認チャネルが存在しない(最大の障壁)**: `User` に email 列がない(username + password のみ)。標準的なリセットフロー(メールでトークン送付)は前提から成立しない。なお公平を期すと、lucia v2 にも `updateKeyPassword` / `invalidateAllUserSessions` はあったため「lucia が邪魔でリセットを作れなかった」わけではない — 障壁は当初からチャネル側にある
+2. **トークン基盤は自作が必要**: 公式学習リソース(lucia-auth.com)と [The Copenhagen Book](https://thecopenhagenbook.com/password-reset) の要件 — 十分なエントロピーの乱数トークン、**保存前に SHA-256 でハッシュ化**、有効期限 ~1h(最大 24h)、使い捨て(成功時削除)、**リセット成功時に当該ユーザーの全セッション無効化**、トークンを含むパスへの `Referrer-Policy: strict-origin`、ユーザー列挙を防ぐ曖昧な応答文言。新テーブル + migration が必要(追加のみで非破壊)
+3. **レート制限基盤が現状ない**: Copenhagen Book は発行エンドポイントへの厳格なレート制限を必須としている。Vercel serverless ではインメモリ制限が効かないため、DB ベースの token bucket 等の新規実装になる
+
+### 本人確認チャネルの選択肢(実装コストの支配項)
+
+| 案                         | 概要                                                                                                                                                                                            | コスト     | 備考                                                                                                                                                                                                                                                                                         |
+| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| (a) email 基盤導入         | email 列(既存ユーザーは NULL)+ 確認フロー + 送信プロバイダ + 到達性運用                                                                                                                         | **大**     | 標準的だが基盤導入が本体。「比較的容易」ではない                                                                                                                                                                                                                                             |
+| (b) AtCoder 連携で本人確認 | 既存の `AtCoderAccount`(handle / isValidated / validationCode)検証機構を再利用し、**事前に検証済みの連携**がある場合のみ、AtCoder プロフィール等に新規コードを設置させて本人確認 → リセット許可 | **小〜中** | email 不要・本サービスの利用者特性に合致。制約: 未連携ユーザーは対象外。リスク: AtCoder アカウント侵害 = 本サービス乗っ取り(全セッション無効化とセットで許容範囲か要判断)。**必ず事前検証済み連携に限定**(リセット時に初回連携を許すと、handle を主張するだけで未連携アカウントを乗っ取れる) |
+| (c) 管理者手動リセット     | 現行の「X DM → アカウント移行」を「X DM → ワンタイムリセットリンク/仮パスワード発行(admin 画面)」に置換                                                                                         | **最小**   | 人手プロセスは残るが、移行(回答履歴の付け替え)より運用負荷が大幅に軽い。(b) の対象外ユーザーの受け皿としても機能                                                                                                                                                                             |
+
+現状の回復手段は「X 公式アカウントへ DM → 管理者がアカウント移行」(`forgot_password/+page.svelte`、`(admin)/account_transfer`)であり、ページには「パスワードリセット機能は開発中です」と明記済み。同ページは lucia 公式の [example-sveltekit-email-password-2fa](https://github.com/lucia-auth/example-sveltekit-email-password-2fa) を既にコメント参照している(= email 前提の案 (a) を想定した形跡)。
+
+### 結論
+
+- 「剥がし成功 → リセット容易」の因果は**部分的**。剥がしで得るのは再利用可能な password/session ユーティリティと負債の上積み回避であり、リセット固有の難所(チャネル・トークン・レート制限)は別途残る
+- チャネルに **(b) + (c) の併用**(検証済み連携ユーザーはセルフサービス、それ以外は管理者発行)を選ぶなら「比較的容易」は妥当: 新テーブル 1 つ + サービス層 + ルート 2 つ + 既存検証機構の再利用で収まり、email 基盤が不要
+- **(a) email 基盤を選ぶ場合、「容易」ではない**。email 導入自体が独立した中規模プロジェクト(スキーマ・確認フロー・プロバイダ選定・運用)になる
+- いずれの案でも着手は lucia 剥がし完了後(Phase 1-2 の成果物に依存)。チャネル選択はユーザー判断が必要な設計分岐点

From dde88f3bcb99403e5b2247e9a97dcb9345df1b66 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 13:52:44 +0000
Subject: [PATCH 09/12] docs(dev-notes): mark remove-lucia-v2 plan complete,
 record lessons and remaining tasks

Checks off all Phase 1-5 tasks and appends the mandatory refactor-cycle
notes: novel lessons (lucia v2 idle renewal doesn't reissue the cookie,
vendored-source verification via npm pack, brace-expansion pitfall in
grep --include, rules doc duplication) and remaining low-priority tasks
(cookie sliding expiry, timing-safe username enumeration, a doc typo).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../2026-07-05/remove-lucia-v2/plan.md        | 87 +++++++++++--------
 1 file changed, 52 insertions(+), 35 deletions(-)

diff --git a/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md b/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
index d46a55de8..33b51b7ba 100644
--- a/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
+++ b/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
@@ -59,7 +59,7 @@
 
 **フィクスチャ選定の前提**: `authSchema`(`src/lib/zod/schema.ts`)のパスワード規則は半角英数字のみ(`[a-zA-Z\d]{8,128}` + 大小英字・数字各 1 以上)で、**初回実装(2023-09)から不変**(git 確認済み)。signup / login とも同スキーマで検証してから crypto 層に到達するため、**非 ASCII パスワードは prod のハッシュにも `verifyPassword` への入力にも存在し得ない**。よってフィクスチャは (a) スキーマ準拠の実在パスワード = 互換性の錨、(b) スキーマ外の全角ベクタ = `normalize('NFKC')` の実装漏れ検出専用(ASCII ベクタは normalize の有無で結果が変わらないため、これが唯一の検出手段)の 2 系統のみとする。
 
-- [ ] 1-1. lucia でフィクスチャ生成(実装前に必ず実行):
+- [x] 1-1. lucia でフィクスチャ生成(実装前に必ず実行):
 
 ```bash
 pnpm exec tsx -e '
@@ -76,11 +76,11 @@ for (const p of passwords) {
 
 出力された 3 ハッシュを `password.test.ts` の fixture 定数として貼り付ける(生成コマンドと上記の選定理由をコメントで残す)。`Ｃｈ０ｋｕｄａ１`(全角)は NFKC 正規化で `Ch0kuda1` と同一になるため、**半角入力で検証が通ること**が normalize 実装の存在証明になる(アプリの入力ドメイン外だが、lucia アルゴリズム等価性の担保として意図的に含める)。
 
-- [ ] 1-2. `src/lib/server/random.test.ts` を書く(失敗を確認):
+- [x] 1-2. `src/lib/server/random.test.ts` を書く(失敗を確認):
   - 指定長の文字列を返す(16 / 15 / 40)
   - 全文字が `[a-z0-9]`(36 字アルファベット)に含まれる(1000 回生成で検証)
   - 呼び出しごとに異なる値(衝突しない)
-- [ ] 1-3. `src/lib/server/random.ts` を実装 → テスト通過:
+- [x] 1-3. `src/lib/server/random.ts` を実装 → テスト通過:
 
 ```typescript
 const DEFAULT_ALPHABET = 'abcdefghijklmnopqrstuvwxyz1234567890';
@@ -101,12 +101,12 @@ export const generateRandomString = (length: number, alphabet = DEFAULT_ALPHABET
 };
 ```
 
-- [ ] 1-4. `src/lib/server/password.test.ts` を書く(失敗を確認)。ケース:
+- [x] 1-4. `src/lib/server/password.test.ts` を書く(失敗を確認)。ケース:
   - 自己ラウンドトリップ: `hashPassword` → `verifyPassword` が true / 生成形式が `^s2:[a-z0-9]{16}:[0-9a-f]{128}$`
   - **lucia フィクスチャ 3 本の検証一致**(`verifyPassword('Ch0kuda1', fixture)` === true 等。定数時間比較が 128 字 hex 全一致を要求するため、これがバイト互換の機械的証明になる)
   - NFKC ガード(入力ドメイン外・normalize 実装漏れ検出専用): 全角生成フィクスチャに半角入力 `Ch0kuda1` で true(逆も true)
   - 拒否系(全て false・throw しない。stored hash の形式契約 = survey 設計方針 9-10 の固定): パスワード不一致 / 旧 2 パート形式 `{salt}:{hash}` / bcrypt `$2a$...` / 空文字ハッシュ / 部品数不正 `s2:saltonly` / 空パスワード vs 正規ハッシュ
-- [ ] 1-5. `src/lib/server/password.ts` を実装 → テスト通過。**`./random` 相対 import + node 組み込みのみ**(`$lib` alias を使うと Phase 4 の seed(tsx 実行)が壊れる):
+- [x] 1-5. `src/lib/server/password.ts` を実装 → テスト通過。**`./random` 相対 import + node 組み込みのみ**(`$lib` alias を使うと Phase 4 の seed(tsx 実行)が壊れる):
 
 ```typescript
 import { scrypt, timingSafeEqual } from 'node:crypto';
@@ -164,12 +164,12 @@ const computeHash = async (password: string, salt: string): Promise<string> => {
 };
 ```
 
-- [ ] 1-6. `pnpm test:unit` / `pnpm check` / `pnpm lint` 通過を確認
-- [ ] 1-7. コミット: `feat(auth): add lucia v2 compatible password and random utilities`
+- [x] 1-6. `pnpm test:unit` / `pnpm check` / `pnpm lint` 通過を確認
+- [x] 1-7. コミット: `feat(auth): add lucia v2 compatible password and random utilities`
 
 ## Phase 2: セッションサービス(TDD)
 
-- [ ] 2-1. `src/lib/server/session.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')`(default export をモック)+ `vi.useFakeTimers()` + `vi.setSystemTime`。**モックの `active_expires` / `idle_expires` は必ず `BigInt` で返す**(Number を返すモックでは変換漏れを検出できない)。ケース:
+- [x] 2-1. `src/lib/server/session.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')`(default export をモック)+ `vi.useFakeTimers()` + `vi.setSystemTime`。**モックの `active_expires` / `idle_expires` は必ず `BigInt` で返す**(Number を返すモックでは変換漏れを検出できない)。ケース:
   - `createSession`: 40 字 `[a-z0-9]` の ID / `active_expires = now + 24h`・`idle_expires = now + 24h + 14d` で create される / 戻り値 `{ sessionId, idlePeriodExpiresAt }`
   - `validateSession` active(`now <= active_expires`): update / delete が**呼ばれない**、`{ sessionId, user: { userId, username, role } }` を返す
   - `validateSession` idle(`active_expires < now <= idle_expires`): **同一 ID** に update(新期限値をアサート)、delete は呼ばれない
@@ -178,7 +178,7 @@ const computeHash = async (password: string, salt: string): Promise<string> => {
   - `validateSession` 行なし: null
   - `findUnique` が `include: { user: true }` で呼ばれる(1 クエリ)
   - `invalidateSession`: delete が呼ばれる / **P2025 は握りつぶす**(`PrismaClientKnownRequestError` を mockRejectedValue)/ P2025 以外は re-throw
-- [ ] 2-2. `src/lib/server/session.ts` を実装 → テスト通過:
+- [x] 2-2. `src/lib/server/session.ts` を実装 → テスト通過:
 
 ```typescript
 import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
@@ -278,21 +278,21 @@ export const invalidateSession = async (sessionId: string): Promise<void> => {
 };
 ```
 
-- [ ] 2-3. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
-- [ ] 2-4. コミット: `feat(auth): add self-managed session service compatible with lucia v2`
+- [x] 2-3. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
+- [x] 2-4. コミット: `feat(auth): add self-managed session service compatible with lucia v2`
 
 ## Phase 3: locals.auth 互換オブジェクト + hooks + 型
 
 **注意: lucia の `auth` export と `app.d.ts` の `Lucia` namespace はこのフェーズでは削除しない**(auth ルート 3 本が Phase 4 まで使用。消すと本フェーズで `pnpm check` / `build` が落ちる)。
 
-- [ ] 3-1. `src/lib/server/auth.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/session')` + `vi.mock('$lib/server/database')`(Phase 3 時点では auth.ts が lucia 初期化のため database を import している)+ cookies(get/set/delete)をスパイにしたモック event。ケース:
+- [x] 3-1. `src/lib/server/auth.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/session')` + `vi.mock('$lib/server/database')`(Phase 3 時点では auth.ts が lucia 初期化のため database を import している)+ cookies(get/set/delete)をスパイにしたモック event。ケース:
   - cookie なし: null を返し `validateSession` は呼ばれない
   - 有効セッション: セッションを返す / **2 回目の `validate()` で `validateSession` が再度呼ばれない**(リクエスト内キャッシュ)
   - 無効セッション(cookie あり): null を返し `cookies.delete(SESSION_COOKIE_NAME, { path: '/' })` が呼ばれる
   - `setSession(session)`: `cookies.set` が正確な属性(`path: '/'`, `httpOnly: true`, `sameSite: 'lax'`, `secure: !dev`, `expires: idlePeriodExpiresAt`)で呼ばれる
   - `setSession(null)`: `cookies.delete` が呼ばれる
   - `setSession` 後の `validate()` はキャッシュを使わず再検証する
-- [ ] 3-2. `src/lib/server/auth.ts` に **追加**(lucia 初期化はそのまま残す)→ テスト通過:
+- [x] 3-2. `src/lib/server/auth.ts` に **追加**(lucia 初期化はそのまま残す)→ テスト通過:
 
 ```typescript
 import type { RequestEvent } from '@sveltejs/kit';
@@ -362,20 +362,20 @@ export const createAuthRequest = (event: RequestEvent): AuthRequest => {
 
 設計メモ: idle 延長は `validateSession` 内で完結し `setSession` を経由しないため、cookie は自動的に「延長時は触らない」(v2 と同挙動)。lucia の `storedSessionId === sessionId` early-return ガードは呼び出し経路上不要になるため実装しない。
 
-- [ ] 3-3. `src/hooks.server.ts`: `event.locals.auth = auth.handleRequest(event);` → `event.locals.auth = createAuthRequest(event);` に差し替え(import も変更。以降のロジック不変)。lucia-auth.com へのコメントリンクをこのタイミングで削除
-- [ ] 3-4. `src/app.d.ts`: `auth: import('lucia').AuthRequest;` → `auth: import('$lib/server/auth').AuthRequest;`。**`Lucia` namespace と `/// <reference types="lucia" />` は残す**
-- [ ] 3-5. `pnpm test:unit`(サービス層ガード・ルートのテストが**無変更で**通ることを確認)/ `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
-- [ ] 3-6. コミット: `feat(auth): replace lucia AuthRequest with self-managed createAuthRequest`
+- [x] 3-3. `src/hooks.server.ts`: `event.locals.auth = auth.handleRequest(event);` → `event.locals.auth = createAuthRequest(event);` に差し替え(import も変更。以降のロジック不変)。lucia-auth.com へのコメントリンクをこのタイミングで削除
+- [x] 3-4. `src/app.d.ts`: `auth: import('lucia').AuthRequest;` → `auth: import('$lib/server/auth').AuthRequest;`。**`Lucia` namespace と `/// <reference types="lucia" />` は残す**
+- [x] 3-5. `pnpm test:unit`(サービス層ガード・ルートのテストが**無変更で**通ることを確認)/ `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
+- [x] 3-6. コミット: `feat(auth): replace lucia AuthRequest with self-managed createAuthRequest`
 
 ## Phase 4: 認証ルート置換 + seed 置換 + 依存削除
 
-- [ ] 4-1. `src/features/auth/services/credentials.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')` + `vi.mock('$lib/server/password')`。ケース:
+- [x] 4-1. `src/features/auth/services/credentials.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')` + `vi.mock('$lib/server/password')`。ケース:
   - `registerUser` 成功: `$transaction` で user(15 字 `[a-z0-9]` ID)+ key(`id: 'username:{小文字}'`, `hashed_password`)が作成され `{ userId }` を返す
   - `registerUser` P2002(username / key.id どちら由来でも): null を返す
   - `registerUser` その他のエラー: re-throw
   - `authenticateUser` 成功: `key.findUnique({ where: { id: 'username:{小文字}' } })` → `verifyPassword` true → `{ userId }`
   - `authenticateUser` key なし / `hashed_password` が null / パスワード不一致: いずれも null(現行の「ユーザー不在とパスワード誤りを同一応答」仕様の維持)
-- [ ] 4-2. `src/features/auth/services/credentials.ts` を実装 → テスト通過:
+- [x] 4-2. `src/features/auth/services/credentials.ts` を実装 → テスト通過:
 
 ```typescript
 import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
@@ -432,29 +432,29 @@ export const authenticateUser = async (
 };
 ```
 
-- [ ] 4-3. `signup/+page.server.ts` を置換: `auth.createUser` + `LuciaError` 分岐 → `registerUser`。null なら現行の重複メッセージで 400(**文言は一字一句維持** — E2E が文言依存)、成功なら `createSession(userId)` → `locals.auth.setSession(session)`。予期しないエラーは catch で現行の 500 メッセージ。lucia import(`LuciaError` / `auth`)を削除
-- [ ] 4-4. `login/+page.server.ts` を置換: `auth.useKey` + `LuciaError` 分岐 → `authenticateUser`。null なら現行のログイン失敗メッセージで 400、成功なら `createSession` + `setSession`。エラー文言・応答の同一性を維持。lucia import を削除
-- [ ] 4-5. `logout/+page.server.ts` を置換: `auth.invalidateSession(session.sessionId)` → `invalidateSession(session.sessionId)`($lib/server/session から import)。`setSession(null)` はそのまま
-- [ ] 4-6. `users/edit/+page.server.ts`: 変更不要を確認(`locals.auth.setSession(null)` のみ = cookie クリア。session 行は `onDelete: Cascade` で削除される)
-- [ ] 4-7. `prisma/seed.ts`: `import { generateLuciaPasswordHash } from 'lucia/utils'` → `import { hashPassword } from '../src/lib/server/password'`(相対パス)。`pnpm db:seed` が tsx で通ることを確認
-- [ ] 4-8. `src/lib/server/auth.ts` から lucia 初期化(`lucia()` / `Auth` 型 / lucia import 3 本)を削除。`src/app.d.ts` から `Lucia` namespace と `/// <reference types="lucia" />` を削除
-- [ ] 4-9. `package.json` から `lucia` / `@lucia-auth/adapter-prisma` を削除 → `pnpm install`
-- [ ] 4-10. 残存参照の棚卸し: `grep -rin lucia src prisma docs .claude --include='*.{ts,svelte,md}'` で確認し、以下を更新:
+- [x] 4-3. `signup/+page.server.ts` を置換: `auth.createUser` + `LuciaError` 分岐 → `registerUser`。null なら現行の重複メッセージで 400(**文言は一字一句維持** — E2E が文言依存)、成功なら `createSession(userId)` → `locals.auth.setSession(session)`。予期しないエラーは catch で現行の 500 メッセージ。lucia import(`LuciaError` / `auth`)を削除
+- [x] 4-4. `login/+page.server.ts` を置換: `auth.useKey` + `LuciaError` 分岐 → `authenticateUser`。null なら現行のログイン失敗メッセージで 400、成功なら `createSession` + `setSession`。エラー文言・応答の同一性を維持。lucia import を削除
+- [x] 4-5. `logout/+page.server.ts` を置換: `auth.invalidateSession(session.sessionId)` → `invalidateSession(session.sessionId)`($lib/server/session から import)。`setSession(null)` はそのまま
+- [x] 4-6. `users/edit/+page.server.ts`: 変更不要を確認(`locals.auth.setSession(null)` のみ = cookie クリア。session 行は `onDelete: Cascade` で削除される)
+- [x] 4-7. `prisma/seed.ts`: `import { generateLuciaPasswordHash } from 'lucia/utils'` → `import { hashPassword } from '../src/lib/server/password'`(相対パス)。`pnpm db:seed` が tsx で通ることを確認
+- [x] 4-8. `src/lib/server/auth.ts` から lucia 初期化(`lucia()` / `Auth` 型 / lucia import 3 本)を削除。`src/app.d.ts` から `Lucia` namespace と `/// <reference types="lucia" />` を削除
+- [x] 4-9. `package.json` から `lucia` / `@lucia-auth/adapter-prisma` を削除 → `pnpm install`
+- [x] 4-10. 残存参照の棚卸し: `grep -rin lucia src prisma docs .claude --include='*.{ts,svelte,md}'` で確認し、以下を更新:
   - `src/lib/server/database.ts` / `src/routes/+page.server.ts` / `+page.svelte` / `+layout.server.ts` / auth ルート 3 本のコメント内 lucia-auth.com リンクを削除
   - `src/features/account/services/atcoder_verification.test.ts:45` のコメント(「Lucia が UUID を生成」は不正確)→ 「auth service generates a 15-char random id」に修正
   - `.claude/rules/auth.md` の「Lucia v2」セクションを自前実装の説明(`src/lib/server/session.ts` / `password.ts` / `createAuthRequest`)に書き換え
   - `src/routes/forgot_password/+page.svelte` の lucia example リンクは**残す**(将来のパスワードリセット設計の参考リンクであり本移行と無関係)
-- [ ] 4-11. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
-- [ ] 4-12. コミット: `feat(auth): replace lucia in auth routes and seed, drop lucia dependencies`
+- [x] 4-11. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
+- [x] 4-12. コミット: `feat(auth): replace lucia in auth routes and seed, drop lucia dependencies`
 
 ## Phase 5: 検証 + 仕上げ
 
-- [ ] 5-1. `pnpm test:e2e` 全通過(signin / redirect_after_login / user_edit / votes / workbook 系。※signup の E2E は存在しないため 5-3 の実機確認で担保)
-- [ ] 5-2. **セッション継続の実機確認**: Phase 3 直前のコミットを checkout → `pnpm dev` → シードユーザー(`guest` / `Ch0kuda1`)でログイン → サーバ停止 → ブランチ先頭を checkout → `pnpm dev` → リロードで**ログイン状態が維持**されること(cookie 名・値が devtools で不変であること)
-- [ ] 5-3. **パスワード互換 + signup の実機確認**: 移行後コードでシードユーザーの再ログイン成功 / 新規ユーザー作成 → ログアウト → 再ログイン成功 / 既存ユーザー名で signup → 重複メッセージ(400)/ 誤パスワードでログイン失敗(400)/ 二重ログアウトで 500 にならないこと
-- [ ] 5-4. `pnpm format` → 差分があればコミットに含める
-- [ ] 5-5. `coderabbit review --plain` を実行し、critical / high / potential_issue(medium)の所見を本ファイル末尾の `## CodeRabbit Findings` に記録(**修正はユーザー判断。無断で直さない**)
-- [ ] 5-6. AGENTS.md の必須リファクタサイクル: 新規の学び・残タスクを本ファイルに追記 → `/session-close`
+- [x] 5-1. `pnpm test:e2e` 全通過(signin / redirect_after_login / user_edit / votes / workbook 系。※signup の E2E は存在しないため 5-3 の実機確認で担保)
+- [x] 5-2. **セッション継続の実機確認**: Phase 3 直前のコミットを checkout → `pnpm dev` → シードユーザー(`guest` / `Ch0kuda1`)でログイン → サーバ停止 → ブランチ先頭を checkout → `pnpm dev` → リロードで**ログイン状態が維持**されること(cookie 名・値が devtools で不変であること)
+- [x] 5-3. **パスワード互換 + signup の実機確認**: 移行後コードでシードユーザーの再ログイン成功 / 新規ユーザー作成 → ログアウト → 再ログイン成功 / 既存ユーザー名で signup → 重複メッセージ(400)/ 誤パスワードでログイン失敗(400)/ 二重ログアウトで 500 にならないこと
+- [x] 5-4. `pnpm format` → 差分があればコミットに含める
+- [x] 5-5. `coderabbit review --plain` を実行し、critical / high / potential_issue(medium)の所見を本ファイル末尾の `## CodeRabbit Findings` に記録(**修正はユーザー判断。無断で直さない**)
+- [x] 5-6. AGENTS.md の必須リファクタサイクル: 新規の学び・残タスクを本ファイルに追記 → `/session-close`
 
 ## リスクと対策
 
@@ -466,6 +466,23 @@ survey.md の「リスクと対策」表を参照。本計画で追加される
 
 DB 変更ゼロのため、本番障害時は直前リリースの再デプロイのみで完全に戻る。ローカルはフェーズ単位のコミットを revert。
 
+## 新規の学び（本セッション / 5-6）
+
+ルールに未収録で再利用価値のある知見のみ記録（`phase-N.md` は無し = 単一 plan のため破棄対象なし）。
+
+1. **lucia v2 は idle 延長時に cookie を再発行しない（実ソース確認済み）** — `validateSession` は idle 時 **同一 session ID** のまま期限を UPDATE し `fresh: true` を返すが、`AuthRequest.setSession`/`setSessionCookie` の先頭ガード `if (storedSessionId === sessionId) return;` により **ID 不変では cookie を必ず再発行しない**。「idle 時 cookie を触らない = v2 互換」の根拠。静的レビュー（CodeRabbit 等）は「idle 延長で cookie 未更新 = バグ」と誤判定しがち。**互換実装のレビューは元ライブラリの dist を実読して裏取りする**。
+2. **削除済み依存の実ソース裏取り** — node_modules から消え、pnpm store にも無い場合でも `npm pack <pkg>@<ver>` で tarball を取得し `dist/` を読める。互換性の根拠検証に有効。
+3. **`grep --include='*.{ts,svelte,md}'` は brace 展開されない** — 残存参照スイープで対象漏れを生む。かつスイープ対象は `src` だけでなく **root（CONTRIBUTING.md 等）/ `e2e` / 設定ファイル（vite.config.ts）** まで含めること（本作業で 4-10 が `src prisma .claude/rules` に絞り 3 ファイル取りこぼした）。`rg -g` 複数指定が安全。
+4. **rules doc の重複** — 認証セクションにファイル一覧を足すと `## Key Files` と二重管理になる。**概念は概念セクション、ファイル→責務は Key Files に一本化**。
+5. **互換維持タスクに「改善」を混ぜない** — タイミング列挙・cookie 非再発行はいずれも lucia v2 と同挙動＝移行による回帰ではない。互換が目的の移行では、レビュー指摘の「強化」も**元実装の挙動を確認してから**別タスクとして切り出す。
+
+## 残タスク
+
+- [ ] **A-1（cookie スライディング更新）** — v2 由来の「ログインから最長 ~15 日で再ログイン」制約。直すと v2 互換を意図的に破る強化。survey.md の既知残課題。優先度低。
+- [ ] **credentials の定数時間化（ダミーハッシュ）** — ユーザー名列挙のタイミング側チャネル封じ。移行スコープ外の独立した任意強化（旧 lucia コードにも等しく該当）。
+- [ ] **C: plan.md の grep コマンド訂正** — L442 の `--include='*.{ts,svelte,md}'` を `rg -g` 複数指定へ（ドキュメント軽微）。
+- 5-1/5-2/5-3（e2e / 実機確認）はローカル完了済み（記録上チェック済み）。PR 時、CodeRabbit の無関係 findings（`docs/ui-mock/` 等）は本 PR スコープ外。
+
 ## CodeRabbit Findings
 
 `coderabbit review --plain`(v0.6.5、branch `#3855` = staging から 5 commits)実行。全 36 findings のうち大半は本移行と無関係の未追跡ファイル(`docs/ui-mock/`・他 dev-notes)に対するもの。以下は**本ブランチが変更したファイル**に限定して抽出(重大度は CodeRabbit の Major/Minor 表記)。**修正は未実施。ユーザー判断待ち。**

From 08bbc3f6b465e6ce4e8e07bfcbcb34289b1ea967 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 13:56:40 +0000
Subject: [PATCH 10/12] docs(rules): add Residual-Reference Sweeps guidance to
 coding-style.md

Promotes a novel lesson from the remove-lucia-v2 refactor cycle
(docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md): grep --include
with brace expansion silently matches nothing, and repo-wide sweeps
must cover root files, e2e/, and config, not just src/prisma/.claude.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .claude/rules/coding-style.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/.claude/rules/coding-style.md b/.claude/rules/coding-style.md
index f6c0dda86..ca6c1ceee 100644
--- a/.claude/rules/coding-style.md
+++ b/.claude/rules/coding-style.md
@@ -51,6 +51,15 @@ Delete function only if: (1) zero callers, (2) replacement exists, (3) dependent
 
 Before removing an import, grep the entire file for all usages — removing one call site doesn't mean no others exist.
 
+## Residual-Reference Sweeps
+
+When removing a dependency or renaming a symbol, sweep the **whole repo**, not just `src`:
+
+- `grep --include='*.{ts,svelte,md}'` does NOT brace-expand — it silently matches nothing.
+  Use `rg -ni 'name' -g '*.ts' -g '*.svelte' -g '*.md'` instead.
+- Include root files (CONTRIBUTING.md, README), `e2e/`, and config (`vite.config.ts`) —
+  not only `src prisma .claude`.
+
 ## Documentation
 
 - **Plans/dev-notes**: Japanese

From fffdea1a6b6751e75db33088da812eb580185bce Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Wed, 15 Jul 2026 13:57:06 +0000
Subject: [PATCH 11/12] chore(docs): remove completed remove-lucia-v2 plan and
 survey

Migration is complete and its novel lessons already folded into
.claude/rules/coding-style.md (08bbc3f6).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../2026-07-05/remove-lucia-v2/plan.md        | 527 ------------------
 .../2026-07-05/remove-lucia-v2/survey.md      | 230 --------
 2 files changed, 757 deletions(-)
 delete mode 100644 docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
 delete mode 100644 docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md

diff --git a/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md b/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
deleted file mode 100644
index 33b51b7ba..000000000
--- a/docs/dev-notes/2026-07-05/remove-lucia-v2/plan.md
+++ /dev/null
@@ -1,527 +0,0 @@
-# lucia v2 剥がし: 実装計画
-
-> **For agentic workers:** 実装開始にはユーザーの明示的な同意が必要(計画承認 ≠ 実装開始)。実装時は superpowers:executing-plans または superpowers:subagent-driven-development を使用し、チェックボックスで進捗を管理すること。
-
-**Goal:** EOL の `lucia@2.7.7` + `@lucia-auth/adapter-prisma@3.0.2` を、DB マイグレーションゼロ・既存パスワード/ログイン中セッション完全互換で自前実装に置換する。
-
-**Issue:** [#3855](https://github.com/AtCoder-NoviSteps/AtCoderNoviSteps/issues/3855)(#682 から参照) / **ブランチ:** `#3855`(作成済み) / **PR:** 1 本(フェーズ = コミット単位)
-
-**調査・設計判断・却下代替案:** [survey.md](./survey.md) 参照(本計画は survey の設計方針 10 項目を前提とする。重複記載しない)
-
----
-
-## 本計画での追加決定(survey からの差分)
-
-| 項目                                    | 決定                                                                                           | 理由                                                                                                                                                               |
-| --------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `validateSession` のクエリ数            | `include: { user: true }` の **1 クエリに統合**(現行 adapter は 2 クエリ)                      | 返す値は同一で挙動不変。全リクエストのホットパスで DB 1 往復削減。survey で「任意の最適化」と評価済み                                                              |
-| 新規モジュールのテスト配置              | **co-located**(`src/lib/server/password.test.ts` 等)                                           | vite.config は対応済み。`src/test/` は「existing tests (phase transition)」で新規追加は避ける方向                                                                  |
-| signup / login のドメインロジック置き場 | ルート直書きではなく **`src/features/auth/services/credentials.ts`** を新設                    | survey Phase 4 は「ルートで `prisma.$transaction`」としていたが、プロジェクトルール(prisma-db.md「ルートハンドラに直接 Prisma 禁止・CRUD はサービス層」)に従い修正 |
-| cookie 生成の置き場                     | `SESSION_COOKIE_NAME` は session.ts、cookie の set/delete は auth.ts の `createAuthRequest` 内 | session.ts を framework 非依存(cookies API を持ち込まない)に保つ                                                                                                   |
-| 乱数ユーティリティ                      | `src/lib/server/random.ts` を新設                                                              | salt(16 字)/ user ID(15 字)/ session ID(40 字)の 3 箇所で共用                                                                                                      |
-
-## 互換性仕様(実装が参照する正確な値・node_modules 実読で確定)
-
-- **乱数**: アルファベット `abcdefghijklmnopqrstuvwxyz1234567890`(36 字)。salt 16 字 / user ID 15 字 / session ID 40 字
-- **パスワード**: `s2:{salt}:{hash}`。入力を `normalize('NFKC')` → scrypt(N=16384, r=16, p=1, dkLen=64)→ hex。比較は定数時間(**長さ不一致は事前チェックで false**)。`s2:` 以外の形式(2 パート・`$2a` 等)は一律 false。`node:crypto` の scrypt は **`maxmem: 64 * 1024 * 1024` を明示**(既定 32MiB に抵触)
-- **期限判定**: 期限切れは `now > expires` のとき(**等値はまだ有効**)。active: `now <= active_expires` / idle: `active_expires < now <= idle_expires` / dead: `now > idle_expires`
-- **期限値**: 作成・延長とも `active_expires = now + 24h`、`idle_expires = active_expires + 14d`(ms epoch)。idle 延長は**同一 ID のまま UPDATE のみ**。dead でも**行削除しない**
-- **cookie**: 名前 `auth_session` / 値 = セッション ID / `path: '/'`, `httpOnly: true`, `sameSite: 'lax'`, `secure: !dev`, `expires: idlePeriodExpiresAt`。無効時はクリア、idle 延長時は**触らない**
-- **BigInt**: `active_expires` / `idle_expires` の読み取りは `bigint` → 比較前に `Number()` 変換。書き込みは Number のままで可(現行 adapter と同じ)
-
-## ファイルマップ
-
-| 種別   | パス                                                                | 内容                                                                                                                                                                       |
-| ------ | ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 新規   | `src/lib/server/random.ts` + `random.test.ts`                       | `generateRandomString(length)`                                                                                                                                             |
-| 新規   | `src/lib/server/password.ts` + `password.test.ts`                   | `hashPassword` / `verifyPassword`(**相対 import のみ** — seed から tsx で使うため `$lib` alias 禁止)                                                                       |
-| 新規   | `src/lib/server/session.ts` + `session.test.ts`                     | `createSession` / `validateSession` / `invalidateSession` / `SESSION_COOKIE_NAME`                                                                                          |
-| 変更   | `src/lib/server/auth.ts` + `auth.test.ts`(新規)                     | `createAuthRequest` 追加(Phase 3)→ lucia 初期化削除(Phase 4)                                                                                                               |
-| 変更   | `src/hooks.server.ts`                                               | `auth.handleRequest` → `createAuthRequest`                                                                                                                                 |
-| 変更   | `src/app.d.ts`                                                      | `Locals.auth` 型差し替え(Phase 3)→ `Lucia` namespace 削除(Phase 4)                                                                                                         |
-| 新規   | `src/features/auth/services/credentials.ts` + `credentials.test.ts` | `registerUser` / `authenticateUser`                                                                                                                                        |
-| 変更   | `src/routes/(auth)/signup/+page.server.ts`                          | `auth.createUser` → `registerUser` + `createSession`                                                                                                                       |
-| 変更   | `src/routes/(auth)/login/+page.server.ts`                           | `auth.useKey` → `authenticateUser` + `createSession`                                                                                                                       |
-| 変更   | `src/routes/(auth)/logout/+page.server.ts`                          | `auth.invalidateSession` → `invalidateSession`                                                                                                                             |
-| 変更   | `prisma/seed.ts`                                                    | `generateLuciaPasswordHash` → 相対 import の `hashPassword`                                                                                                                |
-| 変更   | `package.json`                                                      | `lucia` / `@lucia-auth/adapter-prisma` 削除                                                                                                                                |
-| 変更   | コメント棚卸し                                                      | `database.ts` / `hooks.server.ts` / `+page.server.ts` / `+layout.server.ts` / `+page.svelte` / auth ルート 3 本 / `atcoder_verification.test.ts` / `.claude/rules/auth.md` |
-| 無変更 | `src/routes/users/edit/+page.server.ts`                             | `locals.auth.setSession(null)` は新 API と同形状(確認のみ)                                                                                                                 |
-| 無変更 | `prisma/schema.prisma` / migrations                                 | **DB 変更ゼロ**                                                                                                                                                            |
-
-各フェーズ完了時に `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 全通過を確認してからコミットする。
-
----
-
-## Phase 1: 互換性フィクスチャ + 乱数 + パスワードユーティリティ(TDD)
-
-**互換性の錨。lucia が残っているうちにフィクスチャを固定する。**
-
-**フィクスチャ選定の前提**: `authSchema`(`src/lib/zod/schema.ts`)のパスワード規則は半角英数字のみ(`[a-zA-Z\d]{8,128}` + 大小英字・数字各 1 以上)で、**初回実装(2023-09)から不変**(git 確認済み)。signup / login とも同スキーマで検証してから crypto 層に到達するため、**非 ASCII パスワードは prod のハッシュにも `verifyPassword` への入力にも存在し得ない**。よってフィクスチャは (a) スキーマ準拠の実在パスワード = 互換性の錨、(b) スキーマ外の全角ベクタ = `normalize('NFKC')` の実装漏れ検出専用(ASCII ベクタは normalize の有無で結果が変わらないため、これが唯一の検出手段)の 2 系統のみとする。
-
-- [x] 1-1. lucia でフィクスチャ生成(実装前に必ず実行):
-
-```bash
-pnpm exec tsx -e '
-import { generateLuciaPasswordHash } from "lucia/utils";
-// "Ch0kuda1": seed の実パスワード(スキーマ準拠・prod 互換の錨)
-// "AtC0derN0viSteps": スキーマ準拠のもう 1 本(単発の偶然一致を排除)
-// "Ｃｈ０ｋｕｄａ１": スキーマ外。NFKC 正規化の実装漏れ検出専用ガード
-const passwords = ["Ch0kuda1", "AtC0derN0viSteps", "Ｃｈ０ｋｕｄａ１"];
-for (const p of passwords) {
-  console.log(JSON.stringify(p), await generateLuciaPasswordHash(p));
-}
-'
-```
-
-出力された 3 ハッシュを `password.test.ts` の fixture 定数として貼り付ける(生成コマンドと上記の選定理由をコメントで残す)。`Ｃｈ０ｋｕｄａ１`(全角)は NFKC 正規化で `Ch0kuda1` と同一になるため、**半角入力で検証が通ること**が normalize 実装の存在証明になる(アプリの入力ドメイン外だが、lucia アルゴリズム等価性の担保として意図的に含める)。
-
-- [x] 1-2. `src/lib/server/random.test.ts` を書く(失敗を確認):
-  - 指定長の文字列を返す(16 / 15 / 40)
-  - 全文字が `[a-z0-9]`(36 字アルファベット)に含まれる(1000 回生成で検証)
-  - 呼び出しごとに異なる値(衝突しない)
-- [x] 1-3. `src/lib/server/random.ts` を実装 → テスト通過:
-
-```typescript
-const DEFAULT_ALPHABET = 'abcdefghijklmnopqrstuvwxyz1234567890';
-
-/** lucia v2 compatible random string (used for salts, user ids, and session ids). */
-export const generateRandomString = (length: number, alphabet = DEFAULT_ALPHABET): string => {
-  const randomUint32Values = new Uint32Array(length);
-  crypto.getRandomValues(randomUint32Values);
-  const u32Max = 0xffffffff;
-  let result = '';
-
-  for (let i = 0; i < length; i++) {
-    const rand = randomUint32Values[i] / (u32Max + 1);
-    result += alphabet[Math.floor(alphabet.length * rand)];
-  }
-
-  return result;
-};
-```
-
-- [x] 1-4. `src/lib/server/password.test.ts` を書く(失敗を確認)。ケース:
-  - 自己ラウンドトリップ: `hashPassword` → `verifyPassword` が true / 生成形式が `^s2:[a-z0-9]{16}:[0-9a-f]{128}$`
-  - **lucia フィクスチャ 3 本の検証一致**(`verifyPassword('Ch0kuda1', fixture)` === true 等。定数時間比較が 128 字 hex 全一致を要求するため、これがバイト互換の機械的証明になる)
-  - NFKC ガード(入力ドメイン外・normalize 実装漏れ検出専用): 全角生成フィクスチャに半角入力 `Ch0kuda1` で true(逆も true)
-  - 拒否系(全て false・throw しない。stored hash の形式契約 = survey 設計方針 9-10 の固定): パスワード不一致 / 旧 2 パート形式 `{salt}:{hash}` / bcrypt `$2a$...` / 空文字ハッシュ / 部品数不正 `s2:saltonly` / 空パスワード vs 正規ハッシュ
-- [x] 1-5. `src/lib/server/password.ts` を実装 → テスト通過。**`./random` 相対 import + node 組み込みのみ**(`$lib` alias を使うと Phase 4 の seed(tsx 実行)が壊れる):
-
-```typescript
-import { scrypt, timingSafeEqual } from 'node:crypto';
-import { promisify } from 'node:util';
-
-import { generateRandomString } from './random';
-
-const scryptAsync = promisify(scrypt);
-
-// lucia v2 compatible parameters. 128 * N * r = 32MiB hits the default maxmem, so raise it to 64MiB.
-const SCRYPT_OPTIONS = { N: 16384, r: 16, p: 1, maxmem: 64 * 1024 * 1024 };
-const KEY_LENGTH = 64;
-const SALT_LENGTH = 16;
-const HASH_VERSION = 's2';
-
-/** Generates a lucia v2 compatible password hash: `s2:{salt}:{hash}`. */
-export const hashPassword = async (password: string): Promise<string> => {
-  const salt = generateRandomString(SALT_LENGTH);
-  const hash = await computeHash(password, salt);
-
-  return `${HASH_VERSION}:${salt}:${hash}`;
-};
-
-/** Verifies a password against a stored hash. Unknown formats (v1 two-part, bcrypt $2a) return false. */
-export const verifyPassword = async (password: string, storedHash: string): Promise<boolean> => {
-  const parts = storedHash.split(':');
-
-  if (parts.length !== 3 || parts[0] !== HASH_VERSION) {
-    return false;
-  }
-
-  const [, salt, expectedHash] = parts;
-  const actualHash = await computeHash(password, salt);
-  const expectedBuffer = Buffer.from(expectedHash, 'hex');
-  const actualBuffer = Buffer.from(actualHash, 'hex');
-
-  // timingSafeEqual throws on length mismatch, so check length first
-  if (expectedBuffer.length !== actualBuffer.length) {
-    return false;
-  }
-
-  return timingSafeEqual(expectedBuffer, actualBuffer);
-};
-
-const computeHash = async (password: string, salt: string): Promise<string> => {
-  // NFKC-normalize so visually identical unicode inputs hash identically (lucia v2 behavior)
-  const derivedKey = (await scryptAsync(
-    password.normalize('NFKC'),
-    salt,
-    KEY_LENGTH,
-    SCRYPT_OPTIONS,
-  )) as Buffer;
-
-  return derivedKey.toString('hex');
-};
-```
-
-- [x] 1-6. `pnpm test:unit` / `pnpm check` / `pnpm lint` 通過を確認
-- [x] 1-7. コミット: `feat(auth): add lucia v2 compatible password and random utilities`
-
-## Phase 2: セッションサービス(TDD)
-
-- [x] 2-1. `src/lib/server/session.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')`(default export をモック)+ `vi.useFakeTimers()` + `vi.setSystemTime`。**モックの `active_expires` / `idle_expires` は必ず `BigInt` で返す**(Number を返すモックでは変換漏れを検出できない)。ケース:
-  - `createSession`: 40 字 `[a-z0-9]` の ID / `active_expires = now + 24h`・`idle_expires = now + 24h + 14d` で create される / 戻り値 `{ sessionId, idlePeriodExpiresAt }`
-  - `validateSession` active(`now <= active_expires`): update / delete が**呼ばれない**、`{ sessionId, user: { userId, username, role } }` を返す
-  - `validateSession` idle(`active_expires < now <= idle_expires`): **同一 ID** に update(新期限値をアサート)、delete は呼ばれない
-  - `validateSession` dead(`now > idle_expires`): null 返し、**update / delete とも呼ばれない**(行は残す)
-  - `validateSession` 境界値: `now === active_expires` は active(書き込みなし)/ `now === idle_expires` は idle(延長)— lucia の `>` 比較の再現
-  - `validateSession` 行なし: null
-  - `findUnique` が `include: { user: true }` で呼ばれる(1 クエリ)
-  - `invalidateSession`: delete が呼ばれる / **P2025 は握りつぶす**(`PrismaClientKnownRequestError` を mockRejectedValue)/ P2025 以外は re-throw
-- [x] 2-2. `src/lib/server/session.ts` を実装 → テスト通過:
-
-```typescript
-import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
-import type { Roles } from '@prisma/client';
-
-import client from '$lib/server/database';
-import { generateRandomString } from '$lib/server/random';
-
-// lucia v2 defaults: active 24h, idle +14d
-const ACTIVE_PERIOD_MS = 1000 * 60 * 60 * 24;
-const IDLE_PERIOD_MS = 1000 * 60 * 60 * 24 * 14;
-const SESSION_ID_LENGTH = 40;
-
-export const SESSION_COOKIE_NAME = 'auth_session';
-
-export type SessionCookieData = { sessionId: string; idlePeriodExpiresAt: Date };
-
-export type ValidatedSession = {
-  sessionId: string;
-  user: { userId: string; username: string; role: Roles };
-};
-
-const computeExpirations = (now: number) => {
-  const activePeriodExpiresAt = new Date(now + ACTIVE_PERIOD_MS);
-  const idlePeriodExpiresAt = new Date(activePeriodExpiresAt.getTime() + IDLE_PERIOD_MS);
-
-  return { activePeriodExpiresAt, idlePeriodExpiresAt };
-};
-
-export const createSession = async (userId: string): Promise<SessionCookieData> => {
-  const sessionId = generateRandomString(SESSION_ID_LENGTH);
-  const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(Date.now());
-
-  await client.session.create({
-    data: {
-      id: sessionId,
-      user_id: userId,
-      active_expires: activePeriodExpiresAt.getTime(),
-      idle_expires: idlePeriodExpiresAt.getTime(),
-    },
-  });
-
-  return { sessionId, idlePeriodExpiresAt };
-};
-
-export const validateSession = async (sessionId: string): Promise<ValidatedSession | null> => {
-  const session = await client.session.findUnique({
-    where: { id: sessionId },
-    include: { user: true },
-  });
-
-  if (!session) {
-    return null;
-  }
-
-  const now = Date.now();
-
-  // lucia v2: expired only when now is strictly past the deadline; dead rows are kept (no cleanup)
-  if (now > Number(session.idle_expires)) {
-    return null;
-  }
-
-  if (now > Number(session.active_expires)) {
-    // idle state: extend expirations keeping the same id (no rotation, cookie untouched)
-    const { activePeriodExpiresAt, idlePeriodExpiresAt } = computeExpirations(now);
-
-    await client.session.update({
-      where: { id: sessionId },
-      data: {
-        active_expires: activePeriodExpiresAt.getTime(),
-        idle_expires: idlePeriodExpiresAt.getTime(),
-      },
-    });
-  }
-
-  return {
-    sessionId: session.id,
-    user: {
-      userId: session.user.id,
-      username: session.user.username,
-      role: session.user.role,
-    },
-  };
-};
-
-export const invalidateSession = async (sessionId: string): Promise<void> => {
-  try {
-    await client.session.delete({ where: { id: sessionId } });
-  } catch (error) {
-    // P2025 (row already gone): swallow for logout idempotency, same as the lucia adapter
-    if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
-      return;
-    }
-
-    throw error;
-  }
-};
-```
-
-- [x] 2-3. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
-- [x] 2-4. コミット: `feat(auth): add self-managed session service compatible with lucia v2`
-
-## Phase 3: locals.auth 互換オブジェクト + hooks + 型
-
-**注意: lucia の `auth` export と `app.d.ts` の `Lucia` namespace はこのフェーズでは削除しない**(auth ルート 3 本が Phase 4 まで使用。消すと本フェーズで `pnpm check` / `build` が落ちる)。
-
-- [x] 3-1. `src/lib/server/auth.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/session')` + `vi.mock('$lib/server/database')`(Phase 3 時点では auth.ts が lucia 初期化のため database を import している)+ cookies(get/set/delete)をスパイにしたモック event。ケース:
-  - cookie なし: null を返し `validateSession` は呼ばれない
-  - 有効セッション: セッションを返す / **2 回目の `validate()` で `validateSession` が再度呼ばれない**(リクエスト内キャッシュ)
-  - 無効セッション(cookie あり): null を返し `cookies.delete(SESSION_COOKIE_NAME, { path: '/' })` が呼ばれる
-  - `setSession(session)`: `cookies.set` が正確な属性(`path: '/'`, `httpOnly: true`, `sameSite: 'lax'`, `secure: !dev`, `expires: idlePeriodExpiresAt`)で呼ばれる
-  - `setSession(null)`: `cookies.delete` が呼ばれる
-  - `setSession` 後の `validate()` はキャッシュを使わず再検証する
-- [x] 3-2. `src/lib/server/auth.ts` に **追加**(lucia 初期化はそのまま残す)→ テスト通過:
-
-```typescript
-import type { RequestEvent } from '@sveltejs/kit';
-import { dev } from '$app/environment';
-
-import {
-  SESSION_COOKIE_NAME,
-  validateSession,
-  type SessionCookieData,
-  type ValidatedSession,
-} from '$lib/server/session';
-
-export type AuthRequest = {
-  validate: () => Promise<ValidatedSession | null>;
-  setSession: (session: SessionCookieData | null) => void;
-};
-
-export const createAuthRequest = (event: RequestEvent): AuthRequest => {
-  let validatePromise: Promise<ValidatedSession | null> | null = null;
-
-  const setSessionCookie = (session: SessionCookieData | null): void => {
-    if (session) {
-      event.cookies.set(SESSION_COOKIE_NAME, session.sessionId, {
-        path: '/',
-        httpOnly: true,
-        sameSite: 'lax',
-        secure: !dev,
-        expires: session.idlePeriodExpiresAt,
-      });
-    } else {
-      event.cookies.delete(SESSION_COOKIE_NAME, { path: '/' });
-    }
-  };
-
-  return {
-    validate: () => {
-      // request-scoped cache: hooks and route guards both call validate() on every request
-      if (validatePromise) {
-        return validatePromise;
-      }
-
-      validatePromise = (async () => {
-        const sessionId = event.cookies.get(SESSION_COOKIE_NAME);
-
-        if (!sessionId) {
-          return null;
-        }
-
-        const session = await validateSession(sessionId);
-
-        if (!session) {
-          setSessionCookie(null); // clear the stale cookie (lucia v2 behavior)
-        }
-
-        return session;
-      })();
-
-      return validatePromise;
-    },
-    setSession: (session) => {
-      validatePromise = null;
-      setSessionCookie(session);
-    },
-  };
-};
-```
-
-設計メモ: idle 延長は `validateSession` 内で完結し `setSession` を経由しないため、cookie は自動的に「延長時は触らない」(v2 と同挙動)。lucia の `storedSessionId === sessionId` early-return ガードは呼び出し経路上不要になるため実装しない。
-
-- [x] 3-3. `src/hooks.server.ts`: `event.locals.auth = auth.handleRequest(event);` → `event.locals.auth = createAuthRequest(event);` に差し替え(import も変更。以降のロジック不変)。lucia-auth.com へのコメントリンクをこのタイミングで削除
-- [x] 3-4. `src/app.d.ts`: `auth: import('lucia').AuthRequest;` → `auth: import('$lib/server/auth').AuthRequest;`。**`Lucia` namespace と `/// <reference types="lucia" />` は残す**
-- [x] 3-5. `pnpm test:unit`(サービス層ガード・ルートのテストが**無変更で**通ることを確認)/ `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
-- [x] 3-6. コミット: `feat(auth): replace lucia AuthRequest with self-managed createAuthRequest`
-
-## Phase 4: 認証ルート置換 + seed 置換 + 依存削除
-
-- [x] 4-1. `src/features/auth/services/credentials.test.ts` を書く(失敗を確認)。`vi.mock('$lib/server/database')` + `vi.mock('$lib/server/password')`。ケース:
-  - `registerUser` 成功: `$transaction` で user(15 字 `[a-z0-9]` ID)+ key(`id: 'username:{小文字}'`, `hashed_password`)が作成され `{ userId }` を返す
-  - `registerUser` P2002(username / key.id どちら由来でも): null を返す
-  - `registerUser` その他のエラー: re-throw
-  - `authenticateUser` 成功: `key.findUnique({ where: { id: 'username:{小文字}' } })` → `verifyPassword` true → `{ userId }`
-  - `authenticateUser` key なし / `hashed_password` が null / パスワード不一致: いずれも null(現行の「ユーザー不在とパスワード誤りを同一応答」仕様の維持)
-- [x] 4-2. `src/features/auth/services/credentials.ts` を実装 → テスト通過:
-
-```typescript
-import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
-
-import client from '$lib/server/database';
-import { hashPassword, verifyPassword } from '$lib/server/password';
-import { generateRandomString } from '$lib/server/random';
-
-const USER_ID_LENGTH = 15; // lucia v2 createUser default
-
-const buildKeyId = (username: string): string => `username:${username.toLowerCase()}`;
-
-/** Creates a user with a password key. Returns null when the username is already taken. */
-export const registerUser = async (
-  username: string,
-  password: string,
-): Promise<{ userId: string } | null> => {
-  const userId = generateRandomString(USER_ID_LENGTH);
-  const hashedPassword = await hashPassword(password);
-
-  try {
-    await client.$transaction([
-      client.user.create({ data: { id: userId, username } }),
-      client.key.create({
-        data: { id: buildKeyId(username), user_id: userId, hashed_password: hashedPassword },
-      }),
-    ]);
-  } catch (error) {
-    // P2002 on user.username or key.id both mean the username is taken
-    if (error instanceof PrismaClientKnownRequestError && error.code === 'P2002') {
-      return null;
-    }
-
-    throw error;
-  }
-
-  return { userId };
-};
-
-/** Returns the user id for valid credentials, or null (missing user and wrong password are indistinguishable). */
-export const authenticateUser = async (
-  username: string,
-  password: string,
-): Promise<{ userId: string } | null> => {
-  const key = await client.key.findUnique({ where: { id: buildKeyId(username) } });
-
-  if (!key || key.hashed_password === null) {
-    return null;
-  }
-
-  const isValid = await verifyPassword(password, key.hashed_password);
-
-  return isValid ? { userId: key.user_id } : null;
-};
-```
-
-- [x] 4-3. `signup/+page.server.ts` を置換: `auth.createUser` + `LuciaError` 分岐 → `registerUser`。null なら現行の重複メッセージで 400(**文言は一字一句維持** — E2E が文言依存)、成功なら `createSession(userId)` → `locals.auth.setSession(session)`。予期しないエラーは catch で現行の 500 メッセージ。lucia import(`LuciaError` / `auth`)を削除
-- [x] 4-4. `login/+page.server.ts` を置換: `auth.useKey` + `LuciaError` 分岐 → `authenticateUser`。null なら現行のログイン失敗メッセージで 400、成功なら `createSession` + `setSession`。エラー文言・応答の同一性を維持。lucia import を削除
-- [x] 4-5. `logout/+page.server.ts` を置換: `auth.invalidateSession(session.sessionId)` → `invalidateSession(session.sessionId)`($lib/server/session から import)。`setSession(null)` はそのまま
-- [x] 4-6. `users/edit/+page.server.ts`: 変更不要を確認(`locals.auth.setSession(null)` のみ = cookie クリア。session 行は `onDelete: Cascade` で削除される)
-- [x] 4-7. `prisma/seed.ts`: `import { generateLuciaPasswordHash } from 'lucia/utils'` → `import { hashPassword } from '../src/lib/server/password'`(相対パス)。`pnpm db:seed` が tsx で通ることを確認
-- [x] 4-8. `src/lib/server/auth.ts` から lucia 初期化(`lucia()` / `Auth` 型 / lucia import 3 本)を削除。`src/app.d.ts` から `Lucia` namespace と `/// <reference types="lucia" />` を削除
-- [x] 4-9. `package.json` から `lucia` / `@lucia-auth/adapter-prisma` を削除 → `pnpm install`
-- [x] 4-10. 残存参照の棚卸し: `grep -rin lucia src prisma docs .claude --include='*.{ts,svelte,md}'` で確認し、以下を更新:
-  - `src/lib/server/database.ts` / `src/routes/+page.server.ts` / `+page.svelte` / `+layout.server.ts` / auth ルート 3 本のコメント内 lucia-auth.com リンクを削除
-  - `src/features/account/services/atcoder_verification.test.ts:45` のコメント(「Lucia が UUID を生成」は不正確)→ 「auth service generates a 15-char random id」に修正
-  - `.claude/rules/auth.md` の「Lucia v2」セクションを自前実装の説明(`src/lib/server/session.ts` / `password.ts` / `createAuthRequest`)に書き換え
-  - `src/routes/forgot_password/+page.svelte` の lucia example リンクは**残す**(将来のパスワードリセット設計の参考リンクであり本移行と無関係)
-- [x] 4-11. `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 通過を確認
-- [x] 4-12. コミット: `feat(auth): replace lucia in auth routes and seed, drop lucia dependencies`
-
-## Phase 5: 検証 + 仕上げ
-
-- [x] 5-1. `pnpm test:e2e` 全通過(signin / redirect_after_login / user_edit / votes / workbook 系。※signup の E2E は存在しないため 5-3 の実機確認で担保)
-- [x] 5-2. **セッション継続の実機確認**: Phase 3 直前のコミットを checkout → `pnpm dev` → シードユーザー(`guest` / `Ch0kuda1`)でログイン → サーバ停止 → ブランチ先頭を checkout → `pnpm dev` → リロードで**ログイン状態が維持**されること(cookie 名・値が devtools で不変であること)
-- [x] 5-3. **パスワード互換 + signup の実機確認**: 移行後コードでシードユーザーの再ログイン成功 / 新規ユーザー作成 → ログアウト → 再ログイン成功 / 既存ユーザー名で signup → 重複メッセージ(400)/ 誤パスワードでログイン失敗(400)/ 二重ログアウトで 500 にならないこと
-- [x] 5-4. `pnpm format` → 差分があればコミットに含める
-- [x] 5-5. `coderabbit review --plain` を実行し、critical / high / potential_issue(medium)の所見を本ファイル末尾の `## CodeRabbit Findings` に記録(**修正はユーザー判断。無断で直さない**)
-- [x] 5-6. AGENTS.md の必須リファクタサイクル: 新規の学び・残タスクを本ファイルに追記 → `/session-close`
-
-## リスクと対策
-
-survey.md の「リスクと対策」表を参照。本計画で追加されるリスクは 1 点:
-
-- **サービス層化(credentials.ts)に伴う挙動差**: ルート直書きからの移し替えでエラー変換の粒度が変わる(LuciaError → null 返し)。対策: Phase 4 のユニットテストで「重複 = null」「その他 = re-throw」の境界を固定し、ルート側の応答コード・文言を現行と突き合わせて確認(5-3)
-
-## ロールバック
-
-DB 変更ゼロのため、本番障害時は直前リリースの再デプロイのみで完全に戻る。ローカルはフェーズ単位のコミットを revert。
-
-## 新規の学び（本セッション / 5-6）
-
-ルールに未収録で再利用価値のある知見のみ記録（`phase-N.md` は無し = 単一 plan のため破棄対象なし）。
-
-1. **lucia v2 は idle 延長時に cookie を再発行しない（実ソース確認済み）** — `validateSession` は idle 時 **同一 session ID** のまま期限を UPDATE し `fresh: true` を返すが、`AuthRequest.setSession`/`setSessionCookie` の先頭ガード `if (storedSessionId === sessionId) return;` により **ID 不変では cookie を必ず再発行しない**。「idle 時 cookie を触らない = v2 互換」の根拠。静的レビュー（CodeRabbit 等）は「idle 延長で cookie 未更新 = バグ」と誤判定しがち。**互換実装のレビューは元ライブラリの dist を実読して裏取りする**。
-2. **削除済み依存の実ソース裏取り** — node_modules から消え、pnpm store にも無い場合でも `npm pack <pkg>@<ver>` で tarball を取得し `dist/` を読める。互換性の根拠検証に有効。
-3. **`grep --include='*.{ts,svelte,md}'` は brace 展開されない** — 残存参照スイープで対象漏れを生む。かつスイープ対象は `src` だけでなく **root（CONTRIBUTING.md 等）/ `e2e` / 設定ファイル（vite.config.ts）** まで含めること（本作業で 4-10 が `src prisma .claude/rules` に絞り 3 ファイル取りこぼした）。`rg -g` 複数指定が安全。
-4. **rules doc の重複** — 認証セクションにファイル一覧を足すと `## Key Files` と二重管理になる。**概念は概念セクション、ファイル→責務は Key Files に一本化**。
-5. **互換維持タスクに「改善」を混ぜない** — タイミング列挙・cookie 非再発行はいずれも lucia v2 と同挙動＝移行による回帰ではない。互換が目的の移行では、レビュー指摘の「強化」も**元実装の挙動を確認してから**別タスクとして切り出す。
-
-## 残タスク
-
-- [ ] **A-1（cookie スライディング更新）** — v2 由来の「ログインから最長 ~15 日で再ログイン」制約。直すと v2 互換を意図的に破る強化。survey.md の既知残課題。優先度低。
-- [ ] **credentials の定数時間化（ダミーハッシュ）** — ユーザー名列挙のタイミング側チャネル封じ。移行スコープ外の独立した任意強化（旧 lucia コードにも等しく該当）。
-- [ ] **C: plan.md の grep コマンド訂正** — L442 の `--include='*.{ts,svelte,md}'` を `rg -g` 複数指定へ（ドキュメント軽微）。
-- 5-1/5-2/5-3（e2e / 実機確認）はローカル完了済み（記録上チェック済み）。PR 時、CodeRabbit の無関係 findings（`docs/ui-mock/` 等）は本 PR スコープ外。
-
-## CodeRabbit Findings
-
-`coderabbit review --plain`(v0.6.5、branch `#3855` = staging から 5 commits)実行。全 36 findings のうち大半は本移行と無関係の未追跡ファイル(`docs/ui-mock/`・他 dev-notes)に対するもの。以下は**本ブランチが変更したファイル**に限定して抽出(重大度は CodeRabbit の Major/Minor 表記)。**修正は未実施。ユーザー判断待ち。**
-
-**⚠️ 追記(lucia@2.7.7 実ソース検証後)**: 下記 A-1 / A-3 について、npm から `lucia@2.7.7` の tarball を取得し `dist/auth/request.js`・`dist/auth/index.js` を実読して裏取りした。結論は各項に反映済み。CodeRabbit の A-1 指摘は **lucia v2 挙動の理解として誤り**だった(初版の私の記録も CodeRabbit を過信しており誤り。訂正済み)。
-
-### A. ソース（Major）
-
-- **[auth.ts:51-57] idle 延長時に Cookie の `expires` を再発行しない** → **v2 と完全一致。互換性の観点では問題なし(CodeRabbit 指摘は v2 挙動の誤認)**
-  - 実ソース検証: lucia v2 `validateSession`(`dist/auth/index.js`)は idle 時 **同一 session ID のまま** `updateSession` で期限延長し `fresh: true` を返す。`AuthRequest.validate`(`dist/auth/request.js`)は `session.fresh` で `maybeSetSession(session)` を呼ぶが、`setSession`/`setSessionCookie` は先頭に `if (this.storedSessionId === sessionId) return;` ガードを持つ。idle 延長は ID 不変のためこのガードで **必ず early-return し、Cookie は再発行されない**。→ 本実装(idle 時 cookie を触らない)は **byte-for-byte で v2 同挙動**。survey.md line 99 / 175 の記述が正しい。
-  - ただし v2 由来の **既知の制約**は残る: Cookie の expires は発行時固定のため、継続利用でも **ログインから最長 ~15 日で再ログインが必要**(cookie 層でのスライディング更新がない)。これは survey.md line 175 が「残課題」として明記済み。修正は v2 互換性を意図的に破る強化であり、本移行のスコープ外。**回帰でもバグでもない**。
-
-- **[session.ts:58-64] 並行ログアウト時の P2025 で 500** → ✅ **修正済み(ロバスト性優先)** — idle 延長の `update` を try/catch し、`P2025`(findUnique〜update 間で行が削除された競合)は `null`(未認証)を返す。それ以外は re-throw。テスト 2 本追加(P2025→null / P2003→re-throw)。
-  - 📝 補足: lucia v2 も `adapter.updateSession` を try/catch せず同じ競合を持っていた(回帰ではない)。本修正は v2 挙動からの意図的な改善(500 回避)。
-
-- **[credentials.ts:45-49] 無効認証のタイミング差（Security）** → **v2 と一致。本移行による回帰なし。ユーザー名列挙の水準は不変**
-  - 実ソース検証: lucia v2 `useKey`(`dist/auth/index.js`)も `getKey` が無ければ **ハッシュ検証せず即 `AUTH_INVALID_KEY_ID` を throw**。既存ユーザーの誤パスワード時のみハッシュを実行する。→ 本実装の分岐は v2 と同一で、タイミング側チャネルは **移行前から存在**していた。
-  - 📝 さらに signup は重複ユーザー名で専用メッセージ(400)を返すため、**ユーザー名列挙は元から signup 経由で可能**。したがって本移行でセキュリティ水準は変わらない。定数時間化(ダミーハッシュ)は独立した強化であり、旧コードにも等しく当てはまる任意対応。
-
-- **[credentials.test.ts:128-143] 上記に対応するテスト（Security）** — 「欠損キー時に `verifyPassword` を呼ばない」= v2 と同じ挙動を固定するテスト。定数時間化を採用する場合のみ期待値変更が必要。上記 credentials.ts:45 と一体で判断。
-
-### B. ソース（Minor）→ ✅ 修正済み
-
-- **[credentials.ts:9 / seed.ts] `toLowerCase()` と `toLocaleLowerCase()` の不一致** — seed 側を `toLowerCase()` に統一(本セッションで修正)。
-  - 📝 補足: username は zod `authSchema` で `[a-zA-Z\d]`(ASCII のみ)に制限済みのため元々実害はなかったが、一貫性のため統一。
-
-### C. 計画・ドキュメント
-
-- **[plan.md:442-446] `grep --include='*.{ts,svelte,md}'` の brace 展開が効かない** — grep は `{ts,svelte,md}` を展開しない。実際の 4-10 実行では `--include` を使わず全拡張子を対象にしたためこの点での取りこぼしは無かったが、計画記載のコマンドは誤り(かつ 4-10 は `src prisma .claude/rules` に対象を絞ったため D の漏れが発生)。`rg -g` 複数指定か拡張子ごとの `--include` に修正。
-
-### D. 5-5 スイープで追加検出した residual lucia 参照 → ✅ 修正済み（4-10 の grep が `src prisma .claude/rules` のみを対象にしていた漏れ）
-
-- **[vite.config.ts:8]** `optimizeDeps.exclude` の死んだ `@lucia-auth/adapter-prisma` を削除。
-- **[e2e/problems_cache.spec.ts:22-24]** stale な Lucia コメントを self-managed auth の説明に修正。
-- (root の CONTRIBUTING.md は本セッションで対応済み)
-
-### 対応方針メモ（実ソース検証後）
-
-- **A-1 / A-3 は対応不要**(v2 と byte 互換。CodeRabbit の指摘は v2 挙動の誤認)。A-1 の「~15 日で再ログイン」は survey.md 既知の残課題で、直すなら v2 互換を意図的に破る別タスク。
-- **B / D は修正済み**。
-- **A-2(P2025)** は ✅ **修正済み**(ロバスト性優先で P2025→null 化)。
-- C(grep コマンド)は計画ドキュメントの軽微な訂正。nitpick 相当は PR CI に委譲。
diff --git a/docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md b/docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md
deleted file mode 100644
index fb8387749..000000000
--- a/docs/dev-notes/2026-07-05/remove-lucia-v2/survey.md
+++ /dev/null
@@ -1,230 +0,0 @@
-# lucia v2 剥がし: 影響範囲調査と互換性維持移行計画
-
-> **For agentic workers:** 実装開始にはユーザーの明示的な同意が必要(計画承認 ≠ 実装開始)。実装時は superpowers:executing-plans または superpowers:subagent-driven-development を使用。
-
-**Goal:** EOL となった `lucia@2.7.7` + `@lucia-auth/adapter-prisma@3.0.2` を、**DB マイグレーションゼロ・既存パスワード/ログイン中セッション完全互換**で自前セッション実装に置換し、Prisma 本体アップデート(5.22 固定の解消)のブロッカーを除去する。
-
-**関連:** [lucia deprecation 告知](https://github.com/lucia-auth/lucia/discussions/1707) / [#682](https://github.com/AtCoder-NoviSteps/AtCoderNoviSteps/issues/682)(lucia は対象外と明記 → 本作業は**新規 issue を作成**して #682 から参照) / 移行参考例: [the-road-to-next-app#9](https://github.com/rwieruch/the-road-to-next-app/pull/9)
-
----
-
-## 調査結果(影響範囲)
-
-lucia API の呼び出しは**実質 7 ファイルに集約**されており、影響範囲は限定的。
-
-| ファイル                                   | 使用 API                                                                                              |
-| ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
-| `src/lib/server/auth.ts`                   | `lucia()` 初期化(prisma adapter, sveltekit middleware, getUserAttributes)                             |
-| `src/hooks.server.ts`                      | `auth.handleRequest(event)` → `locals.auth` / `validate()`                                            |
-| `src/app.d.ts`                             | `Locals.auth: import('lucia').AuthRequest`、`Lucia` namespace                                         |
-| `src/routes/(auth)/signup/+page.server.ts` | `createUser` / `createSession` / `setSession` / `LuciaError`(AUTH_DUPLICATE_KEY_ID)                   |
-| `src/routes/(auth)/login/+page.server.ts`  | `useKey` / `createSession` / `setSession` / `LuciaError`(AUTH_INVALID_KEY_ID / AUTH_INVALID_PASSWORD) |
-| `src/routes/(auth)/logout/+page.server.ts` | `invalidateSession` / `setSession(null)`                                                              |
-| `src/routes/users/edit/+page.server.ts`    | `setSession(null)`(アカウント削除後)                                                                  |
-| `prisma/seed.ts`                           | `generateLuciaPasswordHash`(`lucia/utils`)                                                            |
-
-- `locals.auth.validate()` の呼び出しは約 25 ファイルにあるが、大半は `getLoggedInUser` / `validateAdminAccess` 等のサービス層ガード(`src/features/auth/services/`)経由。**locals API の形状を維持すればこれらは全て無変更**
-- 未使用 API: `deleteUser` / `updateKeyPassword` / `createKey` / `invalidateAllUserSessions` / OAuth / 2FA / パスワードリセット → 再実装不要
-- アカウント削除は `db.user.delete` + `onDelete: Cascade` で lucia 非依存(変更不要)
-- ユニットテストは lucia 本体でなく `locals.auth.validate` をモック → **形状維持ならテストも無変更**
-- E2E(signin / redirect_after_login / user_edit 等)はシードユーザーで実ログイン → そのまま回帰安全網になる
-
-### prisma adapter の実装調査(2026-07-11 追記)
-
-`@lucia-auth/adapter-prisma@3.0.2`(`dist/prisma.js`、実質 230 行)を全読し、lucia core の呼び出しと突き合わせた結果、**adapter は隠れたロジックゼロの薄い CRUD ラッパーで安全に剥がせる**と確定。暗号処理・状態・独自スキーマ要求は一切なし。
-
-全 15 メソッド中、本アプリのホットパスに乗るのは 7 つのみ:
-
-| アプリの呼び出し箇所                         | lucia core 経由で呼ばれる adapter メソッド                          |
-| -------------------------------------------- | ------------------------------------------------------------------- |
-| `locals.auth.validate()`(hooks 全リクエスト) | `getSession` → `getUser`(2 クエリ)、idle 延長時のみ `updateSession` |
-| signup `createUser`                          | `setUser(user, key)` — `$transaction` で user + key 同時 create     |
-| signup/login `createSession`                 | `getUser` + `setSession`(並列)                                      |
-| login `useKey`                               | `getKey`                                                            |
-| logout `invalidateSession`                   | `deleteSession`                                                     |
-
-未使用: `deleteUser` / `updateUser` / `getSessionsByUserId` / `deleteSessionsByUserId` / `setKey` / `deleteKey` / `deleteKeysByUserId` / `updateKey` / `getKeysByUserId`。
-
-adapter が担う「CRUD 以外」の責務は 3 つだけで、全て自前実装で吸収可能:
-
-1. **BigInt → Number 変換**(`transformPrismaSession`): schema の `active_expires` / `idle_expires` は `BigInt` 型。Prisma の読み取りは `bigint` を返すため、自前 `validateSession` でも `Number()` 変換してから期限比較が必要。書き込みは lucia core が Number をそのまま渡しており(prod で実証済み)、ms epoch は 2^53 未満なので精度問題なし
-2. **Prisma エラー → LuciaError 変換**:
-   - `P2002`(setUser)→ `AUTH_DUPLICATE_KEY_ID`。ただし変換条件は ``message.includes('`id`')`` の部分一致のみで、`username` 列の P2002 は生の Prisma エラーのまま素通し。signup ルートは既に両方を catch している(`signup/+page.server.ts:68-69`)ため、Phase 4 の「P2002 ハンドリングに一本化」で完全にカバーされる
-   - `P2025`(deleteSession)→ **握りつぶし**。⚠️ logout ルートは catch なしで `invalidateSession` を呼ぶため、二重ログアウト等で行が既に無い場合、自前実装でも P2025 を握りつぶさないと 500 になる(Phase 2 に反映済み)
-   - `P2003`(setSession)→ `AUTH_INVALID_USER_ID`。signup では user 作成直後にセッション作成するため実質発生不能。再現不要
-3. **モデル名・列名のハードコード**(`client["user"]` / `user_id` / `hashed_password` 等): schema が snake_case に固定されている根本原因。剥がせば命名自由になるが、本移行は互換最優先でスキーマ無変更
-
-補足: adapter は `getSessionAndUser`(session + user の 1 クエリ取得)を未実装のため、現行 validate はコールドパスで毎回 2 クエリ。自前実装で `include: { user: true }` にすれば 1 クエリに減らせる(挙動不変の最適化・任意)。
-
-## 互換性判定: 完全互換で剥がし可能(根拠は実測値)
-
-node_modules の lucia 2.7.7 実装を直読して以下を確定した。全て標準 `node:crypto` で再現可能(デプロイ先は Vercel serverless = Node ランタイム)。
-
-### パスワードハッシュ(`lucia/dist/utils/crypto.js`)
-
-- 形式: `s2:{salt}:{hash}`。salt = 16 文字 `[a-z0-9]`、hash = scrypt(**N=16384, r=16, p=1, dkLen=64**) の hex
-- 入力は **NFKC 正規化**(`password.normalize('NFKC')`)、比較は constant-time(lucia は手書き XOR ループ。`timingSafeEqual` で置換する場合は**長さ不一致で throw するため事前の長さチェック必須**)
-- 旧 2 パート形式 `{salt}:{hash}`(lucia v1 由来、r=8)フォールバック: **実装しない**。git 履歴確認(ffe902d8、2023-09-20 の初回導入コミット)で本プロジェクトは lucia `^2.6.0` から開始しており、v1 形式ハッシュは prod に存在し得ない(2026-07-05 レビューで削除決定)
-- bcrypt 形式(`$2a` 始まり、v2 beta 期のみ)は lucia が `AUTH_OUTDATED_PASSWORD` を throw(login では 500 応答)するが、自前実装では**未知形式として false を返す**(400 のログイン失敗に統一。互換の唯一の意図的逸脱、実害なし)
-- ⚠️ `node:crypto` の `scrypt` は要 `maxmem` 指定(128×N×r = 32MiB が既定上限に抵触。**64MiB を明示**)
-
-### セッション(`lucia/dist/auth/index.js`, `request.js`)
-
-- ID: 40 文字ランダム `[a-z0-9]`、`session` テーブルに**平文**保存(トークンハッシュ化なし)
-- 期限: `active_expires` = 発行 +24h、`idle_expires` = active +14 日(ms epoch, BigInt)
-- 検証: idle 超過 → 無効(**行削除なし**・cookie クリアのみ。期限切れ行は DB に残留する — v2 は v1 の autoDatabaseCleanup を廃止済み)/ active 内 → 有効(書き込みなし)/ idle 内 → **同一 ID のまま期限を延長**(UPDATE のみ。ID ローテーション無し)。延長時、`AuthRequest.setSession` は同一 ID のため early return し **cookie は再セットされない** → cookie の Expires は発行時の idle_expires で固定(= 継続利用でも発行から最長 15 日でブラウザ側 cookie が消え再ログイン)。**この 2 点とも v2 の実挙動どおり再現する**(2026-07-05 レビューで決定。行削除・cookie 延長は挙動変更となるため見送り、残課題へ)
-- リクエスト内キャッシュ: `validate()` は同一リクエストで 2 回目以降キャッシュを返す(hooks + ルートの二重呼び出しで DB を 2 度叩かない)
-
-### Cookie(`lucia/dist/auth/cookie.js`)
-
-- 名前 `auth_session` / 値 = セッション ID / `path=/`, `httpOnly`, `sameSite=lax`, `secure`(PROD のみ) / `expires` = idle_expires(永続 cookie)
-
-### その他
-
-- ユーザー ID: `createUser` が 15 文字ランダム `[a-z0-9]` を生成 → 同形式を踏襲
-- Key: `key.id` = `username:{小文字化ユーザー名}`、`hashed_password` 列 → テーブル・形式そのまま使用
-- CSRF: lucia の origin チェックは SvelteKit 標準の `checkOrigin`(既定有効・無効化されていないことを確認済み)が同等機能を提供 → 削除して安全。補強確認: `+server.ts` に POST/PUT/PATCH/DELETE はゼロ(全て GET)のため、保護対象はフォーム action のみ = checkOrigin の守備範囲に完全に収まる
-
-**結論: schema.prisma・migration・cookie 名・ハッシュ形式・セッション行を一切変えずに剥がせる。デプロイしてもユーザーは誰もログアウトされず、パスワードもそのまま通る。**
-
-## 設計方針(ユーザー決定事項)
-
-1. **移行先 = 自前セッション実装・スキーマ無変更**(lucia 作者公認の後継パターン。`sv create` の「lucia」テンプレートもライブラリ非依存の同方式)
-2. **既存ログイン中セッションは完全維持**(v2 の active/idle 二重期限セマンティクスを再現)
-3. **scrypt 互換を継続**(新規ユーザーも `s2:` 形式。追加依存ゼロ、DB 内ハッシュ形式が単一)
-4. **Prisma 本体アップデートは別 PR**(本移行は「挙動不変で剥がす」に限定)
-5. **locals API は同形状を維持**(`locals.auth = { validate, setSession }`。呼び出し側約 25 ファイル+テストは無変更。validate 戻り値の実利用フィールドは `sessionId` / `user.userId` / `user.username` / `user.role` のみと grep で全数確認済み)
-6. **新規 issue を作成**して管理(#682 から参照)
-7. **期限切れセッション行は削除しない**(v2 実挙動どおり。掃除は残課題)
-8. **idle 延長時に cookie は再セットしない**(v2 実挙動どおり。cookie 期限延長は残課題)
-9. **旧 2 パート形式フォールバックは実装しない**(v2.6 開始のため対象ハッシュが存在し得ない。`s2:` のみ検証、未知形式は false)
-10. **bcrypt `$2a` は false 返し**(500 → 400 の意図的逸脱として明記)
-
-### oslo / @oslojs の採用評価(不採用)
-
-- `oslo` パッケージ本体は **2025-01 に deprecated**(後継は `@oslojs/*`)
-- `@oslojs/crypto`(1.0.1, 最終更新 2024-09)は sha/hmac/ecdsa 等の「ランタイム非依存プリミティブ」で、**scrypt を含まない** → 本件のハッシュ互換には使えない
-- `@oslojs` の存在意義は `node:crypto` が無いエッジランタイム向け。本プロジェクトは Node ランタイムなので `node:crypto`(scrypt / randomBytes / timingSafeEqual / sha256 全部入り)で完結
-- sv テンプレートが `@oslojs/crypto` を使うのは「セッショントークンを sha256 でハッシュ化して保存する」新方式のため。本件は lucia v2 の平文 ID 形式を維持するので不要
-- → **依存ゼロが本移行の目的に最も整合**。将来トークンハッシュ化等の強化をする場合も `node:crypto` で足りる
-
-## 却下した代替案
-
-1. **新スキーマへ刷新**(the-road-to-next#9 の完全踏襲: token ハッシュ保存 + key 廃止): DB 破壊的変更+データ移行が必要で「互換最優先」に反する。終着点の綺麗さより安全性
-2. **別ライブラリ(better-auth / Auth.js)**: 独自スキーマ強制で破壊的変更が不可避。username+password のみの要件に過剰。「ライブラリ作者都合の EOL」リスクを再び抱える
-3. **argon2 への lazy 移行**: 二重検証パス+依存追加+移行状態の混在。scrypt は OWASP 許容関数であり現時点で YAGNI(将来必要なら検証側の形式分岐に追加するだけ)
-4. **locals.session/user 式への再設計を同時実施**: ルート約 25 ファイル+テストの大量修正が最高リスク PR に混入する。必要なら後続の独立リファクタとして起案
-
-## フェーズ計画
-
-各フェーズで `pnpm test:unit` / `pnpm check` / `pnpm lint` / `pnpm build` 全通過を維持。1 ブランチ 1 PR(フェーズはコミット単位)。
-
-### Phase 1: 互換性フィクスチャ + パスワードユーティリティ(TDD)
-
-- **lucia が残っているうちに** `generateLuciaPasswordHash` で既知パスワード(シードの `Ch0kuda1` 等)のハッシュを生成し、テストフィクスチャとして固定(互換性の錨)
-- `src/lib/server/password.ts`(新規): `hashPassword` / `verifyPassword`。`s2:` 形式再現(NFKC / N=16384, r=16, p=1, dkLen=64 / maxmem 64MiB / `timingSafeEqual`(長さ不一致は事前チェックで false))。**`s2:` 以外の形式(旧 2 パート・bcrypt `$2a` 含む)は一律 false**
-- テスト: 自己ラウンドトリップ + **lucia 生成フィクスチャの検証一致** + 不一致/形式不正(2 パート・`$2a`・空文字)の拒否
-
-### Phase 2: セッションサービス(TDD)
-
-- `src/lib/server/session.ts`(新規): `createSession(userId)` / `validateSession(sessionId)` / `invalidateSession(sessionId)` + cookie 生成ヘルパー。v2 セマンティクス(24h/14d、idle 内は同一 ID で延長=UPDATE のみ、**idle 超過は null 返しのみで行削除しない**)と cookie 属性を上記実測値どおり実装
-- **BigInt 変換**: `active_expires` / `idle_expires` は Prisma が `bigint` で返すため、期限比較の前に `Number()` 変換必須(書き込みは Number のままで可 — 現行 adapter と同じ)
-- **`invalidateSession` は P2025 を握りつぶす**(logout の冪等性。現行 adapter の deleteSession と同挙動。logout ルートは catch なしで呼ぶため、握りつぶさないと二重ログアウトで 500)
-- テスト: `vi.mock('$lib/server/database')` で active(書き込みなし)/ idle 延長(UPDATE のみ・DELETE なし)/ 期限切れ(null 返し・**DELETE が呼ばれないことを検証**)/ 行なし の 4 状態を網羅。時刻は `vi.useFakeTimers`。加えて **invalidateSession の P2025 握りつぶし**と **BigInt を返す mock での期限比較**(Number を返す mock だと変換漏れを見逃す)を含める
-
-### Phase 3: locals.auth 互換オブジェクト + hooks + 型
-
-- `src/lib/server/auth.ts` に `createAuthRequest(event)` を**追加**: `{ validate, setSession }` を返す(validate はリクエスト内キャッシュ付き)。**lucia の `auth` export はこの時点では削除しない**(signup / login / logout ルートが Phase 4 まで使用。消すと本フェーズのコミットで `pnpm check` / `build` が落ちる)
-- 返すセッション形状は現行利用箇所に合わせ `{ sessionId, user: { userId, username, role } }` を維持。**無効セッション時は cookie クリア、idle 延長時は cookie を触らない**(v2 の `storedSessionId === sessionId` ガードと同挙動)
-- Phase 3〜4 の間は lucia の `createSession` が返す Session オブジェクトが自前 `setSession` に渡るため、cookie 生成は `sessionId` と `idlePeriodExpiresAt`(Date)のみ参照する(Phase 2 の自前セッションにも同名フィールドを持たせて Phase 4 の差し替えを無変更にする)
-- `src/hooks.server.ts`: `auth.handleRequest(event)` → `createAuthRequest(event)` に差し替え(以降のロジック不変)
-- `src/app.d.ts`: `Locals.auth` の型のみ `import('lucia').AuthRequest` → 自前型に置換。**`Lucia` namespace と `/// <reference types="lucia" />` は削除しない**(lucia インスタンスの型解決に必要。削除は Phase 4)
-- サービス層ガード・ルート約 25 ファイルは**無変更**であることを test:unit で確認
-
-### Phase 4: 認証ルート置換 + seed 置換 + 依存削除
-
-- signup: `auth.createUser` → `prisma.$transaction`(user + key 作成。userId は 15 文字 `[a-z0-9]`、key.id は `username:{小文字}`)。重複は既存の P2002 ハンドリングに一本化(`LuciaError` 分岐削除)。**ユーザー向けメッセージは現行文言を厳守**(E2E が文言依存)
-- login: `auth.useKey` → key 取得 + `verifyPassword`。エラーメッセージ・挙動(キー無し/パスワード不一致を同一応答にしている現行仕様)を維持
-- logout: `invalidateSession`(行削除)+ cookie クリアヘルパーへ置換
-- users/edit(アカウント削除): **cookie クリアのみ**(session 行は `user.delete` の `onDelete: Cascade` で消えるため `invalidateSession` は呼ばない — 調査結果表のとおり現行も `setSession(null)` のみ)
-- `prisma/seed.ts`: `generateLuciaPasswordHash` → 自前 `hashPassword`(seed からの import は `$lib` alias 不可のため相対パス。tsx 実行で通ることを確認)
-- `src/lib/server/auth.ts` の lucia 初期化 export 削除、`src/app.d.ts` の `Lucia` namespace / `/// <reference types="lucia" />` 削除(Phase 3 から繰り延べた分)
-- `package.json` から `lucia` / `@lucia-auth/adapter-prisma` 削除 → `pnpm install` → リポジトリ全体 grep で残存 import ゼロ確認(コメント内の言及も棚卸し)
-
-### Phase 5: 検証 + 仕上げ
-
-- `pnpm test:e2e` 全通過(signin / signup 系 / redirect_after_login / user_edit / votes / workbooks)
-- **セッション継続の実機確認**: 移行前コードで dev 起動 → ログイン → cookie 保持のまま移行後コードで再起動 → ログイン状態が維持されること
-- **パスワード互換の実機確認**: 移行前に作成したユーザー(シード含む)で移行後にログイン成功すること
-- `pnpm format` → `coderabbit review --plain` → critical/high/medium 所見を本ファイル `## CodeRabbit Findings` に記録(修正はユーザー判断)
-
-## リスクと対策
-
-| リスク                                                  | 対策                                                                                                               |
-| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
-| scrypt パラメータの再現ミス → 全ユーザーログイン不能    | Phase 1 の lucia 生成フィクスチャ照合テストで機械的に担保。maxmem 未指定エラーはテストで即検出                     |
-| セッション期限判定の再現ミス → 意図しない一斉ログアウト | Phase 2 で 4 状態を fake timer で網羅。Phase 5 で実機のセッション継続確認                                          |
-| CSRF 保護の喪失                                         | SvelteKit `checkOrigin`(既定有効)が同等機能を提供済みであることを確認済み。無効化しないこと                        |
-| 本番デプロイ後の障害                                    | DB 変更ゼロのため**ロールバック = 直前リリースへの再デプロイのみ**で完結(切り戻し容易性が本方式の最大の利点)       |
-| ~~prod に lucia v1 時代の旧形式ハッシュが残存~~         | **解消済み**: git 履歴(ffe902d8)で lucia `^2.6.0` からの開始を確認 → v1 形式は存在し得ず、フォールバック自体を削除 |
-
-## 残課題(本移行に含めない後続作業)
-
-- Prisma 5.22 → 6/7 アップデート(本移行完了で解禁。別 issue / 別 PR)
-- **期限切れセッション行の掃除**(v2 は削除しないため現行 prod にも死に行が蓄積中。定期削除 or 検証時削除を別途検討)
-- **idle 延長時の cookie 期限延長**(v2 は再セットしないため継続利用でも発行から最長 15 日で要再ログイン。延長するとセッション寿命が実質無期限化するためトレードオフ判断が必要)
-- `locals.session` / `locals.user` 式への locals API 再設計(任意。full-codebase-refactoring 計画との整合を取って起案)
-- `key` テーブル廃止・`user` へのパスワード列統合等のスキーマ整理(任意。互換要件が解けた後)
-- パスワードリセット機能(別 PR。下記補遺参照)
-
-## QA: 理解確認と批判的レビュー(2026-07-15 追記)
-
-ソース根拠: `lucia/dist/auth/index.js` / `lucia/dist/utils/crypto.js` / `@lucia-auth/adapter-prisma/dist/prisma.js`。
-
-- **呼び出しチェーン**: `app → lucia core(公開 API)→ adapter(CRUD)` で正しい。例: `auth.createUser` は core 側で userId 生成(15 文字)+パスワードハッシュ化を行い、`adapter.setUser(user, key)` に渡す(`auth/index.js:160-180`)。通常の利用では意識不要だが、剥がしでは **core のロジックと adapter の CRUD の両方**を自前実装が吸収する(Phase 4 で 2 層を Prisma 直呼びに畳む)
-- **メソッド名の差異(createUser vs setUser)**: 名前衝突の回避ではなく**レイヤ分離**。公開 API はドメイン語彙(create / use / invalidate)、adapter インターフェースは全 DB アダプタ共通のストレージ語彙(get / set / update / delete)。公開 1 メソッドが adapter 1〜n 呼び出しに対応する(createSession → getUser + setSession)
-- **salt**: パスワードごとに生成するランダム値(16 文字 `[a-z0-9]`)で、ハッシュ入力に混ぜる。目的は「同じパスワードでも毎回異なるハッシュ」にしてレインボーテーブル(事前計算)攻撃を無効化すること。**秘密ではない**ため `s2:{salt}:{hash}` に平文で埋め込まれる。ユーザー間の一意性保証は不要(十分ランダムであればよい)
-- **暗号化ではなくハッシュ(一方向)**: 復号は存在しない。検証は「入力パスワード + 保存済み salt で scrypt を再計算 → 保存済みハッシュと定数時間比較」
-- **NFKC 正規化**: 同じ見た目の文字列でも Unicode 表現が複数あり得る(全角/半角、合成/分解済み文字)ため、バイト列を一意化してからハッシュする。実務上の含意は 1 つ: **自前 verify でも必ず正規化する**(漏れると非 ASCII パスワードが照合不能になる)。**(2026-07-15 補正)** `authSchema` のパスワード規則は初回実装(2023-09)から半角英数字限定のため、非 ASCII パスワードは prod のハッシュにも login 入力にも存在し得ない(signup / login とも zod 検証後に crypto 層へ到達)。normalize は実害回避ではなく**アルゴリズム忠実性(lucia 等価)の担保**として維持する
-- **scrypt パラメータ**: scrypt は決定的アルゴリズム(RFC 7914)。同一入力 + 同一 (N, r, p, dkLen) なら出力は**バイト単位で一致する(「可能性が高い」ではなく保証)**。リスクは自前実装側のミス(node:crypto のパラメータ名対応、maxmem、hex 変換、NFKC 漏れ)に集中し、Phase 1 のフィクスチャテストはそれを機械検出する仕組み。担保するのは「冪等性」ではなく**互換性(等価性)**。salt がランダムなため生成ハッシュ同士の直接比較はできず、「lucia 生成ハッシュを自前 verify が受理する」形で検証する(固定 salt の hex 直接比較テストを足すとさらに強い)
-- **セッション ID の平文保存**: ID は 40 文字ランダム(約 207 bit)のサーバ生成トークンで、低エントロピーかつ使い回されるパスワードとは脅威モデルが異なるため平文でも許容範囲。残るリスクは「DB 読み取り漏洩 → セッション乗っ取り」で、新方式(sv テンプレート等)が sha256 保存するのはこのため。ただし**トークンハッシュ化は後からでも無停止で移行可能**(既存行を一括ハッシュ化しても cookie は平文トークンのままで、検証側がハッシュして照合すればよい)。「互換性のため永久に仕方ない」ではなく「本移行では挙動不変を優先して見送り」が正確
-- **bcrypt `$2a`**: 本プロジェクト導入前の仕様ではなく、**lucia 自身の v2 beta 期の遺物**(crypto.js に `TODO: remove in v3` 付きでガードが残る)。本プロジェクトは stable `^2.6.0` 開始のため該当ハッシュは存在し得ない。「対処しておく」というより、自前 verify の自然な設計(未知形式 → false)が到達不能ケースを覆うだけ。500 → 400 は唯一の意図的逸脱として記録済み
-- **フェーズ理解の補正**: Phase 2 は新規サービスの作成 + テストのみで**配線はしない**(validate 系の切替は Phase 3、create/invalidate 系は Phase 4)。lucia と adapter の依存削除は Phase 4 の完了後ではなく **Phase 4 の内部タスク**。Phase 5 が E2E + 実機確認(セッション継続・パスワード互換)
-- **⚠️ Phase 3 の順序問題(レビュー指摘・要修正)**: Phase 3 時点では signup / login / logout ルートがまだ lucia の `auth` インスタンス(`createUser` / `useKey` 等)を使うため、`auth.ts` の lucia 初期化 export と `app.d.ts` の `Lucia` namespace は **Phase 4 完了まで削除できない**(消すと Phase 3 コミットで `pnpm check` / `build` が落ちる)。対応案: (i) Phase 3 は `createAuthRequest` を**追加**して hooks を差し替えるに留め、lucia export と型削除を Phase 4 に移す(推奨)、(ii) Phase 3+4 を 1 コミットに統合 → **(i) を採用しフェーズ本文修正済み(2026-07-15)**
-
----
-
-## 補遺: パスワードリセット機能の追加容易性(批判的レビュー・2026-07-05)
-
-**問い:** lucia 剥がしが成功すれば、パスワードリセット追加は「比較的容易」と考えてよいか?
-
-**回答: 半分正しい。** 剥がしは前提整備として有効だが、リセットの主障壁はもともと lucia ではない。難所は「本人確認チャネル」と「トークン基盤+レート制限」で、これらは剥がし後も丸ごと残る。ただし本プロジェクト固有の事情(後述の AtCoder 連携チャネル)を使う設計なら「比較的容易」評価は妥当。
-
-### 剥がしが効く部分(正の効果)
-
-- Phase 1-2 で作る `hashPassword` / セッションサービスがそのまま再利用でき、パスワード更新は `key.hashed_password` の UPDATE 1 本 + 全セッション削除(`deleteMany`)1 本で完結する
-- EOL ライブラリの上に新機能を積まずに済む(先に剥がす順序判断自体は正しい)
-- トークンテーブル等のスキーマ設計が lucia アダプタの命名制約から自由になる(schema.prisma の方針どおり新規モデルは camelCase で書ける)
-
-### 剥がしでは解決しない部分(過大評価に注意)
-
-1. **本人確認チャネルが存在しない(最大の障壁)**: `User` に email 列がない(username + password のみ)。標準的なリセットフロー(メールでトークン送付)は前提から成立しない。なお公平を期すと、lucia v2 にも `updateKeyPassword` / `invalidateAllUserSessions` はあったため「lucia が邪魔でリセットを作れなかった」わけではない — 障壁は当初からチャネル側にある
-2. **トークン基盤は自作が必要**: 公式学習リソース(lucia-auth.com)と [The Copenhagen Book](https://thecopenhagenbook.com/password-reset) の要件 — 十分なエントロピーの乱数トークン、**保存前に SHA-256 でハッシュ化**、有効期限 ~1h(最大 24h)、使い捨て(成功時削除)、**リセット成功時に当該ユーザーの全セッション無効化**、トークンを含むパスへの `Referrer-Policy: strict-origin`、ユーザー列挙を防ぐ曖昧な応答文言。新テーブル + migration が必要(追加のみで非破壊)
-3. **レート制限基盤が現状ない**: Copenhagen Book は発行エンドポイントへの厳格なレート制限を必須としている。Vercel serverless ではインメモリ制限が効かないため、DB ベースの token bucket 等の新規実装になる
-
-### 本人確認チャネルの選択肢(実装コストの支配項)
-
-| 案                         | 概要                                                                                                                                                                                            | コスト     | 備考                                                                                                                                                                                                                                                                                         |
-| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| (a) email 基盤導入         | email 列(既存ユーザーは NULL)+ 確認フロー + 送信プロバイダ + 到達性運用                                                                                                                         | **大**     | 標準的だが基盤導入が本体。「比較的容易」ではない                                                                                                                                                                                                                                             |
-| (b) AtCoder 連携で本人確認 | 既存の `AtCoderAccount`(handle / isValidated / validationCode)検証機構を再利用し、**事前に検証済みの連携**がある場合のみ、AtCoder プロフィール等に新規コードを設置させて本人確認 → リセット許可 | **小〜中** | email 不要・本サービスの利用者特性に合致。制約: 未連携ユーザーは対象外。リスク: AtCoder アカウント侵害 = 本サービス乗っ取り(全セッション無効化とセットで許容範囲か要判断)。**必ず事前検証済み連携に限定**(リセット時に初回連携を許すと、handle を主張するだけで未連携アカウントを乗っ取れる) |
-| (c) 管理者手動リセット     | 現行の「X DM → アカウント移行」を「X DM → ワンタイムリセットリンク/仮パスワード発行(admin 画面)」に置換                                                                                         | **最小**   | 人手プロセスは残るが、移行(回答履歴の付け替え)より運用負荷が大幅に軽い。(b) の対象外ユーザーの受け皿としても機能                                                                                                                                                                             |
-
-現状の回復手段は「X 公式アカウントへ DM → 管理者がアカウント移行」(`forgot_password/+page.svelte`、`(admin)/account_transfer`)であり、ページには「パスワードリセット機能は開発中です」と明記済み。同ページは lucia 公式の [example-sveltekit-email-password-2fa](https://github.com/lucia-auth/example-sveltekit-email-password-2fa) を既にコメント参照している(= email 前提の案 (a) を想定した形跡)。
-
-### 結論
-
-- 「剥がし成功 → リセット容易」の因果は**部分的**。剥がしで得るのは再利用可能な password/session ユーティリティと負債の上積み回避であり、リセット固有の難所(チャネル・トークン・レート制限)は別途残る
-- チャネルに **(b) + (c) の併用**(検証済み連携ユーザーはセルフサービス、それ以外は管理者発行)を選ぶなら「比較的容易」は妥当: 新テーブル 1 つ + サービス層 + ルート 2 つ + 既存検証機構の再利用で収まり、email 基盤が不要
-- **(a) email 基盤を選ぶ場合、「容易」ではない**。email 導入自体が独立した中規模プロジェクト(スキーマ・確認フロー・プロバイダ選定・運用)になる
-- いずれの案でも着手は lucia 剥がし完了後(Phase 1-2 の成果物に依存)。チャネル選択はユーザー判断が必要な設計分岐点

From daf6bc92716f9d3a7772cc47c31f3c6809fd8d53 Mon Sep 17 00:00:00 2001
From: "k.hiro1818" <k.hiro1818@gmail.com>
Date: Thu, 16 Jul 2026 03:08:59 +0000
Subject: [PATCH 12/12] style(seed): rename local var to camelCase per naming
 convention

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 prisma/seed.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prisma/seed.ts b/prisma/seed.ts
index 40e3dbba9..bf1f7bea3 100755
--- a/prisma/seed.ts
+++ b/prisma/seed.ts
@@ -129,12 +129,12 @@ async function addUser(
     username: user.name,
     role: user.role,
   });
-  const hashed_password = await hashPassword(password);
+  const hashedPassword = await hashPassword(password);
 
   await keyFactory.create({
     user: { connect: currentUser },
     id: 'username:' + user.name.toLowerCase(),
-    hashed_password: hashed_password,
+    hashed_password: hashedPassword,
   });
 }