@oimlsmart/platform-server 0.2.4 → 0.2.6

package/migrations/0024_oidc_code_auth_time.sql

@@ -0,0 +1,10 @@
+-- Migration 0024 — the SSO wave-A tail (TODO.identity-sso: RP-initiated
+-- logout + prompt=login): the one-time code carries the consenting
+-- session's authentication instant (sessions.created_at, verbatim), so
+-- the token endpoint emits the ID token's auth_time — the forced
+-- re-authentication's freshness proof the RP verifies. NULL = no
+-- instant recorded (a code minted before this wave).
+-- schema.sql carries the same end state for fresh databases —
+-- src/__tests__/d1-store.test.ts pins the UNION of every migration to
+-- schema.sql's CREATE set.
+ALTER TABLE oidc_codes ADD COLUMN auth_time TEXT;

package/migrations/0025_oidc_refresh_tokens.sql

@@ -0,0 +1,61 @@
+-- Migration 0025 — the SSO wave-C token surface (TODO.identity-sso: the
+-- refresh-token grant with rotation + revocation): the OP's refresh
+-- tokens. A refresh token is the offline half of the remembered consent
+-- (the Relying Party keeps the authorization while the holder is away),
+-- so the row carries the granting code's full provenance: the canonical
+-- scope spelling, the context_org, the amr, and the ORIGINAL
+-- authentication instant (auth_time never advances on a refresh — the
+-- refreshed ID token proves the original authentication, never a new
+-- one).
+--
+-- The doctrines:
+--   - ONE-TIME, atomically consumed (the oidc_codes / email_change_tokens
+--     posture): the exchange's UPDATE … WHERE consumed_at IS NULL flips
+--     exactly once — a replay loses the race;
+--   - the FAMILY: every rotation descends from the first mint and carries
+--     its family_id. A presented CONSUMED token is the theft signal
+--     (RFC 6819 §5.2.2.3): the whole family dies (DELETE WHERE
+--     family_id), so the attacker's copy and the holder's legitimate
+--     chain both end;
+--   - the consumed row STAYS (the reuse detector reads it) until the
+--     family's end: revocation (RFC 7009, client-bound — a client revokes
+--     only its own, and revoking one refresh token revokes the family),
+--     the consent's revocation, the deactivation sweep, and the account
+--     erasure remove the rows outright (the personal_access_tokens
+--     doctrine);
+--   - expiry is per row (the consumer passes ttlMs at each mint; a
+--     rotation slides the window forward on the NEW row). An expired
+--     present is consumed anyway — never a second chance.
+-- schema.sql carries the same end state for fresh databases —
+-- test/migrations.test.ts pins the UNION of every migration to
+-- schema.sql's CREATE set.
+
+CREATE TABLE IF NOT EXISTS oidc_refresh_tokens (
+  token TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id),
+  client_id TEXT NOT NULL,
+  -- The granted scope set, the canonical space-joined spelling
+  -- (normalizeOidcScopeSet) — a refresh never widens it (the route's
+  -- math), the row is the grant's record.
+  scope TEXT NOT NULL,
+  -- The granting code's context — a refreshed access token answers the
+  -- SAME claims the original carried.
+  context_org TEXT,
+  -- The authorizing authentication's amr provenance (a JSON array; NULL =
+  -- none recorded).
+  amr TEXT,
+  -- The ORIGINAL authentication instant (verbatim from the consenting
+  -- session; NULL = none recorded) — carried into every refreshed ID
+  -- token's auth_time.
+  auth_time TEXT,
+  -- The rotation lineage: the first mint's generated id, inherited by
+  -- every rotation. Reuse of a consumed row kills the family.
+  family_id TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  expires_at TEXT NOT NULL,
+  consumed_at TEXT
+);
+-- The deactivation/erasure sweeps + the account console's per-app read.
+CREATE INDEX IF NOT EXISTS idx_oidc_refresh_tokens_user ON oidc_refresh_tokens (user_id);
+-- The reuse-kill + the RFC 7009 family revocation.
+CREATE INDEX IF NOT EXISTS idx_oidc_refresh_tokens_family ON oidc_refresh_tokens (family_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oimlsmart/platform-server",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "The OIML SMART platform server kernel: the store seam (ServerStore + the D1 and SQLite implementations), the canonical D1 migration set both deployments apply, the instance profile, the mailer, the RBAC map, the OIDC/OAuth client cones, and the shared role/permission vocabulary. Consumed by the smart monorepo (browser/) and the identity service.",
   "type": "module",
   "repository": {

package/src/store/d1.ts

@@ -39,6 +39,7 @@ import {
   type AuthUserPayload,
   type CompleteEmailChangeResult,
   type CompleteEnrollmentResult,
+  type ConsumeOidcRefreshTokenResult,
   type EmailChangeToken,
   type EnrollmentToken,
   type EntityChange,
@@ -64,6 +65,7 @@ import {
   type OidcCode,
   type OidcConsentGrant,
   type OidcKeyRow,
+  type OidcRefreshToken,
   consentGrantCovers,
   normalizeOidcScopeSet,
   type OpAccountErasure,
@@ -227,6 +229,7 @@ interface EnsureMemos {
   oidcColumns: Promise<void> | null
   personalAccessTokenSupport: Promise<void> | null
   consentGrantSupport: Promise<void> | null
+  oidcRefreshTokenSupport: Promise<void> | null
   accountEmailSupport: Promise<void> | null
   notifyDeliverySupport: Promise<void> | null
 }
@@ -243,6 +246,7 @@ function ensured(binding: D1Database, slot: keyof EnsureMemos, run: () => Promis
       orgRegistrySupport: null, holderAttributionSupport: null,
       instrumentRegistrationSupport: null, oidcColumns: null,
       personalAccessTokenSupport: null, consentGrantSupport: null,
+      oidcRefreshTokenSupport: null,
       accountEmailSupport: null, notifyDeliverySupport: null,
     }
     ensureMemosByBinding.set(binding, memos)
@@ -640,6 +644,11 @@ export class D1ServerStore implements ServerStore {
       if (!codeCols.results.some(c => c.name === 'amr')) {
         await this.db.prepare('ALTER TABLE oidc_codes ADD COLUMN amr TEXT').run()
       }
+      // TODO.identity-sso (the wave-A tail): the code carries the
+      // consenting session's authentication instant (migration 0024).
+      if (!codeCols.results.some(c => c.name === 'auth_time')) {
+        await this.db.prepare('ALTER TABLE oidc_codes ADD COLUMN auth_time TEXT').run()
+      }
       const tokenCols = await this.db.prepare('PRAGMA table_info(oidc_access_tokens)').all<{ name: string }>()
       if (!tokenCols.results.some(c => c.name === 'amr')) {
         await this.db.prepare('ALTER TABLE oidc_access_tokens ADD COLUMN amr TEXT').run()
@@ -701,6 +710,33 @@ export class D1ServerStore implements ServerStore {
     })
   }
 
+  // TODO.identity-sso (the wave-C token surface): the oidc_refresh_tokens
+  // table arrives with migration 0025 — a dev D1 migrated from before it
+  // lacks the table, so the refresh methods (and the deactivation sweep)
+  // ensure it defensively (the ensureConsentGrantSupport posture,
+  // memoized per (binding, chain) at module scope).
+  private ensureOidcRefreshTokenSupport(): Promise<void> {
+    return ensured(this.binding, 'oidcRefreshTokenSupport', async () => {
+      await this.db.prepare(
+        `CREATE TABLE IF NOT EXISTS oidc_refresh_tokens (
+           token TEXT PRIMARY KEY,
+           user_id TEXT NOT NULL REFERENCES users(id),
+           client_id TEXT NOT NULL,
+           scope TEXT NOT NULL,
+           context_org TEXT,
+           amr TEXT,
+           auth_time TEXT,
+           family_id TEXT NOT NULL,
+           created_at TEXT NOT NULL DEFAULT (datetime('now')),
+           expires_at TEXT NOT NULL,
+           consumed_at TEXT
+         )`,
+      ).run()
+      await this.db.prepare('CREATE INDEX IF NOT EXISTS idx_oidc_refresh_tokens_user ON oidc_refresh_tokens (user_id)').run()
+      await this.db.prepare('CREATE INDEX IF NOT EXISTS idx_oidc_refresh_tokens_family ON oidc_refresh_tokens (family_id)').run()
+    })
+  }
+
   // TODO.identity-features/01 (multiple emails per account): the
   // account_emails table + the email_change_tokens.kind column arrive
   // with migration 0022 — a dev D1 migrated from before it lacks both,
@@ -862,11 +898,11 @@ export class D1ServerStore implements ServerStore {
     // reassignment takes effect on the next request; deactivation ends
     // the session at once.
     const session = await this.stmt(
-      `SELECT s.user_id, s.active_org, s.amr, u.email, u.name, u.role, u.roles, u.org_id, u.avatar_url, u.provider, u.email_verified_at
+      `SELECT s.user_id, s.active_org, s.amr, s.created_at, u.email, u.name, u.role, u.roles, u.org_id, u.avatar_url, u.provider, u.email_verified_at
        FROM sessions s JOIN users u ON s.user_id = u.id
        WHERE s.token = ? AND s.expires_at > datetime('now') AND u.active = 1`,
       token,
-    ).first<{ user_id: string; active_org: string | null; amr: string | null; email: string; name: string; role: string; roles: string | null; org_id: string | null; avatar_url: string | null; provider: string; email_verified_at: string | null }>()
+    ).first<{ user_id: string; active_org: string | null; amr: string | null; created_at: string; email: string; name: string; role: string; roles: string | null; org_id: string | null; avatar_url: string | null; provider: string; email_verified_at: string | null }>()
     if (!session) return null
     const amr = parseRoles(session.amr)
     const payload: AuthUserPayload = {
@@ -880,6 +916,9 @@ export class D1ServerStore implements ServerStore {
       provider: session.provider,
       emailVerifiedAt: session.email_verified_at ?? null,
       ...(amr?.length ? { amr } : {}),
+      // TODO.identity-sso (the wave-A tail): the authentication instant —
+      // the ID token's auth_time derives from it (the consumer converts).
+      sessionCreatedAt: session.created_at,
     }
     // TODO.identity/11: the active-org context (the membership model) —
     // the payload's org/roles follow the session's stamped context. The
@@ -1295,16 +1334,20 @@ export class D1ServerStore implements ServerStore {
      *  (stored as JSON; the token endpoint emits it as the ID token's
      *  amr). Absent = no provenance recorded. */
     amr?: string[] | null
+    /** TODO.identity-sso (the wave-A tail): the consenting session's
+     *  authentication instant (verbatim; absent = none recorded) — the
+     *  token endpoint emits it as the ID token's auth_time. */
+    authTime?: string | null
     ttlMs: number
   }): Promise<void> {
     await this.ensureMembershipSupport()
     const expiresAt = new Date(Date.now() + input.ttlMs).toISOString()
     await this.ensureOidcColumns()
     await this.stmt(
-      `INSERT INTO oidc_codes (code, client_id, redirect_uri, scope, nonce, code_challenge, user_id, context_org, amr, expires_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      `INSERT INTO oidc_codes (code, client_id, redirect_uri, scope, nonce, code_challenge, user_id, context_org, amr, auth_time, expires_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       input.code, input.clientId, input.redirectUri, input.scope, input.nonce, input.codeChallenge, input.userId, input.contextOrg ?? null,
-      input.amr?.length ? JSON.stringify(input.amr) : null, expiresAt,
+      input.amr?.length ? JSON.stringify(input.amr) : null, input.authTime ?? null, expiresAt,
     ).run()
   }
 
@@ -1330,6 +1373,7 @@ export class D1ServerStore implements ServerStore {
       userId: row.user_id as string,
       contextOrg: (row.context_org as string | null) ?? null,
       amr: parseRoles((row.amr as string | null) ?? null) ?? null,
+      authTime: (row.auth_time as string | null) ?? null,
       expiresAt: row.expires_at as string,
     }
   }
@@ -1360,7 +1404,7 @@ export class D1ServerStore implements ServerStore {
   async getOidcAccessToken(token: string): Promise<OidcAccessToken | null> {
     await this.ensureMembershipSupport()
     const row = await this.stmt(
-      "SELECT * FROM oidc_access_tokens WHERE token = ? AND expires_at > datetime('now')", token,
+      "SELECT * FROM oidc_access_tokens WHERE token = ? AND datetime(expires_at) > datetime('now')", token,
     ).first<Record<string, unknown>>()
     if (!row) return null
     return {
@@ -1374,6 +1418,124 @@ export class D1ServerStore implements ServerStore {
     }
   }
 
+  /** The account console's per-app read + the governance view's per-user
+   *  slice: the account's LIVE access tokens, newest first — created_at
+   *  is second-resolution, the rowid breaks the tie. */
+  async listOidcAccessTokens(userId: string): Promise<OidcAccessToken[]> {
+    await this.ensureMembershipSupport()
+    const res = await this.stmt(
+      "SELECT * FROM oidc_access_tokens WHERE user_id = ? AND datetime(expires_at) > datetime('now') ORDER BY created_at DESC, rowid DESC", userId,
+    ).all<Record<string, unknown>>()
+    return res.results.map(row => ({
+      token: row.token as string,
+      userId: row.user_id as string,
+      clientId: row.client_id as string,
+      scope: row.scope as string,
+      contextOrg: (row.context_org as string | null) ?? null,
+      amr: parseRoles((row.amr as string | null) ?? null) ?? null,
+      expiresAt: row.expires_at as string,
+    }))
+  }
+
+  /** The RFC 7009 access-token revocation: the row goes, client-bound. */
+  async deleteOidcAccessToken(token: string, clientId: string): Promise<boolean> {
+    await this.ensureMembershipSupport()
+    const res = await this.stmt(
+      'DELETE FROM oidc_access_tokens WHERE token = ? AND client_id = ?', token, clientId,
+    ).run()
+    return (res.meta.changes ?? 0) > 0
+  }
+
+  private static toRefreshToken(row: Record<string, unknown>): OidcRefreshToken {
+    return {
+      token: row.token as string,
+      userId: row.user_id as string,
+      clientId: row.client_id as string,
+      scope: row.scope as string,
+      contextOrg: (row.context_org as string | null) ?? null,
+      amr: parseRoles((row.amr as string | null) ?? null) ?? null,
+      authTime: (row.auth_time as string | null) ?? null,
+      familyId: row.family_id as string,
+      createdAt: row.created_at as string,
+      expiresAt: row.expires_at as string,
+      consumedAt: (row.consumed_at as string | null) ?? null,
+    }
+  }
+
+  async createOidcRefreshToken(input: {
+    token: string
+    userId: string
+    clientId: string
+    scope: string
+    contextOrg?: string | null
+    amr?: string[] | null
+    authTime?: string | null
+    familyId: string
+    ttlMs: number
+  }): Promise<OidcRefreshToken> {
+    await this.ensureMembershipSupport()
+    await this.ensureOidcRefreshTokenSupport()
+    const expiresAt = new Date(Date.now() + input.ttlMs).toISOString()
+    await this.stmt(
+      `INSERT INTO oidc_refresh_tokens (token, user_id, client_id, scope, context_org, amr, auth_time, family_id, expires_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      input.token, input.userId, input.clientId, input.scope, input.contextOrg ?? null,
+      input.amr?.length ? JSON.stringify(input.amr) : null, input.authTime ?? null, input.familyId, expiresAt,
+    ).run()
+    const row = await this.stmt('SELECT * FROM oidc_refresh_tokens WHERE token = ?', input.token).first<Record<string, unknown>>()
+    return D1ServerStore.toRefreshToken(row as Record<string, unknown>)
+  }
+
+  /** The refresh exchange's consume: the UPDATE flips consumed_at exactly
+   *  once — a replay loses the race, reads the consumed row back, and the
+   *  WHOLE FAMILY dies (the theft signal, RFC 6819 §5.2.2.3; a concurrent
+   *  double-present lands the same verdict — fail toward invalidation).
+   *  An expired live row is consumed anyway (never a second chance) and
+   *  answers 'invalid'. */
+  async consumeOidcRefreshToken(token: string): Promise<ConsumeOidcRefreshTokenResult> {
+    await this.ensureMembershipSupport()
+    await this.ensureOidcRefreshTokenSupport()
+    const res = await this.stmt(
+      "UPDATE oidc_refresh_tokens SET consumed_at = datetime('now') WHERE token = ? AND consumed_at IS NULL", token,
+    ).run()
+    if ((res.meta.changes ?? 0) > 0) {
+      const row = await this.stmt('SELECT * FROM oidc_refresh_tokens WHERE token = ?', token).first<Record<string, unknown>>()
+      if (!row) return { kind: 'invalid' }
+      if (new Date(row.expires_at as string).getTime() <= Date.now()) return { kind: 'invalid' }
+      return { kind: 'ok', token: D1ServerStore.toRefreshToken(row) }
+    }
+    const row = await this.stmt('SELECT * FROM oidc_refresh_tokens WHERE token = ?', token).first<Record<string, unknown>>()
+    if (!row) return { kind: 'invalid' }
+    // The reuse signal: the consumed row's family dies outright.
+    const familyId = row.family_id as string
+    await this.stmt('DELETE FROM oidc_refresh_tokens WHERE family_id = ?', familyId).run()
+    return { kind: 'reuse', familyId, userId: row.user_id as string, clientId: row.client_id as string }
+  }
+
+  /** The RFC 7009 refresh revocation, client-bound: the presented token's
+   *  family goes (never another client's rows). */
+  async revokeOidcRefreshToken(token: string, clientId: string): Promise<boolean> {
+    await this.ensureMembershipSupport()
+    await this.ensureOidcRefreshTokenSupport()
+    const row = await this.stmt(
+      'SELECT family_id FROM oidc_refresh_tokens WHERE token = ? AND client_id = ?', token, clientId,
+    ).first<{ family_id: string }>()
+    if (!row) return false
+    await this.stmt('DELETE FROM oidc_refresh_tokens WHERE family_id = ?', row.family_id).run()
+    return true
+  }
+
+  /** The consent revocation's companion: the (account, client) pair's
+   *  refresh rows all go. */
+  async deleteOidcRefreshTokensForUserClient(userId: string, clientId: string): Promise<number> {
+    await this.ensureMembershipSupport()
+    await this.ensureOidcRefreshTokenSupport()
+    const res = await this.stmt(
+      'DELETE FROM oidc_refresh_tokens WHERE user_id = ? AND client_id = ?', userId, clientId,
+    ).run()
+    return res.meta.changes ?? 0
+  }
+
   async listOidcKeys(): Promise<OidcKeyRow[]> {
     const res = await this.stmt('SELECT * FROM oidc_keys ORDER BY created_at, kid').all<Record<string, unknown>>()
     return res.results.map(row => ({
@@ -1829,16 +1991,21 @@ export class D1ServerStore implements ServerStore {
   }
 
   /** The deactivation's revocation half: every live session, every issued
-   *  access token, every unconsumed code and pending authorization goes.
-   *  The user row STAYS (the history). */
-  async revokeOpUserCredentials(userId: string): Promise<{ sessions: number; accessTokens: number; codes: number; authorizations: number }> {
+   *  access token, every refresh token (migration 0025 — the ensure runs
+   *  first: a dev D1 from before it lacks the table), every unconsumed
+   *  code and pending authorization goes. The user row STAYS (the
+   *  history). */
+  async revokeOpUserCredentials(userId: string): Promise<{ sessions: number; accessTokens: number; refreshTokens: number; codes: number; authorizations: number }> {
+    await this.ensureOidcRefreshTokenSupport()
     const sessions = await this.stmt('DELETE FROM sessions WHERE user_id = ?', userId).run()
     const accessTokens = await this.stmt('DELETE FROM oidc_access_tokens WHERE user_id = ?', userId).run()
+    const refreshTokens = await this.stmt('DELETE FROM oidc_refresh_tokens WHERE user_id = ?', userId).run()
     const codes = await this.stmt('DELETE FROM oidc_codes WHERE user_id = ? AND consumed_at IS NULL', userId).run()
     const authorizations = await this.stmt('DELETE FROM oidc_authorizations WHERE user_id = ? AND decision IS NULL', userId).run()
     return {
       sessions: sessions.meta.changes ?? 0,
       accessTokens: accessTokens.meta.changes ?? 0,
+      refreshTokens: refreshTokens.meta.changes ?? 0,
       codes: codes.meta.changes ?? 0,
       authorizations: authorizations.meta.changes ?? 0,
     }

package/src/store/sqlite/op-accounts-store.ts

@@ -299,15 +299,18 @@ export function deleteOpClientRoles(userId: string, clientId: string): boolean {
 }
 
 /** The deactivation's revocation half: every live session, every issued
- *  access token, every unconsumed code and pending authorization goes.
- *  The user row STAYS (the history). */
-export function revokeOpUserCredentials(userId: string): { sessions: number; accessTokens: number; codes: number; authorizations: number } {
+ *  access token, every refresh token (migration 0025 — consumed or not;
+ *  the reuse detector has no more verdicts to give), every unconsumed
+ *  code and pending authorization goes. The user row STAYS (the
+ *  history). */
+export function revokeOpUserCredentials(userId: string): { sessions: number; accessTokens: number; refreshTokens: number; codes: number; authorizations: number } {
   const db = getDb()
   const sessions = db.prepare('DELETE FROM sessions WHERE user_id = ?').run(userId).changes
   const accessTokens = db.prepare('DELETE FROM oidc_access_tokens WHERE user_id = ?').run(userId).changes
+  const refreshTokens = db.prepare('DELETE FROM oidc_refresh_tokens WHERE user_id = ?').run(userId).changes
   const codes = db.prepare('DELETE FROM oidc_codes WHERE user_id = ? AND consumed_at IS NULL').run(userId).changes
   const authorizations = db.prepare('DELETE FROM oidc_authorizations WHERE user_id = ? AND decision IS NULL').run(userId).changes
-  return { sessions, accessTokens, codes, authorizations }
+  return { sessions, accessTokens, refreshTokens, codes, authorizations }
 }
 
 /** The registry's edit act (name/email). The email UNIQUE conflict
@@ -351,6 +354,7 @@ export function updateOpAccount(id: string, input: { name?: string; email?: stri
 export function eraseOpAccount(userId: string): {
   sessions: number
   accessTokens: number
+  refreshTokens: number
   codes: number
   authorizations: number
   links: number

package/src/store/sqlite/op-store.ts

@@ -11,12 +11,14 @@
 
 import { getDb } from './store'
 import type {
+  ConsumeOidcRefreshTokenResult,
   OidcAccessToken,
   OidcAuthorization,
   OidcClient,
   OidcClientLaunch,
   OidcCode,
   OidcKeyRow,
+  OidcRefreshToken,
 } from '../../store'
 
 function toOidcClient(row: Record<string, unknown>): OidcClient {
@@ -174,14 +176,18 @@ export function createOidcCode(input: {
    *  (stored as JSON; the token endpoint emits it as the ID token's
    *  amr). Absent = no provenance recorded. */
   amr?: string[] | null
+  /** TODO.identity-sso (the wave-A tail): the consenting session's
+   *  authentication instant (verbatim; absent = none recorded) — the
+   *  token endpoint emits it as the ID token's auth_time. */
+  authTime?: string | null
   ttlMs: number
 }): void {
   const expiresAt = new Date(Date.now() + input.ttlMs).toISOString()
   getDb().prepare(`
-    INSERT INTO oidc_codes (code, client_id, redirect_uri, scope, nonce, code_challenge, user_id, context_org, amr, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO oidc_codes (code, client_id, redirect_uri, scope, nonce, code_challenge, user_id, context_org, amr, auth_time, expires_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(input.code, input.clientId, input.redirectUri, input.scope, input.nonce, input.codeChallenge, input.userId,
-    input.contextOrg ?? null, input.amr?.length ? JSON.stringify(input.amr) : null, expiresAt)
+    input.contextOrg ?? null, input.amr?.length ? JSON.stringify(input.amr) : null, input.authTime ?? null, expiresAt)
 }
 
 /** Atomically consume the code: the UPDATE flips consumed_at exactly
@@ -204,6 +210,7 @@ export function consumeOidcCode(code: string): OidcCode | null {
     userId: row.user_id as string,
     contextOrg: (row.context_org as string | null) ?? null,
     amr: parseJsonStringList(row.amr),
+    authTime: (row.auth_time as string | null) ?? null,
     expiresAt: row.expires_at as string,
   }
 }
@@ -230,7 +237,7 @@ export function createOidcAccessToken(input: {
 
 export function getOidcAccessToken(token: string): OidcAccessToken | null {
   const row = getDb().prepare(
-    "SELECT * FROM oidc_access_tokens WHERE token = ? AND expires_at > datetime('now')",
+    "SELECT * FROM oidc_access_tokens WHERE token = ? AND datetime(expires_at) > datetime('now')",
   ).get(token) as Record<string, unknown> | undefined
   if (!row) return null
   return {
@@ -244,6 +251,109 @@ export function getOidcAccessToken(token: string): OidcAccessToken | null {
   }
 }
 
+/** The account console's per-app read + the governance view's per-user
+ *  slice: the account's LIVE access tokens, newest first — created_at is
+ *  second-resolution, the rowid breaks the tie. */
+export function listOidcAccessTokens(userId: string): OidcAccessToken[] {
+  const rows = getDb().prepare(
+    "SELECT * FROM oidc_access_tokens WHERE user_id = ? AND datetime(expires_at) > datetime('now') ORDER BY created_at DESC, rowid DESC",
+  ).all(userId) as Array<Record<string, unknown>>
+  return rows.map(row => ({
+    token: row.token as string,
+    userId: row.user_id as string,
+    clientId: row.client_id as string,
+    scope: row.scope as string,
+    contextOrg: (row.context_org as string | null) ?? null,
+    amr: parseJsonStringList(row.amr),
+    expiresAt: row.expires_at as string,
+  }))
+}
+
+/** The RFC 7009 access-token revocation: the row goes, client-bound. */
+export function deleteOidcAccessToken(token: string, clientId: string): boolean {
+  const res = getDb().prepare('DELETE FROM oidc_access_tokens WHERE token = ? AND client_id = ?').run(token, clientId)
+  return res.changes > 0
+}
+
+function toOidcRefreshToken(row: Record<string, unknown>): OidcRefreshToken {
+  return {
+    token: row.token as string,
+    userId: row.user_id as string,
+    clientId: row.client_id as string,
+    scope: row.scope as string,
+    contextOrg: (row.context_org as string | null) ?? null,
+    amr: parseJsonStringList(row.amr),
+    authTime: (row.auth_time as string | null) ?? null,
+    familyId: row.family_id as string,
+    createdAt: row.created_at as string,
+    expiresAt: row.expires_at as string,
+    consumedAt: (row.consumed_at as string | null) ?? null,
+  }
+}
+
+/** The refresh mint (migration 0025): the row carries the granting code's
+ *  provenance verbatim — a rotation re-mints the SAME truth, auth_time
+ *  never advances. */
+export function createOidcRefreshToken(input: {
+  token: string
+  userId: string
+  clientId: string
+  scope: string
+  contextOrg?: string | null
+  amr?: string[] | null
+  authTime?: string | null
+  familyId: string
+  ttlMs: number
+}): OidcRefreshToken {
+  const expiresAt = new Date(Date.now() + input.ttlMs).toISOString()
+  getDb().prepare(`
+    INSERT INTO oidc_refresh_tokens (token, user_id, client_id, scope, context_org, amr, auth_time, family_id, expires_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(input.token, input.userId, input.clientId, input.scope, input.contextOrg ?? null,
+    input.amr?.length ? JSON.stringify(input.amr) : null, input.authTime ?? null, input.familyId, expiresAt)
+  return toOidcRefreshToken(
+    getDb().prepare('SELECT * FROM oidc_refresh_tokens WHERE token = ?').get(input.token) as Record<string, unknown>,
+  )
+}
+
+/** The refresh exchange's consume: the UPDATE flips consumed_at exactly
+ *  once — a replay loses the race, reads the consumed row back, and the
+ *  WHOLE FAMILY dies (the theft signal, RFC 6819 §5.2.2.3; a concurrent
+ *  double-present lands the same verdict — fail toward invalidation). An
+ *  expired live row is consumed anyway (never a second chance) and
+ *  answers 'invalid'. */
+export function consumeOidcRefreshToken(token: string): ConsumeOidcRefreshTokenResult {
+  const db = getDb()
+  const res = db.prepare("UPDATE oidc_refresh_tokens SET consumed_at = datetime('now') WHERE token = ? AND consumed_at IS NULL").run(token)
+  if (res.changes > 0) {
+    const row = db.prepare('SELECT * FROM oidc_refresh_tokens WHERE token = ?').get(token) as Record<string, unknown>
+    if (new Date(row.expires_at as string).getTime() <= Date.now()) return { kind: 'invalid' }
+    return { kind: 'ok', token: toOidcRefreshToken(row) }
+  }
+  const row = db.prepare('SELECT * FROM oidc_refresh_tokens WHERE token = ?').get(token) as Record<string, unknown> | undefined
+  if (!row) return { kind: 'invalid' }
+  // The reuse signal: the consumed row's family dies outright.
+  const familyId = row.family_id as string
+  db.prepare('DELETE FROM oidc_refresh_tokens WHERE family_id = ?').run(familyId)
+  return { kind: 'reuse', familyId, userId: row.user_id as string, clientId: row.client_id as string }
+}
+
+/** The RFC 7009 refresh revocation, client-bound: the presented token's
+ *  family goes (never another client's rows). */
+export function revokeOidcRefreshToken(token: string, clientId: string): boolean {
+  const db = getDb()
+  const row = db.prepare('SELECT family_id FROM oidc_refresh_tokens WHERE token = ? AND client_id = ?').get(token, clientId) as { family_id: string } | undefined
+  if (!row) return false
+  db.prepare('DELETE FROM oidc_refresh_tokens WHERE family_id = ?').run(row.family_id)
+  return true
+}
+
+/** The consent revocation's companion: the (account, client) pair's
+ *  refresh rows all go. */
+export function deleteOidcRefreshTokensForUserClient(userId: string, clientId: string): number {
+  return getDb().prepare('DELETE FROM oidc_refresh_tokens WHERE user_id = ? AND client_id = ?').run(userId, clientId).changes
+}
+
 /** The amr column's honest parse (a JSON array of strings, else null —
  *  the provenance is absent on rows that predate the wave). */
 function parseJsonStringList(raw: unknown): string[] | null {

package/src/store/sqlite/schema.sql

@@ -339,6 +339,10 @@ CREATE TABLE IF NOT EXISTS oidc_codes (
   -- TODO.identity-sso/02+03: the consenting session's amr provenance (a
   -- JSON array; NULL = none recorded), carried into the ID token.
   amr TEXT,
+  -- TODO.identity-sso (the wave-A tail): the consenting session's
+  -- authentication instant (sessions.created_at, verbatim; NULL = none
+  -- recorded), carried into the ID token's auth_time.
+  auth_time TEXT,
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   expires_at TEXT NOT NULL,
   consumed_at TEXT
@@ -360,6 +364,31 @@ CREATE TABLE IF NOT EXISTS oidc_access_tokens (
   created_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
 
+-- The refresh tokens (migration 0025 — the SSO wave-C token surface): the
+-- offline half of the remembered consent. One-time, atomically consumed
+-- (WHERE consumed_at IS NULL); every rotation inherits the first mint's
+-- family_id, and a presented CONSUMED token is the theft signal that kills
+-- the whole family. The row carries the granting code's provenance
+-- (canonical scope, context_org, amr, the ORIGINAL auth_time — a refresh
+-- never advances it). Consumed rows STAY for the reuse detector;
+-- revocation (client-bound, per family), the consent's revocation, the
+-- deactivation sweep and the erasure remove rows outright.
+CREATE TABLE IF NOT EXISTS oidc_refresh_tokens (
+  token TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id),
+  client_id TEXT NOT NULL,
+  scope TEXT NOT NULL,
+  context_org TEXT,
+  amr TEXT,
+  auth_time TEXT,
+  family_id TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  expires_at TEXT NOT NULL,
+  consumed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_oidc_refresh_tokens_user ON oidc_refresh_tokens (user_id);
+CREATE INDEX IF NOT EXISTS idx_oidc_refresh_tokens_family ON oidc_refresh_tokens (family_id);
+
 -- The OP's signing-key rotation history: the PUBLIC halves. JWKS serves
 -- every row not retired beyond the token lifetime, so a rotation never
 -- strands an in-flight ID token. The private half rides the

package/src/store/sqlite/store.ts

@@ -323,6 +323,10 @@ export function getSessionUser(token: string): AuthUserPayload | null {
   ).run(token)
   // s.* carries the SESSION's id — the payload's id is the USER's.
   const payload = toAuthPayload({ ...session, id: session.user_id })
+  // TODO.identity-sso (the wave-A tail): the session's authentication
+  // instant (sessions.created_at, verbatim) — the ID token's auth_time
+  // derives from it (the consumer converts to the OIDC NumericDate).
+  payload.sessionCreatedAt = session.created_at as string
   // TODO.identity/11: the active-org context (the membership model) —
   // the payload's org/roles follow the session's stamped context.
   return applySessionOrgContext(session.active_org ?? null, payload)

package/src/store/sqlite.ts

@@ -117,16 +117,22 @@ import {
 } from './sqlite/notify'
 import {
   consumeOidcCode,
+  consumeOidcRefreshToken,
   createOidcAccessToken,
   createOidcAuthorization,
   createOidcCode,
+  createOidcRefreshToken,
   decideOidcAuthorization,
+  deleteOidcAccessToken,
+  deleteOidcRefreshTokensForUserClient,
   getOidcAccessToken,
   getOidcAuthorization,
   getOidcClient,
+  listOidcAccessTokens,
   listOidcClients,
   listOidcKeys,
   retireOidcKey,
+  revokeOidcRefreshToken,
   setOidcClientStatus,
   setOidcClientLaunch,
   upsertOidcClient,
@@ -179,7 +185,7 @@ import {
   updateOpAccount,
   updateUserName,
 } from './sqlite/op-accounts-store'
-import { installStore, type AccountEmail, type AddAccountEmailResult, type AuthUserPayload, type CertificateHolderClaim, type CertificateHolderOrg, type CompleteEmailChangeResult, type CompleteEnrollmentResult, type EmailChangeToken, type EnrollmentToken, type EntityChange, type EntityRow, type EventEntityKey, type EventKeyFilter, type FederationPeer, type IdentityApproval, type IdentityLink, type IdentityProvider, type InstrumentRegistration, type InstrumentRegistrationLifecycle, type InstrumentRegistrationScopeStatus, type NotifyDelivery, type NotifyDeliveryStatus, type NotifyEntityMute, type NotifyInboxState, type NotifyPreferences, type NotifyRule, type OAuthInitialAssignment, type OidcAccessToken, type OidcAuthorization, type OidcClient, type OidcClientLaunch, type OidcCode, type OidcConsentGrant, type OidcKeyRow, type OpAccountErasure, type OpClientRoleAssignment, type OpLiveSession, type OrgJoinRequest, type OrgMembership, type OrgMembershipState, type OrgRegistryContact, type OrgRegistryOrg, type OrgRegistryState, type PersonalAccessToken, type PlatformEvent, type ServerStore, type SessionView, type SsoSignInState, type UserAdminRow, type AdvanceCounterResult, type MfaPending, type RecoveryCodeState, type TotpSecret, type WebauthnChallenge, type WebauthnCredential } from '../store'
+import { installStore, type AccountEmail, type AddAccountEmailResult, type AuthUserPayload, type CertificateHolderClaim, type CertificateHolderOrg, type CompleteEmailChangeResult, type CompleteEnrollmentResult, type ConsumeOidcRefreshTokenResult, type EmailChangeToken, type EnrollmentToken, type EntityChange, type EntityRow, type EventEntityKey, type EventKeyFilter, type FederationPeer, type IdentityApproval, type IdentityLink, type IdentityProvider, type InstrumentRegistration, type InstrumentRegistrationLifecycle, type InstrumentRegistrationScopeStatus, type NotifyDelivery, type NotifyDeliveryStatus, type NotifyEntityMute, type NotifyInboxState, type NotifyPreferences, type NotifyRule, type OAuthInitialAssignment, type OidcAccessToken, type OidcAuthorization, type OidcClient, type OidcClientLaunch, type OidcCode, type OidcConsentGrant, type OidcKeyRow, type OidcRefreshToken, type OpAccountErasure, type OpClientRoleAssignment, type OpLiveSession, type OrgJoinRequest, type OrgMembership, type OrgMembershipState, type OrgRegistryContact, type OrgRegistryOrg, type OrgRegistryState, type PersonalAccessToken, type PlatformEvent, type ServerStore, type SessionView, type SsoSignInState, type UserAdminRow, type AdvanceCounterResult, type MfaPending, type RecoveryCodeState, type TotpSecret, type WebauthnChallenge, type WebauthnCredential } from '../store'
 import {
   advanceWebauthnCounter,
   consumeMfaPending,
@@ -658,6 +664,34 @@ export function createSqliteServerStore(): ServerStore {
     async getOidcAccessToken(token: string): Promise<OidcAccessToken | null> {
       return getOidcAccessToken(token)
     },
+    async listOidcAccessTokens(userId: string): Promise<OidcAccessToken[]> {
+      return listOidcAccessTokens(userId)
+    },
+    async deleteOidcAccessToken(token: string, clientId: string): Promise<boolean> {
+      return deleteOidcAccessToken(token, clientId)
+    },
+    async createOidcRefreshToken(input: {
+      token: string
+      userId: string
+      clientId: string
+      scope: string
+      contextOrg?: string | null
+      amr?: string[] | null
+      authTime?: string | null
+      familyId: string
+      ttlMs: number
+    }): Promise<OidcRefreshToken> {
+      return createOidcRefreshToken(input)
+    },
+    async consumeOidcRefreshToken(token: string): Promise<ConsumeOidcRefreshTokenResult> {
+      return consumeOidcRefreshToken(token)
+    },
+    async revokeOidcRefreshToken(token: string, clientId: string): Promise<boolean> {
+      return revokeOidcRefreshToken(token, clientId)
+    },
+    async deleteOidcRefreshTokensForUserClient(userId: string, clientId: string): Promise<number> {
+      return deleteOidcRefreshTokensForUserClient(userId, clientId)
+    },
     async listOidcKeys(): Promise<OidcKeyRow[]> {
       return listOidcKeys()
     },
@@ -956,7 +990,7 @@ export function createSqliteServerStore(): ServerStore {
     async deleteOpClientRoles(userId: string, clientId: string): Promise<boolean> {
       return deleteOpClientRoles(userId, clientId)
     },
-    async revokeOpUserCredentials(userId: string): Promise<{ sessions: number; accessTokens: number; codes: number; authorizations: number }> {
+    async revokeOpUserCredentials(userId: string): Promise<{ sessions: number; accessTokens: number; refreshTokens: number; codes: number; authorizations: number }> {
       return revokeOpUserCredentials(userId)
     },
     async eraseOpAccount(userId: string): Promise<OpAccountErasure | null> {

package/src/store.ts

@@ -65,6 +65,13 @@ export interface AuthUserPayload {
    *  read (getSessionUser) only; ABSENT = no OP-side credential event
    *  recorded (an upstream-provider sign-in, a legacy row). */
   amr?: string[]
+  /** TODO.identity-sso (the wave-A tail): the SESSION's authentication
+   *  instant (sessions.created_at, the column verbatim — the sign-in's
+   *  wall-clock stamp). Projected by the session-backed read
+   *  (getSessionUser) only. The ID token's auth_time derives from it (the
+   *  OIDC NumericDate conversion is the consumer's — the column's storage
+   *  format is the store's own). */
+  sessionCreatedAt?: string
 }
 
 // ── identity federation (TODO.federation/10) ─────────────────────────
@@ -425,6 +432,10 @@ export interface OidcCode {
   /** TODO.identity-sso/02+03: the consenting session's amr provenance
    *  (parsed from the row's JSON; null = none recorded). */
   amr: string[] | null
+  /** TODO.identity-sso (the wave-A tail): the consenting session's
+   *  authentication instant (sessions.created_at, verbatim; null = none
+   *  recorded) — the token endpoint emits it as the ID token's auth_time. */
+  authTime: string | null
   expiresAt: string
 }
 
@@ -443,6 +454,41 @@ export interface OidcAccessToken {
   expiresAt: string
 }
 
+/** An issued refresh token (migration 0025 — the SSO wave-C token
+ *  surface): the offline half of the remembered consent. The row carries
+ *  the granting code's full provenance — the canonical scope spelling, the
+ *  context_org, the amr, and the ORIGINAL authentication instant (authTime
+ *  never advances on a refresh: the refreshed ID token proves the original
+ *  authentication). familyId is the rotation lineage: every rotation
+ *  inherits the first mint's id. consumedAt flips atomically at the
+ *  exchange; the consumed row STAYS so a re-present detects the reuse. */
+export interface OidcRefreshToken {
+  token: string
+  userId: string
+  clientId: string
+  scope: string
+  contextOrg: string | null
+  amr: string[] | null
+  authTime: string | null
+  familyId: string
+  createdAt: string
+  expiresAt: string
+  consumedAt: string | null
+}
+
+/** The refresh exchange's honest outcomes. 'ok' carries the freshly
+ *  consumed row (the route rotates from its provenance). 'reuse' is the
+ *  theft signal (RFC 6819 §5.2.2.3): a presented CONSUMED token — the
+ *  store already killed the whole family (the attacker's copy and the
+ *  legitimate chain both end); a concurrent double-present loses the
+ *  atomic race to the same verdict, the fail-toward-invalidation posture.
+ *  'invalid' covers the never-existed, the revoked (the row is gone), and
+ *  the expired (consumed anyway — never a second chance). */
+export type ConsumeOidcRefreshTokenResult =
+  | { kind: 'ok'; token: OidcRefreshToken }
+  | { kind: 'reuse'; familyId: string; userId: string; clientId: string }
+  | { kind: 'invalid' }
+
 /** The OP key rotation history — the PUBLIC half only. */
 export interface OidcKeyRow {
   kid: string
@@ -598,7 +644,7 @@ export interface OpClientRoleAssignment {
 }
 
 /** The erasure act's removal counts (the audit event's metadata):
- *  revokeOpUserCredentials' four plus the links, the per-client
+ *  revokeOpUserCredentials' five plus the links, the per-client
  *  assignments, the org memberships (TODO.identity/11), and the
  *  credential/token rows (passwords, enrollment tokens, email-change
  *  tokens). TODO.identity-sso/02+03 adds `factors`: the factor-registry
@@ -613,6 +659,7 @@ export interface OpClientRoleAssignment {
 export interface OpAccountErasure {
   sessions: number
   accessTokens: number
+  refreshTokens: number
   codes: number
   authorizations: number
   links: number
@@ -1580,6 +1627,11 @@ export interface ServerStore {
      *  (stored as JSON; the token endpoint emits it as the ID token's
      *  amr). Absent = no provenance recorded. */
     amr?: string[] | null
+    /** TODO.identity-sso (the wave-A tail): the consenting session's
+     *  authentication instant (sessions.created_at, verbatim; absent =
+     *  none recorded) — the token endpoint emits it as the ID token's
+     *  auth_time. */
+    authTime?: string | null
     ttlMs: number
   }): Promise<void>
   /** Atomically consume the code: answers the row exactly once (a
@@ -1601,6 +1653,50 @@ export interface ServerStore {
     ttlMs: number
   }): Promise<void>
   getOidcAccessToken(token: string): Promise<OidcAccessToken | null>
+  /** The account's LIVE access tokens (unexpired, never revoked — the
+   *  row's absence IS the revocation), newest first. The account console's
+   *  per-app read and the client-registry governance view's per-user
+   *  slice; the introspection endpoint never lists (it resolves ONE
+   *  presented token). */
+  listOidcAccessTokens(userId: string): Promise<OidcAccessToken[]>
+  /** The RFC 7009 access-token revocation: delete the row, client-bound —
+   *  a client revokes only its OWN tokens (a token minted for another
+   *  client answers false). An absent row answers false too (the endpoint
+   *  masks both behind its 200). */
+  deleteOidcAccessToken(token: string, clientId: string): Promise<boolean>
+  /** The refresh tokens (migration 0025 — the SSO wave-C token surface).
+   *  The mint: token is the opaque value the route generated, familyId the
+   *  rotation lineage (a fresh id at the code exchange's first mint, the
+   *  consumed row's familyId at every rotation). scope is the CANONICAL
+   *  spelling of the granted set (a refresh never widens it). authTime is
+   *  the ORIGINAL authentication instant — it never advances. */
+  createOidcRefreshToken(input: {
+    token: string
+    userId: string
+    clientId: string
+    scope: string
+    contextOrg?: string | null
+    amr?: string[] | null
+    authTime?: string | null
+    familyId: string
+    ttlMs: number
+  }): Promise<OidcRefreshToken>
+  /** The refresh exchange's consume: the UPDATE … WHERE consumed_at IS
+   *  NULL flips exactly once (the oidc_codes doctrine). A presented
+   *  CONSUMED token is the reuse signal — the whole family is deleted
+   *  before the verdict answers. An expired live row is consumed anyway
+   *  and answers 'invalid'. */
+  consumeOidcRefreshToken(token: string): Promise<ConsumeOidcRefreshTokenResult>
+  /** The RFC 7009 refresh-token revocation, client-bound: the presented
+   *  token's WHOLE FAMILY goes (the grant lineage ends), never another
+   *  client's rows. Answers false when the token never existed, was
+   *  already gone, or belongs to another client (the endpoint masks all
+   *  three behind its 200). */
+  revokeOidcRefreshToken(token: string, clientId: string): Promise<boolean>
+  /** The consent revocation's companion: every refresh row of the
+   *  (account, client) pair goes — the "Revoke access" act ends the
+   *  offline half with the remembered consent. Answers the count. */
+  deleteOidcRefreshTokensForUserClient(userId: string, clientId: string): Promise<number>
   /** The key rotation history (public halves). */
   listOidcKeys(): Promise<OidcKeyRow[]>
   upsertOidcKey(input: { kid: string; publicJwk: string }): Promise<void>
@@ -1747,10 +1843,12 @@ export interface ServerStore {
   /** Clear the per-client assignment (the account default is restored). */
   deleteOpClientRoles(userId: string, clientId: string): Promise<boolean>
   /** The deactivation's revocation half: delete EVERY live session, every
-   *  issued OIDC access token, every unconsumed authorization code and
-   *  every pending authorization of the account. Answers the counts (the
-   *  audit event's metadata). The user row STAYS (the history). */
-  revokeOpUserCredentials(userId: string): Promise<{ sessions: number; accessTokens: number; codes: number; authorizations: number }>
+   *  issued OIDC access token, every refresh token (consumed or not — the
+   *  reuse detector has no more verdicts to give), every unconsumed
+   *  authorization code and every pending authorization of the account.
+   *  Answers the counts (the audit event's metadata). The user row STAYS
+   *  (the history). */
+  revokeOpUserCredentials(userId: string): Promise<{ sessions: number; accessTokens: number; refreshTokens: number; codes: number; authorizations: number }>
   /** The offboarding runbook's DELETE path (the erasure): every credential,
    *  token, link and per-client assignment removed, the user row anonymized
    *  in place (provider 'erased' — it drops out of every account surface;