@saadnvd1/agent-os 0.3.561 → 0.3.564

package/app/api/devices/[id]/route.ts

@@ -1,9 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
-import {
-  renameDevice,
-  revokeDevice,
-  setDeviceCanApprove,
-} from "@/lib/security/devices";
+import { renameDevice, setDeviceCanApprove } from "@/lib/security/devices";
+import { revokeDeviceAndKeys } from "@/lib/orchestrator/passkey-asks";
 import { requireLocalTrust } from "@/lib/security/route-guard";
 import { DEVICE_HEADER } from "@/lib/security/auth";
 import { demoMode } from "@/lib/security/demo";
@@ -43,7 +40,7 @@ export async function DELETE(request: NextRequest, { params }: Ctx) {
       { error: "Not available in the demo." },
       { status: 403 }
     );
-  if (!revokeDevice(id))
+  if (!revokeDeviceAndKeys(id, "Devices"))
     return NextResponse.json({ error: "Not found" }, { status: 404 });
   return NextResponse.json({ ok: true });
 }

package/app/api/devices/me/route.ts

@@ -1,12 +1,12 @@
 import { NextRequest, NextResponse } from "next/server";
-import { revokeDevice } from "@/lib/security/devices";
+import { revokeDeviceAndKeys } from "@/lib/orchestrator/passkey-asks";
 import { callingDevice, needsDevice } from "@/lib/security/device-me";
 
 // DELETE /api/devices/me - the device signs itself out ("Forget machine")
 export async function DELETE(request: NextRequest) {
   const id = callingDevice(request);
   if (!id) return needsDevice();
-  if (!revokeDevice(id))
+  if (!revokeDeviceAndKeys(id, "the device itself"))
     return NextResponse.json({ error: "Not found" }, { status: 404 });
   return NextResponse.json({ ok: true });
 }

package/app/api/presence/device-key/options/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import {
+  deviceRegistrationOptions,
+  PresenceError,
+} from "@/lib/security/presence";
+import { refusalResponse } from "@/lib/security/presence-http";
+import { passkeysBootstrapped } from "@/lib/security/passkeys";
+
+// A challenge for this paired device's new approval key to sign. The key is
+// the device's own, so only a paired device asks; with passkeys already set
+// up, it needs a code from one of them, like a browser passkey does.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  if (gate.approver.via !== "device" || !gate.approver.deviceId)
+    return NextResponse.json(
+      { error: "Only a paired device has its own key" },
+      { status: 403 }
+    );
+  try {
+    const { enrollCode } = (await request.json().catch(() => ({}))) as {
+      enrollCode?: string;
+    };
+    return NextResponse.json(
+      deviceRegistrationOptions(gate.approver.deviceId, enrollCode)
+    );
+  } catch (error) {
+    if (error instanceof PresenceError && error.code === "enroll")
+      return NextResponse.json({
+        needsCode: true,
+        canBootstrap: !passkeysBootstrapped(),
+      });
+    return refusalResponse(error);
+  }
+}

package/app/api/presence/device-key/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { verifyDeviceRegistration } from "@/lib/security/presence";
+import { placeOf, refusalResponse } from "@/lib/security/presence-http";
+import { raisePasskeyAsks } from "@/lib/orchestrator/passkey-asks";
+import { resolvePasskeyAsks } from "@/lib/orchestrator/asks";
+
+// Stores the paired device's own approval key, and puts it on Saad's asks
+// list to confirm. A key it replaces (a reinstall) is revoked and noted.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  if (gate.approver.via !== "device" || !gate.approver.deviceId)
+    return NextResponse.json(
+      { error: "Only a paired device has its own key" },
+      { status: 403 }
+    );
+  try {
+    const body = (await request.json().catch(() => ({}))) as {
+      publicKey?: string;
+      challenge?: string;
+      signature?: string;
+      name?: string;
+      hardware?: string;
+      enrollCode?: string;
+    };
+    if (!body.publicKey || !body.challenge || !body.signature)
+      return NextResponse.json({ error: "No key" }, { status: 400 });
+    const place = placeOf(gate.approver, request.headers);
+    const { key, replaced } = verifyDeviceRegistration(
+      gate.approver.deviceId,
+      {
+        publicKey: body.publicKey,
+        challenge: body.challenge,
+        signature: body.signature,
+        name: body.name || place,
+        hardware: body.hardware,
+      },
+      {
+        via: gate.approver.via,
+        from: place,
+        userAgent: request.headers.get("user-agent"),
+      },
+      body.enrollCode
+    );
+    for (const old of replaced) {
+      resolvePasskeyAsks(old.id, "replaced");
+      raisePasskeyAsks(old, place, "revoked");
+    }
+    raisePasskeyAsks(key, place);
+    return NextResponse.json({ passkey: { id: key.id, name: key.name } });
+  } catch (error) {
+    return refusalResponse(error);
+  }
+}

package/app/api/presence/enroll/route.ts

@@ -1,12 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
+import { mintEnrollCode } from "@/lib/security/presence";
 import {
-  mintEnrollCode,
-  relyingParty,
-  verifyPresence,
-} from "@/lib/security/presence";
-import { refusalResponse } from "@/lib/security/presence-http";
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 
 // A one-time code (10 minutes) for adding a passkey on another device,
 // minted only on an assertion from an existing passkey.
@@ -14,15 +13,8 @@ export async function POST(request: NextRequest) {
   const gate = requireApprover(request);
   if (!gate.ok) return gate.response;
   try {
-    const { assertion } = (await request.json().catch(() => ({}))) as {
-      assertion?: AuthenticationResponseJSON;
-    };
-    await verifyPresence(
-      relyingParty(request.headers),
-      assertion,
-      "enroll",
-      "enroll"
-    );
+    const body = (await request.json().catch(() => ({}))) as PresenceProof;
+    await requirePresence(request, gate.approver, body, "enroll", "enroll");
     return NextResponse.json({ code: mintEnrollCode() });
   } catch (error) {
     return refusalResponse(error);

package/app/api/presence/options/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { requireApprover } from "@/lib/security/approver";
 import {
   assertionOptions,
+  deviceAssertionOptions,
   relyingParty,
   type PresencePurpose,
 } from "@/lib/security/presence";
@@ -21,8 +22,27 @@ export async function POST(request: NextRequest) {
       askId?: number;
       binding?: string;
       passkeyId?: string;
+      method?: "device";
     };
     const binding = presenceBinding(body);
+    if (body.method === "device") {
+      if (gate.approver.via !== "device" || !gate.approver.deviceId)
+        return NextResponse.json(
+          { error: "Only a paired device has its own key" },
+          { status: 403 }
+        );
+      const device = deviceAssertionOptions(
+        gate.approver.deviceId,
+        body.purpose!,
+        binding
+      );
+      if (!device)
+        return NextResponse.json({
+          needsDeviceKey: true,
+          canBootstrap: !passkeysBootstrapped(),
+        });
+      return NextResponse.json({ device });
+    }
     const rp = relyingParty(request.headers);
     const options = await assertionOptions(rp, body.purpose!, binding);
     if (!options)

package/app/api/presence/passkeys/[id]/route.ts

@@ -1,9 +1,12 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
 import { getPasskey, revokePasskey } from "@/lib/security/passkeys";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { placeOf, refusalResponse } from "@/lib/security/presence-http";
+import {
+  placeOf,
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { raisePasskeyAsks } from "@/lib/orchestrator/passkey-asks";
 import { revokePresence } from "@/lib/orchestrator/presence-binding";
 import { resolvePasskeyAsks } from "@/lib/orchestrator/asks";
@@ -21,12 +24,11 @@ export async function DELETE(request: NextRequest, { params }: Ctx) {
     const key = getPasskey(id);
     if (!key || key.revoked_at)
       return NextResponse.json({ error: "Not found" }, { status: 404 });
-    const { assertion } = (await request.json().catch(() => ({}))) as {
-      assertion?: AuthenticationResponseJSON;
-    };
-    await verifyPresence(
-      relyingParty(request.headers),
-      assertion,
+    const body = (await request.json().catch(() => ({}))) as PresenceProof;
+    await requirePresence(
+      request,
+      gate.approver,
+      body,
       "revoke",
       revokePresence(id)
     );

package/app/api/workspaces/[id]/orchestrator/asks/[askId]/route.ts

@@ -1,8 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { placeOf, refusalResponse } from "@/lib/security/presence-http";
+import {
+  placeOf,
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { getPasskey } from "@/lib/security/passkeys";
 import { raisePasskeyAsks } from "@/lib/orchestrator/passkey-asks";
 import {
@@ -40,10 +43,11 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     : requireApprover(request);
   if (!gate.ok) return gate.response;
   const { id, askId } = await params;
-  const body = (await request.json().catch(() => null)) as {
-    binding?: string;
-    assertion?: AuthenticationResponseJSON;
-  } | null;
+  const body = (await request.json().catch(() => null)) as
+    | ({
+        binding?: string;
+      } & PresenceProof)
+    | null;
   const parsed = parseAnswer(body);
   // A demo keeps no visitor's words where the next visitor would read them.
   const answer =
@@ -73,9 +77,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
           { status: 400 }
         );
       if (!demo && PRESENCE_KINDS.includes(ask.kind))
-        await verifyPresence(
-          relyingParty(request.headers),
-          body.assertion,
+        await requirePresence(
+          request,
+          gate.approver,
+          body,
           "approve",
           askPresence(ask.id, body.binding)
         );

package/app/api/workspaces/[id]/orchestrator/pause/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { getWorkspace } from "@/lib/workspaces";
 import { setPaused } from "@/lib/orchestrator/pause";
 import { requireApprover } from "@/lib/security/approver";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { refusalResponse } from "@/lib/security/presence-http";
+import {
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { resumePresence } from "@/lib/orchestrator/presence-binding";
 
 type RouteParams = { params: Promise<{ id: string }> };
@@ -18,10 +20,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
   const { id } = await params;
   if (!getWorkspace(id))
     return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
-  const { paused, assertion } = (await request.json().catch(() => ({}))) as {
+  const body = (await request.json().catch(() => ({}))) as {
     paused?: unknown;
-    assertion?: AuthenticationResponseJSON;
-  };
+  } & PresenceProof;
+  const { paused } = body;
   if (typeof paused !== "boolean")
     return NextResponse.json(
       { error: "paused must be true or false" },
@@ -29,9 +31,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     );
   try {
     if (!paused)
-      await verifyPresence(
-        relyingParty(request.headers),
-        assertion,
+      await requirePresence(
+        request,
+        gate.approver,
+        body,
         "resume",
         resumePresence(id)
       );

package/app/api/workspaces/[id]/orchestrator/rules/[ruleId]/route.ts

@@ -1,11 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import type { PresenceProof } from "@/lib/security/presence-http";
 import { removeRule, updateRule } from "@/lib/orchestrator/rules";
 import { provenAsSaad } from "../presence";
 
 type RouteParams = { params: Promise<{ id: string; ruleId: string }> };
 
-type Body = { text?: unknown; assertion?: AuthenticationResponseJSON };
+type Body = { text?: unknown } & PresenceProof;
 
 // The rule, its body, and Saad's passkey on it; or the refusal.
 async function target(
@@ -21,7 +21,7 @@ async function target(
       response: NextResponse.json({ error: "Bad rule id" }, { status: 400 }),
     };
   const body = (await request.json().catch(() => ({}))) as Body;
-  const refused = await provenAsSaad(request, id, body.assertion);
+  const refused = await provenAsSaad(request, id, body);
   if (refused) return { response: refused };
   return { workspaceId: id, ruleId: n, body };
 }

package/app/api/workspaces/[id]/orchestrator/rules/presence.ts

@@ -1,8 +1,10 @@
 import type { NextRequest } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { refusalResponse } from "@/lib/security/presence-http";
+import {
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { rulesPresence } from "@/lib/orchestrator/presence-binding";
 
 // A rule written here is Saad's, shown to the orchestrator as his word and
@@ -11,14 +13,15 @@ import { rulesPresence } from "@/lib/orchestrator/presence-binding";
 export async function provenAsSaad(
   request: NextRequest,
   workspaceId: string,
-  assertion: AuthenticationResponseJSON | undefined
+  proof: PresenceProof | undefined
 ): Promise<Response | null> {
   const gate = requireApprover(request);
   if (!gate.ok) return gate.response;
   try {
-    await verifyPresence(
-      relyingParty(request.headers),
-      assertion,
+    await requirePresence(
+      request,
+      gate.approver,
+      proof,
       "rules",
       rulesPresence(workspaceId)
     );

package/app/api/workspaces/[id]/orchestrator/rules/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import type { PresenceProof } from "@/lib/security/presence-http";
 import { getWorkspace } from "@/lib/workspaces";
 import { addRule, listRules } from "@/lib/orchestrator/rules";
 import { provenAsSaad } from "./presence";
@@ -19,13 +19,13 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
   const { id } = await params;
   if (!getWorkspace(id))
     return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
-  const { text, assertion } = (await request.json().catch(() => ({}))) as {
+  const body = (await request.json().catch(() => ({}))) as {
     text?: unknown;
-    assertion?: AuthenticationResponseJSON;
-  };
+  } & PresenceProof;
+  const { text } = body;
   if (typeof text !== "string")
     return NextResponse.json({ error: "text is required" }, { status: 400 });
-  const refused = await provenAsSaad(request, id, assertion);
+  const refused = await provenAsSaad(request, id, body);
   if (refused) return refused;
   try {
     return NextResponse.json({ rule: addRule(id, text, "saad") });

package/components/Devices/PasskeysSection.tsx

@@ -25,7 +25,8 @@ const when = (s: string) =>
 const fail = (e: Error) => toast.error(e.message);
 
 // Passkeys prove it's you approving an ask or resuming an orchestrator.
-// Each belongs to the host name it was made on.
+// A browser passkey belongs to the host name it was made on; the app keeps its
+// own key in the phone's Secure Enclave.
 export function PasskeysSection({ open }: { open: boolean }) {
   const { data } = usePasskeysQuery(open);
   const add = useAddPasskey();
@@ -64,7 +65,8 @@ export function PasskeysSection({ open }: { open: boolean }) {
           <div className="min-w-0 flex-1">
             <p className="truncate text-sm font-medium">{k.name}</p>
             <p className="text-muted-foreground truncate text-xs">
-              {k.rp_id} · added {when(k.created_at)}
+              {k.type === "device" ? "Device key (Face ID)" : k.rp_id} · added{" "}
+              {when(k.created_at)}
               {k.registered_from ? ` from ${k.registered_from}` : ""} · used{" "}
               {lastSeen(k.last_used_at)}
             </p>

package/lib/db/migrations-legacy-checksums.json

@@ -0,0 +1,90 @@
+{
+  "1": "f6d5756a104c16ec",
+  "2": "3699f5f3cd215455",
+  "3": "dc4efbc29c2976ef",
+  "4": "d3db3af92f123a13",
+  "5": "d5937aba3b590fed",
+  "6": "0c4668cf9a58cecd",
+  "7": "7f535265ae1ad37f",
+  "8": "5c24f600f5f73145",
+  "9": "99496923fc7ff333",
+  "10": "22162670e68726c0",
+  "11": "21cd323c1654f9a9",
+  "12": "d66b982154dc3ee2",
+  "13": "ba1c8c4e2486a74d",
+  "14": "2f9575eed78d3284",
+  "15": "4c2293b3766c0d84",
+  "16": "8e798e52aed97875",
+  "17": "a743501f00312926",
+  "18": "cb84130b195bfa63",
+  "19": "b0ba5d304ca64aba",
+  "20": "ef3e125d28bfa506",
+  "21": "542664a9bef5f215",
+  "22": "195a6a7a87776269",
+  "23": "e4b50e60ac0821fa",
+  "24": "afb9644f31cc7602",
+  "25": "52bb47e1eed4e8d4",
+  "26": "9b5247315a01bdbe",
+  "27": "9c34c46d26c93cc4",
+  "28": "83d816f925aa0aba",
+  "29": "5ce556a828f7510b",
+  "30": "3d1bc245c30dcf49",
+  "31": "250433b280fd8df1",
+  "32": "95ec3c8125969681",
+  "33": "711226e6a027f6cd",
+  "34": "d8c917aa6f3e00b6",
+  "35": "7db35660583c2a50",
+  "36": "7ff8363149a3952c",
+  "37": "b7e72a18d3398da6",
+  "38": "cea02e00d1262601",
+  "39": "61c77d0f357d71d6",
+  "40": "6cedcf70268ddd25",
+  "41": "3d9af0548ae91946",
+  "42": "410ef4562a046ce6",
+  "43": "b0fca4e05ff6499e",
+  "44": "06b7f4dc636c9675",
+  "45": "73948f256c522959",
+  "46": "202f8fd102ef2581",
+  "47": "510435d6afa487cd",
+  "48": "10727869e8c8dea1",
+  "49": "0384a86395f6650a",
+  "50": "cc05c3663ca18b2b",
+  "51": "b381268fe096fb02",
+  "52": "281ad10453d9177a",
+  "53": "a7a53074ed49a566",
+  "54": "2358b106da3e7b68",
+  "55": "478ece72deb01953",
+  "56": "d04bafcaa2eda941",
+  "57": "0f9bc09a7a31f64d",
+  "58": "ccbf7eebccadfa3f",
+  "59": "1859ac87155d546b",
+  "60": "035e204a4b6c457e",
+  "61": "85d9bb65b051409a",
+  "62": "723d9c60994dec97",
+  "63": "77dd17570476ee17",
+  "64": "de5f368a88af93de",
+  "65": "081cc6eaf666581b",
+  "66": "08eedfefd3d3f3f9",
+  "67": "e37ead69c14e2d01",
+  "68": "9ab2551e258f1588",
+  "69": "55edb197ed55afe1",
+  "70": "d8a4faf39318bd1d",
+  "71": "45b9b9ff57d2083d",
+  "72": "51b77e2e1c5c8ae6",
+  "73": "2878b9f0762ab53d",
+  "74": "c94cd8f644a8518f",
+  "75": "e082428a046f9e6b",
+  "76": "17f3160630d658dc",
+  "77": "cd54bfd73fbcd168",
+  "78": "8ad44a982b1eb58d",
+  "79": "0b09d57d6ea8ce0a",
+  "80": "941d85f2ef8bd012",
+  "81": "ecd85de2bdf45ff1",
+  "82": "07f11cdac5f8444a",
+  "83": "eabf72b6a8616eac",
+  "84": "1ed4fb30b7435f28",
+  "85": "a85ac25c0e34f2fb",
+  "86": "50b5725a67286dee",
+  "87": "6024c62bcdbb186e",
+  "88": "bb58ec622ae398e5"
+}

package/lib/db/migrations.ts

@@ -10,14 +10,43 @@ import {
 import type Database from "better-sqlite3";
 import { moveSchedulesToRecipes } from "./schedules-move";
 
-interface Migration {
+// HOW TO ADD A MIGRATION: append an object with a timestamp `key`, never an
+// integer `id`: `key: "YYYYMMDDTHHMM_snake_name"` (UTC, e.g.
+// "20261014T0130_share_links"). Hand-picked numbers collide when two tasks run
+// in parallel and the loser is silently skipped on databases that already
+// applied the winner. Ids 1..88 are legacy: they run first, by number, and
+// never change. Timestamp keys run after them, in lexical order. Never edit a
+// migration that has shipped; add a new one. lib/db/migrations.test.ts
+// enforces all of this.
+interface LegacyMigration {
   id: number;
+  key?: undefined;
   name: string;
   up: (db: Database.Database) => void;
 }
+interface KeyedMigration {
+  key: string;
+  id?: undefined;
+  name?: undefined;
+  up: (db: Database.Database) => void;
+}
+export type Migration = LegacyMigration | KeyedMigration;
+
+export const migrationKey = (m: Migration): string => m.key ?? String(m.id);
+const migrationName = (m: Migration): string =>
+  m.name ?? (m.key as string).replace(/^\d{8}T\d{4}_/, "");
+
+// Legacy ids sort before every timestamp key.
+function compareToUpTo(m: Migration, upTo: number | string): number {
+  if (typeof upTo === "number") {
+    return m.id === undefined ? 1 : m.id - upTo;
+  }
+  if (m.id !== undefined) return -1;
+  return m.key < upTo ? -1 : m.key > upTo ? 1 : 0;
+}
 
 // All migrations in order - never modify existing ones, only add new
-const migrations: Migration[] = [
+export const migrations: Migration[] = [
   {
     id: 1,
     name: "add_group_path_to_sessions",
@@ -2137,12 +2166,34 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 89,
+    name: "passkeys_device_keys",
+    up: (db) => {
+      // A paired device's own approval key (Secure Enclave, Face ID) sits in
+      // the passkeys table beside the browser passkeys: type 'device', bound
+      // to the device that made it. Additive; existing rows read as webauthn.
+      const columns = db.prepare(`PRAGMA table_info(passkeys)`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === "type"))
+        db.exec(
+          `ALTER TABLE passkeys ADD COLUMN type TEXT NOT NULL DEFAULT 'webauthn'`
+        );
+      if (!columns.some((c) => c.name === "device_id"))
+        db.exec(`ALTER TABLE passkeys ADD COLUMN device_id TEXT`);
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_passkeys_device ON passkeys(device_id)`
+      );
+    },
+  },
 ];
 
-// `upTo`: stop after this id (tests that start from an older database).
+// `upTo`: stop after this legacy id or timestamp key, inclusive (tests that
+// start from an older database).
 export function runMigrations(
   db: Database.Database,
-  upTo = Number.POSITIVE_INFINITY
+  upTo?: number | string
 ): void {
   // Create migrations tracking table
   db.exec(`
@@ -2152,31 +2203,59 @@ export function runMigrations(
       applied_at TEXT NOT NULL DEFAULT (datetime('now'))
     )
   `);
+  // Timestamp-keyed rows get an auto id and carry their key here; legacy rows
+  // (key NULL) keep meaning "applied" by their integer id.
+  const cols = db.prepare(`PRAGMA table_info(_migrations)`).all() as {
+    name: string;
+  }[];
+  if (!cols.some((c) => c.name === "key")) {
+    try {
+      db.exec(`ALTER TABLE _migrations ADD COLUMN key TEXT`);
+    } catch (error) {
+      if (!String(error).includes("duplicate column")) throw error;
+    }
+  }
+  db.exec(
+    `CREATE UNIQUE INDEX IF NOT EXISTS idx_migrations_key ON _migrations(key)`
+  );
 
-  // Get already applied migrations
   const applied = new Set(
-    (db.prepare(`SELECT id FROM _migrations`).all() as { id: number }[]).map(
-      (r) => r.id
-    )
+    (
+      db.prepare(`SELECT id, key FROM _migrations`).all() as {
+        id: number;
+        key: string | null;
+      }[]
+    ).map((r) => r.key ?? String(r.id))
   );
 
   // Use INSERT OR IGNORE to handle concurrent workers
-  const insertMigration = db.prepare(
+  const insertLegacy = db.prepare(
     `INSERT OR IGNORE INTO _migrations (id, name) VALUES (?, ?)`
   );
+  const insertKeyed = db.prepare(
+    `INSERT OR IGNORE INTO _migrations (key, name) VALUES (?, ?)`
+  );
+  const record = (m: Migration) =>
+    m.key === undefined
+      ? insertLegacy.run(m.id, m.name)
+      : insertKeyed.run(m.key, migrationName(m));
 
   for (const migration of migrations) {
-    if (applied.has(migration.id) || migration.id > upTo) continue;
+    const key = migrationKey(migration);
+    const name = migrationName(migration);
+    if (
+      applied.has(key) ||
+      (upTo !== undefined && compareToUpTo(migration, upTo) > 0)
+    )
+      continue;
 
     try {
       migration.up(db);
-      const result = insertMigration.run(migration.id, migration.name);
+      const result = record(migration);
       if (result.changes > 0) {
-        console.log(`Migration ${migration.id}: ${migration.name} applied`);
+        console.log(`Migration ${key}: ${name} applied`);
       } else {
-        console.log(
-          `Migration ${migration.id}: ${migration.name} skipped (concurrent apply)`
-        );
+        console.log(`Migration ${key}: ${name} skipped (concurrent apply)`);
       }
     } catch (error) {
       // Some migrations may fail if columns already exist (from old system or concurrent worker)
@@ -2186,15 +2265,10 @@ export function runMigrations(
         errorMsg.includes("duplicate column") ||
         errorMsg.includes("already exists")
       ) {
-        insertMigration.run(migration.id, migration.name);
-        console.log(
-          `Migration ${migration.id}: ${migration.name} skipped (already applied)`
-        );
+        record(migration);
+        console.log(`Migration ${key}: ${name} skipped (already applied)`);
       } else {
-        console.error(
-          `Migration ${migration.id}: ${migration.name} failed:`,
-          error
-        );
+        console.error(`Migration ${key}: ${name} failed:`, error);
         throw error;
       }
     }

package/lib/orchestrator/passkey-asks.ts

@@ -3,8 +3,11 @@
 // Declining a new passkey's ask revokes it.
 
 import type { PasskeyRow } from "../security/passkeys";
+import { revokeDeviceKeys } from "../security/device-keys";
+import { revokeDevice } from "../security/devices";
 import {
   AskRefused,
+  resolvePasskeyAsks,
   passkeySubject,
   raiseAsk,
   revokedPasskeySubject,
@@ -54,3 +57,14 @@ export function raisePasskeyAsks(
   }
   return n;
 }
+
+// Signing a device out takes its approval key with it, and the revoke goes
+// on the asks list like any other.
+export function revokeDeviceAndKeys(deviceId: string, place: string): boolean {
+  const changed = revokeDevice(deviceId);
+  for (const key of revokeDeviceKeys(deviceId)) {
+    resolvePasskeyAsks(key.id, "revoked");
+    raisePasskeyAsks(key, place, "revoked");
+  }
+  return changed;
+}

package/lib/security/device-key-message.ts

@@ -0,0 +1,27 @@
+// What a paired device signs to prove a person is there. Client-safe (no
+// database, no node modules), so the app builds the same bytes the server
+// checks. The server rebuilds it from its own record of the challenge; what
+// the client says it signed is never used.
+
+export const DEVICE_KEY_DOMAIN = "AgentOS device approval v1";
+
+export interface DeviceKeyMessage {
+  challenge: string;
+  purpose: string;
+  binding: string;
+  deviceId: string;
+}
+
+export function deviceKeyMessage(m: DeviceKeyMessage): string {
+  return [
+    DEVICE_KEY_DOMAIN,
+    m.challenge,
+    m.purpose,
+    m.binding,
+    m.deviceId,
+  ].join("\n");
+}
+
+// A device key's relying-party id in the passkeys table. It can never equal
+// a host name, so the browser flow never sees these keys.
+export const deviceRp = (deviceId: string) => `device:${deviceId}`;

package/lib/security/device-keys.ts

@@ -0,0 +1,75 @@
+/**
+ * A paired device's approval key: P-256, made in the phone's Secure Enclave
+ * and unlocked by Face ID, Touch ID or the passcode. Only the public key is
+ * kept, in the passkeys table (type 'device', rp_id device:<id>).
+ */
+
+import crypto from "crypto";
+import { getDb } from "@/lib/db";
+import type { PasskeyRow } from "./passkeys";
+
+// The fixed prefix of a P-256 SubjectPublicKeyInfo; the 65-byte X9.63 point
+// follows it.
+const SPKI_P256_PREFIX = Buffer.from(
+  "3059301306072a8648ce3d020106082a8648ce3d030107034200",
+  "hex"
+);
+
+export const newDeviceKeyId = () =>
+  crypto.randomBytes(16).toString("base64url");
+
+// The app sends the key as an uncompressed X9.63 point. Throws unless it's a
+// real point on the curve.
+export function spkiFromRawP256(raw: Buffer): Buffer {
+  if (raw.length !== 65 || raw[0] !== 0x04)
+    throw new Error("Not a P-256 public key");
+  const spki = Buffer.concat([SPKI_P256_PREFIX, raw]);
+  crypto.createPublicKey({ key: spki, format: "der", type: "spki" });
+  return spki;
+}
+
+// iOS signs with ecdsaSignatureMessageX962SHA256, which is DER.
+export function verifyDeviceSignature(
+  spki: Buffer,
+  message: string,
+  signature: Buffer
+): boolean {
+  try {
+    return crypto.verify(
+      "sha256",
+      Buffer.from(message),
+      { key: spki, format: "der", type: "spki", dsaEncoding: "der" },
+      signature
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function activeDeviceKey(deviceId: string): PasskeyRow | null {
+  return (
+    (getDb()
+      .prepare(
+        `SELECT * FROM passkeys WHERE type = 'device' AND device_id = ? AND revoked_at IS NULL`
+      )
+      .get(deviceId) as PasskeyRow | undefined) ?? null
+  );
+}
+
+// Revokes every active key of this device; returns them so the caller can
+// raise the "revoked" asks.
+export function revokeDeviceKeys(deviceId: string): PasskeyRow[] {
+  const keys = getDb()
+    .prepare(
+      `SELECT * FROM passkeys WHERE type = 'device' AND device_id = ? AND revoked_at IS NULL`
+    )
+    .all(deviceId) as PasskeyRow[];
+  if (keys.length)
+    getDb()
+      .prepare(
+        `UPDATE passkeys SET revoked_at = datetime('now')
+         WHERE type = 'device' AND device_id = ? AND revoked_at IS NULL`
+      )
+      .run(deviceId);
+  return keys;
+}

package/lib/security/passkeys.ts

@@ -19,12 +19,15 @@ export interface PasskeyRow {
   created_at: string;
   last_used_at: string | null;
   revoked_at: string | null;
+  // 'webauthn' (a browser passkey) or 'device' (a paired device's own key).
+  type: "webauthn" | "device";
+  device_id: string | null;
 }
 
 export type PasskeyView = Omit<PasskeyRow, "public_key" | "counter">;
 
 const VIEW = `id, transports, rp_id, name, registered_via, registered_from,
-  user_agent, created_at, last_used_at, revoked_at`;
+  user_agent, created_at, last_used_at, revoked_at, type, device_id`;
 
 export function listPasskeys(): PasskeyView[] {
   return getDb()
@@ -66,12 +69,14 @@ export function addPasskey(p: {
   via: string;
   from: string | null;
   userAgent: string | null;
+  type?: "webauthn" | "device";
+  deviceId?: string | null;
 }): PasskeyRow {
   getDb()
     .prepare(
       `INSERT INTO passkeys (id, public_key, counter, transports, rp_id, name,
-         registered_via, registered_from, user_agent)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+         registered_via, registered_from, user_agent, type, device_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     )
     .run(
       p.id,
@@ -82,7 +87,9 @@ export function addPasskey(p: {
       p.name.trim().slice(0, 80) || "Passkey",
       p.via,
       p.from,
-      p.userAgent?.slice(0, 300) ?? null
+      p.userAgent?.slice(0, 300) ?? null,
+      p.type ?? "webauthn",
+      p.deviceId ?? null
     );
   return getPasskey(p.id)!;
 }

package/lib/security/presence-http.ts

@@ -5,7 +5,17 @@ import { NextResponse } from "next/server";
 import { REMOTE_HEADER } from "./auth";
 import type { Approver } from "./approver";
 import { getDevice } from "./devices";
-import { PresenceError } from "./presence";
+import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import type { NextRequest } from "next/server";
+import type { PasskeyRow } from "./passkeys";
+import {
+  PresenceError,
+  relyingParty,
+  verifyDevicePresence,
+  verifyPresence,
+  type DeviceSignature,
+  type PresencePurpose,
+} from "./presence";
 
 export function placeOf(approver: Approver, headers: Headers): string {
   if (approver.via === "loopback") return "this machine";
@@ -14,6 +24,44 @@ export function placeOf(approver: Approver, headers: Headers): string {
   return getDevice(approver.deviceId ?? "")?.name ?? "a paired device";
 }
 
+// What a request sends to prove a person: a browser's passkey assertion, or
+// a paired device's signature from its own key.
+export interface PresenceProof {
+  assertion?: AuthenticationResponseJSON;
+  deviceSignature?: DeviceSignature;
+}
+
+// A device signature counts only from the device whose key it is; anything
+// else goes through the browser passkey check as before.
+export function requirePresence(
+  request: NextRequest,
+  approver: Approver,
+  proof: PresenceProof | null | undefined,
+  purpose: PresencePurpose,
+  binding: string
+): Promise<PasskeyRow> {
+  if (proof?.deviceSignature) {
+    if (approver.via !== "device" || !approver.deviceId)
+      return Promise.reject(
+        new PresenceError("Only a paired device can sign with its own key")
+      );
+    return Promise.resolve().then(() =>
+      verifyDevicePresence(
+        approver.deviceId!,
+        proof.deviceSignature,
+        purpose,
+        binding
+      )
+    );
+  }
+  return verifyPresence(
+    relyingParty(request.headers),
+    proof?.assertion,
+    purpose,
+    binding
+  );
+}
+
 export function refusalResponse(error: unknown): NextResponse {
   if (error instanceof PresenceError)
     return NextResponse.json(

package/lib/security/presence.ts

@@ -23,6 +23,14 @@ import {
   type RegistrationResponseJSON,
 } from "@simplewebauthn/server";
 import { getDb } from "@/lib/db";
+import { deviceKeyMessage, deviceRp } from "./device-key-message";
+import {
+  activeDeviceKey,
+  newDeviceKeyId,
+  revokeDeviceKeys,
+  spkiFromRawP256,
+  verifyDeviceSignature,
+} from "./device-keys";
 import {
   activePasskeys,
   markBootstrapped,
@@ -319,3 +327,179 @@ export async function verifyRegistration(
     });
   })();
 }
+
+// ---- A paired device's own key (Secure Enclave, Face ID) ----
+
+export interface DeviceSignature {
+  keyId: string;
+  challenge: string;
+  signature: string;
+}
+
+export interface DeviceOptions {
+  challenge: string;
+  keyId: string;
+  message: string;
+}
+
+const newChallenge = () => crypto.randomBytes(32).toString("base64url");
+
+// Options for a device-key assertion, or null when the device has no key.
+export function deviceAssertionOptions(
+  deviceId: string,
+  purpose: PresencePurpose,
+  binding: string
+): DeviceOptions | null {
+  const key = activeDeviceKey(deviceId);
+  if (!key) return null;
+  const challenge = newChallenge();
+  storeChallenge(challenge, "assert", purpose, binding, deviceRp(deviceId));
+  return {
+    challenge,
+    keyId: key.id,
+    message: deviceKeyMessage({ challenge, purpose, binding, deviceId }),
+  };
+}
+
+// Checks a device's signature over exactly this challenge, purpose and
+// binding, by that device's own active key. The message is rebuilt here
+// from what the server issued.
+export function verifyDevicePresence(
+  deviceId: string,
+  proof: DeviceSignature | null | undefined,
+  purpose: PresencePurpose,
+  binding: string
+): PasskeyRow {
+  if (!proof?.keyId || !proof.challenge || !proof.signature)
+    throw new PresenceError("This needs your Face ID or Touch ID");
+  const key = getPasskey(proof.keyId);
+  if (
+    !key ||
+    key.type !== "device" ||
+    key.revoked_at ||
+    key.device_id !== deviceId
+  )
+    throw new PresenceError("Unknown passkey");
+  // Spent before the signature is checked: one try per challenge.
+  takeChallenge(
+    proof.challenge,
+    "assert",
+    purpose,
+    binding,
+    deviceRp(deviceId)
+  );
+  const message = deviceKeyMessage({
+    challenge: proof.challenge,
+    purpose,
+    binding,
+    deviceId,
+  });
+  if (
+    !verifyDeviceSignature(
+      key.public_key,
+      message,
+      Buffer.from(proof.signature, "base64url")
+    )
+  )
+    throw new PresenceError("Passkey check failed");
+  touchPasskey(key.id, key.counter);
+  return key;
+}
+
+// Options for registering this device's key: a challenge the new key signs.
+// Needs the same trust as a browser passkey (the free first one, or a code).
+export function deviceRegistrationOptions(
+  deviceId: string,
+  enrollCode?: string
+): { challenge: string; message: string } {
+  const binding = registrationBinding(enrollCode);
+  const challenge = newChallenge();
+  storeChallenge(
+    challenge,
+    "register",
+    "register",
+    binding,
+    deviceRp(deviceId)
+  );
+  return {
+    challenge,
+    message: deviceKeyMessage({
+      challenge,
+      purpose: "register",
+      binding,
+      deviceId,
+    }),
+  };
+}
+
+export function verifyDeviceRegistration(
+  deviceId: string,
+  body: {
+    publicKey: string;
+    challenge: string;
+    signature: string;
+    name: string;
+    hardware?: string;
+  },
+  meta: { via: string; from: string | null; userAgent: string | null },
+  enrollCode?: string
+): { key: PasskeyRow; replaced: PasskeyRow[] } {
+  const binding = registrationBinding(enrollCode);
+  let spki: Buffer;
+  try {
+    spki = spkiFromRawP256(Buffer.from(body.publicKey, "base64url"));
+  } catch {
+    throw new PresenceError("Not a usable key");
+  }
+  const message = deviceKeyMessage({
+    challenge: body.challenge,
+    purpose: "register",
+    binding,
+    deviceId,
+  });
+  if (
+    !verifyDeviceSignature(
+      spki,
+      message,
+      Buffer.from(body.signature, "base64url")
+    )
+  )
+    throw new PresenceError("The new key couldn't sign the request");
+  return getDb().transaction(() => {
+    takeChallenge(
+      body.challenge,
+      "register",
+      "register",
+      binding,
+      deviceRp(deviceId)
+    );
+    if (binding === "bootstrap") {
+      if (passkeysBootstrapped())
+        throw new PresenceError(
+          "A passkey was added meanwhile; get a code from it"
+        );
+      markBootstrapped();
+    } else {
+      const used = getDb()
+        .prepare(
+          `UPDATE passkey_enrollments SET used_at = ? WHERE code_hash = ? AND used_at IS NULL`
+        )
+        .run(now(), hash(enrollCode!)).changes;
+      if (used !== 1) throw new PresenceError("That code was already used");
+    }
+    // A reinstall makes a new key; the old one stops counting.
+    const replaced = revokeDeviceKeys(deviceId);
+    const hardware = body.hardware === "software" ? " (software key)" : "";
+    const key = addPasskey({
+      id: newDeviceKeyId(),
+      publicKey: spki,
+      counter: 0,
+      rpId: deviceRp(deviceId),
+      name: `${body.name.trim().slice(0, 60) || "Device"}${hardware}`,
+      type: "device",
+      deviceId,
+      ...meta,
+    });
+    return { key, replaced };
+  })();
+}

package/lib/security/soft-authenticator.ts

@@ -81,3 +81,24 @@ export function softAuthenticator(rpId = "localhost") {
     },
   };
 }
+
+// Tests only: a software stand-in for the app's Secure Enclave key. The
+// public key is the uncompressed X9.63 point the app sends; sign() gives a
+// DER signature, as iOS does.
+export function softDeviceKey() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ec", {
+    namedCurve: "P-256",
+  });
+  const jwk = publicKey.export({ format: "jwk" }) as { x: string; y: string };
+  return {
+    publicKey: b64url(
+      Buffer.concat([
+        Buffer.from([0x04]),
+        Buffer.from(jwk.x, "base64url"),
+        Buffer.from(jwk.y, "base64url"),
+      ])
+    ),
+    sign: (message: string) =>
+      b64url(crypto.sign("sha256", Buffer.from(message), privateKey)),
+  };
+}

package/lib/sidebar/shelves.ts

@@ -267,11 +267,16 @@ export function buildShelves(input: ShelfInput): Shelves {
 
   const top: SidebarRow[] = [];
   for (const row of rows) {
-    // A quick change always sits under the orchestrator that makes it: it's
-    // that orchestrator's to carry, never one that needs you.
-    const owner = row.session.quick_of
-      ? byId.get(row.session.quick_of)
-      : undefined;
+    // A quick change sits under the orchestrator that makes it: it's that
+    // orchestrator's to carry, never one that needs you. Once merged it
+    // leaves for the shelves, so Done can take it.
+    const finished =
+      (row.task && isFinished(row.task)) ||
+      row.session.task_status === "merged";
+    const owner =
+      row.session.quick_of && !finished
+        ? byId.get(row.session.quick_of)
+        : undefined;
     if (owner) {
       (owner.quick ??= []).push(row);
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.561",
+  "version": "0.3.564",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"