@agentrific/server 0.1.4 → 0.1.6

package/index.js

@@ -7,6 +7,303 @@ process.on("warning", (warning) => {
   for (const handler of handlers) handler.call(process, warning);
 });
 
+// src/push.ts
+import {
+  generateKeyPairSync,
+  createPrivateKey,
+  createPublicKey,
+  sign,
+  randomUUID
+} from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { Effect } from "effect";
+
+// ../../packages/contracts/src/push.ts
+import { z } from "zod";
+var PUSH_API_URL = "https://api.agentrific.com";
+var PushKindSchema = z.enum([
+  "started",
+  "completed",
+  "needs_input",
+  "prepared",
+  "drafting_pr",
+  "pr_created",
+  "failed"
+]);
+var PushPreferencesSchema = z.array(PushKindSchema).max(7);
+var PushPublicKeySchema = z.string().regex(/^[a-f0-9]{64}$/);
+var PushInstallationSchema = z.object({ installationId: z.string().uuid(), token: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var PushRegistrationSchema = z.object({
+  expoToken: z.string().regex(/^(Expo|Exponent)PushToken\[[A-Za-z0-9_-]+\]$/),
+  preferences: PushPreferencesSchema
+}).strict();
+var PushEnrollmentSchema = z.object({ serverId: z.string().uuid(), publicKey: PushPublicKeySchema }).strict();
+var PushGrantSchema = PushEnrollmentSchema.extend({
+  installationId: z.string().uuid(),
+  bindingId: z.string().uuid(),
+  grant: z.string().regex(/^[a-f0-9]{64}$/),
+  expiresAt: z.number()
+}).strict();
+var PushPullRequestUrlSchema = z.string().max(512).regex(/^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/[1-9][0-9]*$/);
+var PushEventSchema = z.object({
+  eventId: z.string().uuid(),
+  sessionId: z.string().uuid(),
+  kind: PushKindSchema,
+  taskTitle: z.string().trim().min(1).max(160).optional(),
+  prUrl: PushPullRequestUrlSchema.optional()
+}).strict();
+var PushSignedRequestSchema = z.object({
+  bindingId: z.string().uuid(),
+  timestamp: z.number().int(),
+  nonce: z.string().uuid(),
+  payload: z.string().max(2048),
+  signature: z.string().regex(/^[a-f0-9]{128}$/)
+}).strict();
+var PushEntitlementSchema = z.object({ active: z.boolean(), expiresAt: z.number().nullable() }).strict();
+var PushServerStatusSchema = z.object({
+  publicKey: PushPublicKeySchema,
+  bindings: z.array(
+    z.object({
+      bindingId: z.string().uuid(),
+      installationId: z.string().uuid(),
+      deviceId: z.string().uuid()
+    })
+  ),
+  pending: z.number().int().nonnegative(),
+  error: z.string().nullable()
+});
+function pushSigningText(installationId, operation, request) {
+  return [
+    "agentrific-push-v1",
+    installationId,
+    operation,
+    request.bindingId,
+    request.timestamp,
+    request.nonce,
+    request.payload
+  ].join("\n");
+}
+
+// src/push.ts
+function pushKind(session, previous) {
+  if (session.gitDelivery?.status === "pr_opened" && previous?.gitDelivery?.status !== "pr_opened")
+    return "pr_created";
+  if (["merged", "no_changes"].includes(session.gitDelivery?.status ?? "") && session.gitDelivery?.status !== previous?.gitDelivery?.status)
+    return "completed";
+  if (session.gitDelivery?.status === "failed" && previous?.gitDelivery?.status !== "failed")
+    return "failed";
+  if (session.gitDelivery?.stage === "opening_pr" && previous?.gitDelivery?.stage !== "opening_pr")
+    return "drafting_pr";
+  if (session.preparation?.status === "ready" && previous?.preparation?.status !== "ready")
+    return "prepared";
+  if (session.status === previous?.status) return void 0;
+  switch (session.status) {
+    case "running":
+      return "started";
+    case "completed":
+      return session.gitFlow ? void 0 : "completed";
+    case "waiting_for_input":
+      return "needs_input";
+    case "failed":
+      return "failed";
+    default:
+      return void 0;
+  }
+}
+var ServerPush = class {
+  constructor(store2, serverId, directory, transport = fetch, apiUrl = PUSH_API_URL) {
+    this.store = store2;
+    this.serverId = serverId;
+    this.transport = transport;
+    this.apiUrl = apiUrl;
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    const filename = path.join(directory, "push-signing-key.pem");
+    if (!existsSync(filename))
+      writeFileSync(
+        filename,
+        generateKeyPairSync("ed25519").privateKey.export({ format: "pem", type: "pkcs8" }),
+        { mode: 384, flag: "wx" }
+      );
+    this.key = createPrivateKey(readFileSync(filename));
+    this.publicKey = createPublicKey(this.key).export({ format: "der", type: "spki" }).subarray(-32).toString("hex");
+  }
+  store;
+  serverId;
+  transport;
+  apiUrl;
+  key;
+  publicKey;
+  draining;
+  timer;
+  stopped = false;
+  pending(session, previous) {
+    const kind = pushKind(session, previous);
+    const state = Effect.runSync(this.store.pushState());
+    if (!kind || !state.bindings.length) return void 0;
+    return {
+      eventId: randomUUID(),
+      sessionId: session.id,
+      kind,
+      taskTitle: session.title.replace(/[\r\n\t]+/g, " ").trim().slice(0, 160) || void 0,
+      prUrl: kind === "pr_created" ? PushPullRequestUrlSchema.safeParse(session.gitDelivery?.url).data : void 0,
+      remaining: state.bindings,
+      createdAt: Date.now(),
+      attempts: 0,
+      nextAt: Date.now()
+    };
+  }
+  status(deviceId) {
+    const state = Effect.runSync(this.store.pushState());
+    return {
+      publicKey: this.publicKey,
+      bindings: state.bindings.filter((binding) => binding.deviceId === deviceId),
+      pending: Effect.runSync(this.store.pendingPush()).length,
+      error: state.error
+    };
+  }
+  async send(installationId, bindingId, operation, payload) {
+    const request = { bindingId, timestamp: Date.now(), nonce: randomUUID(), payload };
+    const signature = sign(
+      null,
+      Buffer.from(pushSigningText(installationId, operation, request)),
+      this.key
+    ).toString("hex");
+    return this.transport(`${this.apiUrl}/v1/installations/${installationId}/${operation}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...request, signature }),
+      signal: AbortSignal.timeout(1e4),
+      redirect: "error"
+    });
+  }
+  async bind(grant, deviceId) {
+    if (grant.serverId !== this.serverId || grant.publicKey !== this.publicKey || grant.expiresAt <= Date.now())
+      throw new Error("Grant does not match this server or has expired");
+    const existing = Effect.runSync(this.store.pushState());
+    if (existing.bindings.length >= 10 && !existing.bindings.some((binding) => binding.deviceId === deviceId))
+      throw new Error("Server notification binding limit reached");
+    const response = await this.send(
+      grant.installationId,
+      grant.bindingId,
+      "redeem",
+      JSON.stringify({ grant: grant.grant })
+    );
+    if (!response.ok)
+      throw new Error("Notification enrolment failed; enable push again to obtain a fresh grant");
+    const state = Effect.runSync(this.store.pushState());
+    state.bindings = state.bindings.filter((binding) => binding.deviceId !== deviceId);
+    state.bindings.push({
+      installationId: grant.installationId,
+      bindingId: grant.bindingId,
+      deviceId
+    });
+    state.error = null;
+    await Effect.runPromise(this.store.savePushState(state));
+    return this.status(deviceId);
+  }
+  unbind(deviceId) {
+    const state = Effect.runSync(this.store.pushState());
+    state.bindings = state.bindings.filter((binding) => binding.deviceId !== deviceId);
+    Effect.runSync(this.store.savePushState(state));
+  }
+  start() {
+    this.timer = setInterval(() => void this.flush(), 5e3);
+    this.timer.unref();
+    void this.flush();
+  }
+  flush() {
+    if (this.stopped) return Promise.resolve();
+    this.draining ??= this.drain().catch(() => {
+      const state = Effect.runSync(this.store.pushState());
+      state.error = "Notification delivery temporarily unavailable";
+      Effect.runSync(this.store.savePushState(state));
+    }).finally(() => {
+      this.draining = void 0;
+    });
+    return this.draining;
+  }
+  async drain() {
+    for (const job of Effect.runSync(this.store.pendingPush())) {
+      if (job.createdAt + 36e5 < Date.now() || job.attempts >= 12) {
+        Effect.runSync(this.store.removePush(job.eventId));
+        continue;
+      }
+      if (job.nextAt > Date.now()) continue;
+      const remaining = [];
+      for (const binding of job.remaining) {
+        const state2 = Effect.runSync(this.store.pushState());
+        const device = Effect.runSync(this.store.devices()).find(
+          (device2) => device2.id === binding.deviceId
+        );
+        if (!device || device.revokedAt !== null || !state2.bindings.some((current) => current.bindingId === binding.bindingId))
+          continue;
+        try {
+          const response = await this.send(
+            binding.installationId,
+            binding.bindingId,
+            "events",
+            JSON.stringify({
+              eventId: job.eventId,
+              sessionId: job.sessionId,
+              kind: job.kind,
+              taskTitle: job.taskTitle,
+              prUrl: job.prUrl
+            })
+          );
+          if (response.ok) continue;
+          if ([401, 403, 404].includes(response.status)) {
+            this.unbind(binding.deviceId);
+            continue;
+          }
+          remaining.push(binding);
+        } catch {
+          remaining.push(binding);
+        }
+      }
+      if (!remaining.length) Effect.runSync(this.store.removePush(job.eventId));
+      else
+        Effect.runSync(
+          this.store.savePendingPush({
+            ...job,
+            remaining,
+            attempts: job.attempts + 1,
+            nextAt: Date.now() + Math.min(3e5, 5e3 * 2 ** job.attempts)
+          })
+        );
+      const state = Effect.runSync(this.store.pushState());
+      state.error = remaining.length ? "Notification delivery pending; check subscription and connectivity" : null;
+      Effect.runSync(this.store.savePushState(state));
+    }
+  }
+  async close() {
+    this.stopped = true;
+    clearInterval(this.timer);
+    await this.draining;
+  }
+};
+function registerPushRoutes(app2, push2, security2) {
+  function deviceId(authorization) {
+    const device = security2.authenticate((authorization ?? "").slice(7));
+    if (!device) throw new Error("Pair this device");
+    return device.id;
+  }
+  app2.get("/api/push", (request) => push2.status(deviceId(request.headers.authorization)));
+  app2.post("/api/push/bind", async (request, reply) => {
+    const grant = PushGrantSchema.safeParse(request.body);
+    if (!grant.success) return reply.code(400).send({ error: "Invalid notification enrolment" });
+    try {
+      return await push2.bind(grant.data, deviceId(request.headers.authorization));
+    } catch {
+      return reply.code(400).send({ error: "Could not enable notifications. Check your subscription and try again." });
+    }
+  });
+  app2.delete("/api/push/bind", (request) => {
+    push2.unbind(deviceId(request.headers.authorization));
+    return { disabled: true };
+  });
+}
+
 // src/index.ts
 import Fastify from "fastify";
 import pretty from "pino-pretty";
@@ -15,17 +312,17 @@ import cors from "@fastify/cors";
 import multipart from "@fastify/multipart";
 
 // src/attachments.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { createReadStream, createWriteStream } from "node:fs";
 import { mkdir, readFile, rm, stat, readdir } from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 import { pipeline } from "node:stream/promises";
 import sharp from "sharp";
-import { Context, Data, Effect, Layer } from "effect";
-import { z as z2 } from "zod";
+import { Context, Data, Effect as Effect2, Layer } from "effect";
+import { z as z3 } from "zod";
 
 // ../../packages/contracts/src/index.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var cronBounds = [
   [0, 59],
   [0, 23],
@@ -69,10 +366,10 @@ function cronMatches(expression, date) {
   const day = fields[2].wildcard || fields[4].wildcard ? matches[2] && matches[4] : matches[2] || matches[4];
   return Boolean(matches[0] && matches[1] && matches[3] && day);
 }
-var AutomationConfigSchema = z.object({
-  enabled: z.boolean(),
-  parallelism: z.number().int().min(1).max(32),
-  cron: z.string().trim().min(1).max(100).superRefine((value, context) => {
+var AutomationConfigSchema = z2.object({
+  enabled: z2.boolean(),
+  parallelism: z2.number().int().min(1).max(32),
+  cron: z2.string().trim().min(1).max(100).superRefine((value, context) => {
     try {
       cronFields(value);
     } catch (error) {
@@ -82,15 +379,15 @@ var AutomationConfigSchema = z.object({
       });
     }
   }),
-  projectIds: z.array(z.string().min(1).max(200)).max(1e3).refine((ids) => new Set(ids).size === ids.length, "Projects must be unique.")
+  projectIds: z2.array(z2.string().min(1).max(200)).max(1e3).refine((ids) => new Set(ids).size === ids.length, "Projects must be unique.")
 });
-var AutomationStateSchema = z.object({
+var AutomationStateSchema = z2.object({
   config: AutomationConfigSchema,
-  order: z.array(z.string()),
-  lastMinute: z.string().nullable(),
-  error: z.string().nullable()
+  order: z2.array(z2.string()),
+  lastMinute: z2.string().nullable(),
+  error: z2.string().nullable()
 });
-var SessionStatusSchema = z.enum([
+var SessionStatusSchema = z2.enum([
   "queued",
   "starting",
   "running",
@@ -99,36 +396,36 @@ var SessionStatusSchema = z.enum([
   "failed",
   "stopped"
 ]);
-var AgentKindSchema = z.enum(["pi"]);
-var ModelReferenceSchema = z.object({
-  platformId: z.string().min(1).max(200),
-  modelId: z.string().min(1).max(500)
+var AgentKindSchema = z2.enum(["pi"]);
+var ModelReferenceSchema = z2.object({
+  platformId: z2.string().min(1).max(200),
+  modelId: z2.string().min(1).max(500)
 });
 var ModelIdentitySchema = ModelReferenceSchema.extend({
-  name: z.string(),
-  platformName: z.string(),
-  providerId: z.string(),
-  providerName: z.string()
+  name: z2.string(),
+  platformName: z2.string(),
+  providerId: z2.string(),
+  providerName: z2.string()
 });
 var ModelOptionSchema = ModelIdentitySchema.extend({
-  available: z.boolean(),
-  reasoning: z.boolean(),
-  input: z.array(z.enum(["text", "image"])),
-  contextWindow: z.number()
+  available: z2.boolean(),
+  reasoning: z2.boolean(),
+  input: z2.array(z2.enum(["text", "image"])),
+  contextWindow: z2.number()
 });
-var ModelCatalogSchema = z.object({
-  models: z.array(ModelOptionSchema),
+var ModelCatalogSchema = z2.object({
+  models: z2.array(ModelOptionSchema),
   defaultModel: ModelIdentitySchema.nullable(),
-  refreshedAt: z.string().datetime(),
-  warning: z.string().nullable()
+  refreshedAt: z2.string().datetime(),
+  warning: z2.string().nullable()
 });
-var GitFlowSchema = z.object({
-  workspace: z.enum(["checkout", "worktree"]),
-  delivery: z.enum(["merge", "pull_request"])
+var GitFlowSchema = z2.object({
+  workspace: z2.enum(["checkout", "worktree"]),
+  delivery: z2.enum(["merge", "pull_request"])
 });
-var GitDeliverySchema = z.object({
-  status: z.enum(["pending", "waiting", "merged", "no_changes", "pr_opened", "failed"]),
-  stage: z.enum([
+var GitDeliverySchema = z2.object({
+  status: z2.enum(["pending", "waiting", "merged", "no_changes", "pr_opened", "failed"]),
+  stage: z2.enum([
     "validating",
     "drafting",
     "committing",
@@ -140,165 +437,165 @@ var GitDeliverySchema = z.object({
     "blocked",
     "delivered"
   ]).optional(),
-  commitSha: z.string().optional(),
-  attempt: z.number().int().positive().optional(),
-  logs: z.string().optional(),
-  url: z.string().url().optional(),
-  message: z.string().optional()
+  commitSha: z2.string().optional(),
+  attempt: z2.number().int().positive().optional(),
+  logs: z2.string().optional(),
+  url: z2.string().url().optional(),
+  message: z2.string().optional()
 });
-var DeliveryRequestSchema = z.object({
-  summary: z.string().trim().min(1).max(1e3),
-  verification: z.array(z.string().max(1e3)).max(20).default([])
+var DeliveryRequestSchema = z2.object({
+  summary: z2.string().trim().min(1).max(1e3),
+  verification: z2.array(z2.string().max(1e3)).max(20).default([])
 });
-var RunPreparationSchema = z.object({
-  status: z.enum(["creating", "installing", "ready", "failed"]),
-  message: z.string(),
-  logs: z.string().optional()
+var RunPreparationSchema = z2.object({
+  status: z2.enum(["creating", "installing", "ready", "failed"]),
+  message: z2.string(),
+  logs: z2.string().optional()
 });
-var SessionSchema = z.object({
-  id: z.string(),
-  taskId: z.string().nullable().optional(),
-  projectId: z.string(),
-  title: z.string(),
+var SessionSchema = z2.object({
+  id: z2.string(),
+  taskId: z2.string().nullable().optional(),
+  projectId: z2.string(),
+  title: z2.string(),
   status: SessionStatusSchema,
   agent: AgentKindSchema,
   model: ModelIdentitySchema.optional(),
-  branch: z.string().nullable(),
-  workspacePath: z.string().optional(),
+  branch: z2.string().nullable(),
+  workspacePath: z2.string().optional(),
   gitFlow: GitFlowSchema.optional(),
   gitDelivery: GitDeliverySchema.optional(),
   preparation: RunPreparationSchema.optional(),
-  createdAt: z.string().datetime(),
-  updatedAt: z.string().datetime()
+  createdAt: z2.string().datetime(),
+  updatedAt: z2.string().datetime()
 });
 var MAX_ATTACHMENTS = 5;
 var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-var AttachmentSchema = z.object({
-  id: z.string().uuid(),
-  projectId: z.string(),
-  name: z.string(),
-  mimeType: z.string(),
-  size: z.number().int().nonnegative(),
-  kind: z.enum(["image", "text"]),
-  createdAt: z.string().datetime()
+var AttachmentSchema = z2.object({
+  id: z2.string().uuid(),
+  projectId: z2.string(),
+  name: z2.string(),
+  mimeType: z2.string(),
+  size: z2.number().int().nonnegative(),
+  kind: z2.enum(["image", "text"]),
+  createdAt: z2.string().datetime()
 });
-var AttachmentIdsSchema = z.array(z.string().uuid()).max(MAX_ATTACHMENTS).refine((ids) => new Set(ids).size === ids.length, "Choose each attachment once.");
-var CreateSessionSchema = z.object({
-  projectId: z.string().min(1),
-  taskId: z.string().optional(),
-  prompt: z.string().min(1),
+var AttachmentIdsSchema = z2.array(z2.string().uuid()).max(MAX_ATTACHMENTS).refine((ids) => new Set(ids).size === ids.length, "Choose each attachment once.");
+var CreateSessionSchema = z2.object({
+  projectId: z2.string().min(1),
+  taskId: z2.string().optional(),
+  prompt: z2.string().min(1),
   agent: AgentKindSchema.default("pi"),
   model: ModelReferenceSchema.optional(),
   gitFlow: GitFlowSchema.optional(),
   attachmentIds: AttachmentIdsSchema.optional()
 });
-var SendMessageSchema = z.object({
-  message: z.string().trim().max(2e4),
+var SendMessageSchema = z2.object({
+  message: z2.string().trim().max(2e4),
   attachmentIds: AttachmentIdsSchema.optional(),
-  clientMessageId: z.string().min(1).max(120).optional()
+  clientMessageId: z2.string().min(1).max(120).optional()
 }).refine(
   (input) => input.message.length > 0 || (input.attachmentIds?.length ?? 0) > 0,
   "Write a message or attach a file."
 );
-var SessionEventSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("session.updated"), session: SessionSchema }),
-  z.object({
-    type: z.literal("message.user"),
-    sessionId: z.string(),
-    messageId: z.string().optional(),
-    text: z.string(),
-    attachments: z.array(AttachmentSchema).optional()
+var SessionEventSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("session.updated"), session: SessionSchema }),
+  z2.object({
+    type: z2.literal("message.user"),
+    sessionId: z2.string(),
+    messageId: z2.string().optional(),
+    text: z2.string(),
+    attachments: z2.array(AttachmentSchema).optional()
   }),
-  z.object({
-    type: z.literal("message.started"),
+  z2.object({
+    type: z2.literal("message.started"),
     model: ModelIdentitySchema.optional(),
-    sessionId: z.string(),
-    messageId: z.string().optional()
+    sessionId: z2.string(),
+    messageId: z2.string().optional()
   }),
-  z.object({
-    type: z.literal("message.delta"),
+  z2.object({
+    type: z2.literal("message.delta"),
     model: ModelIdentitySchema.optional(),
-    sessionId: z.string(),
-    messageId: z.string().optional(),
-    text: z.string()
+    sessionId: z2.string(),
+    messageId: z2.string().optional(),
+    text: z2.string()
   }),
-  z.object({
-    type: z.literal("message.completed"),
+  z2.object({
+    type: z2.literal("message.completed"),
     model: ModelIdentitySchema.optional(),
-    sessionId: z.string(),
-    messageId: z.string().optional(),
-    text: z.string()
+    sessionId: z2.string(),
+    messageId: z2.string().optional(),
+    text: z2.string()
   }),
-  z.object({
-    type: z.literal("tool.started"),
-    sessionId: z.string(),
-    toolCallId: z.string().optional(),
-    tool: z.string(),
-    input: z.string()
+  z2.object({
+    type: z2.literal("tool.started"),
+    sessionId: z2.string(),
+    toolCallId: z2.string().optional(),
+    tool: z2.string(),
+    input: z2.string()
   }),
-  z.object({
-    type: z.literal("tool.completed"),
-    sessionId: z.string(),
-    toolCallId: z.string().optional(),
-    tool: z.string(),
-    output: z.string(),
-    isError: z.boolean().default(false)
+  z2.object({
+    type: z2.literal("tool.completed"),
+    sessionId: z2.string(),
+    toolCallId: z2.string().optional(),
+    tool: z2.string(),
+    output: z2.string(),
+    isError: z2.boolean().default(false)
   }),
-  z.object({
-    type: z.literal("activity.updated"),
-    sessionId: z.string(),
-    state: z.enum(["thinking", "responding", "idle"])
+  z2.object({
+    type: z2.literal("activity.updated"),
+    sessionId: z2.string(),
+    state: z2.enum(["thinking", "responding", "idle"])
   }),
-  z.object({ type: z.literal("error"), sessionId: z.string(), message: z.string() })
+  z2.object({ type: z2.literal("error"), sessionId: z2.string(), message: z2.string() })
 ]);
-var RecordedEventSchema = z.object({
-  sequence: z.number().int().positive(),
-  recordedAt: z.string().datetime(),
+var RecordedEventSchema = z2.object({
+  sequence: z2.number().int().positive(),
+  recordedAt: z2.string().datetime(),
   event: SessionEventSchema
 });
-var EventHistorySchema = z.object({
-  events: z.array(RecordedEventSchema),
-  cursor: z.number().int().nonnegative(),
-  hasMore: z.boolean()
+var EventHistorySchema = z2.object({
+  events: z2.array(RecordedEventSchema),
+  cursor: z2.number().int().nonnegative(),
+  hasMore: z2.boolean()
 });
-var ServerEventSchema = z.union([
-  z.object({ type: z.literal("snapshot"), sessions: z.array(SessionSchema) }),
-  z.object({ type: z.literal("event"), record: RecordedEventSchema })
+var ServerEventSchema = z2.union([
+  z2.object({ type: z2.literal("snapshot"), sessions: z2.array(SessionSchema) }),
+  z2.object({ type: z2.literal("event"), record: RecordedEventSchema })
 ]);
-var ServerSettingsSchema = z.object({
-  projectsRoot: z.string().min(1),
+var ServerSettingsSchema = z2.object({
+  projectsRoot: z2.string().min(1),
   defaultModel: ModelIdentitySchema.nullable().optional()
 });
-var ConnectionsStatusSchema = z.object({
-  githubCli: z.object({ installed: z.boolean(), authenticated: z.boolean() })
+var ConnectionsStatusSchema = z2.object({
+  githubCli: z2.object({ installed: z2.boolean(), authenticated: z2.boolean() })
 });
-var UpdateSettingsSchema = z.object({ projectsRoot: z.string().trim().min(1).max(4096) });
-var ProjectSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  path: z.string(),
-  available: z.boolean().default(true)
+var UpdateSettingsSchema = z2.object({ projectsRoot: z2.string().trim().min(1).max(4096) });
+var ProjectSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  path: z2.string(),
+  available: z2.boolean().default(true)
 });
-var TaskStatusSchema = z.enum(["backlog", "needs_user_input", "running", "done"]);
-var TaskSchema = z.object({
-  id: z.string(),
-  projectId: z.string(),
-  title: z.string(),
-  prompt: z.string(),
-  attachments: z.array(AttachmentSchema).optional(),
+var TaskStatusSchema = z2.enum(["backlog", "needs_user_input", "running", "done"]);
+var TaskSchema = z2.object({
+  id: z2.string(),
+  projectId: z2.string(),
+  title: z2.string(),
+  prompt: z2.string(),
+  attachments: z2.array(AttachmentSchema).optional(),
   model: ModelReferenceSchema.optional(),
   gitFlow: GitFlowSchema.optional(),
   status: TaskStatusSchema,
-  sessionId: z.string().nullable(),
-  pullRequestUrl: z.string().url().optional(),
-  createdAt: z.string().datetime(),
-  updatedAt: z.string().datetime(),
-  deletedAt: z.string().datetime().optional()
+  sessionId: z2.string().nullable(),
+  pullRequestUrl: z2.string().url().optional(),
+  createdAt: z2.string().datetime(),
+  updatedAt: z2.string().datetime(),
+  deletedAt: z2.string().datetime().optional()
 });
-var CreateTaskSchema = z.object({
-  projectId: z.string().min(1),
-  title: z.string().trim().min(1).max(120),
-  prompt: z.string().trim().max(2e4).default(""),
+var CreateTaskSchema = z2.object({
+  projectId: z2.string().min(1),
+  title: z2.string().trim().min(1).max(120),
+  prompt: z2.string().trim().max(2e4).default(""),
   attachmentIds: AttachmentIdsSchema.optional(),
   model: ModelReferenceSchema.optional(),
   gitFlow: GitFlowSchema.optional()
@@ -310,57 +607,62 @@ var UpdateTaskSchema = CreateTaskSchema.pick({
   gitFlow: true
 }).extend({ gitFlow: GitFlowSchema.nullable().optional() }).strict();
 var PROTOCOL_VERSION = 1;
-var ServerUpdateStatusSchema = z.object({
-  currentVersion: z.string(),
-  latestVersion: z.string().optional(),
-  available: z.boolean(),
-  published: z.boolean().nullable(),
-  canAutoUpdate: z.literal(false),
-  checkedAt: z.string().datetime().nullable(),
-  error: z.string().nullable()
+var ServerUpdateStatusSchema = z2.object({
+  currentVersion: z2.string(),
+  latestVersion: z2.string().optional(),
+  available: z2.boolean(),
+  published: z2.boolean().nullable(),
+  canAutoUpdate: z2.literal(false),
+  checkedAt: z2.string().datetime().nullable(),
+  error: z2.string().nullable()
 });
-var ServerHealthSchema = z.object({
-  status: z.literal("ok"),
-  service: z.literal("agentrific-server"),
-  serverId: z.string().uuid(),
-  serverVersion: z.string(),
-  protocolVersion: z.literal(PROTOCOL_VERSION),
-  authentication: z.literal("pairing")
+var ServerHealthSchema = z2.object({
+  status: z2.literal("ok"),
+  service: z2.literal("agentrific-server"),
+  serverId: z2.string().uuid(),
+  serverVersion: z2.string(),
+  protocolVersion: z2.literal(PROTOCOL_VERSION),
+  authentication: z2.literal("pairing")
 });
-var PairingPayloadSchema = z.object({
-  v: z.literal(1),
-  url: z.string().url(),
-  serverId: z.string().uuid(),
-  pairingId: z.string().regex(/^[a-f0-9]{64}$/)
+var PairingPayloadSchema = z2.object({
+  v: z2.literal(1),
+  url: z2.string().url(),
+  serverId: z2.string().uuid(),
+  pairingId: z2.string().regex(/^[a-f0-9]{64}$/)
 });
-var PairingRequestSchema = z.object({
-  pairingId: z.string().regex(/^[a-f0-9]{64}$/),
-  pin: z.string().regex(/^\d{6}$/),
-  deviceName: z.string().trim().min(1).max(100),
-  platform: z.enum(["ios", "android", "web"])
+var PairingInvitationSchema = z2.object({
+  payload: PairingPayloadSchema,
+  pin: z2.string().regex(/^\d{6}$/),
+  expiresAt: z2.number()
 });
-var DeviceSchema = z.object({
-  id: z.string().uuid(),
-  name: z.string(),
-  platform: z.enum(["ios", "android", "web"]),
-  createdAt: z.number(),
-  lastSeenAt: z.number(),
-  revokedAt: z.number().nullable()
+var PairingRequestSchema = z2.object({
+  pairingId: z2.string().regex(/^[a-f0-9]{64}$/),
+  pin: z2.string().regex(/^\d{6}$/),
+  deviceName: z2.string().trim().min(1).max(100),
+  platform: z2.enum(["ios", "android", "web"])
 });
-var PairingResultSchema = z.object({
-  deviceId: z.string().uuid(),
-  deviceToken: z.string().regex(/^[a-f0-9]{64}$/),
-  serverId: z.string().uuid()
+var DeviceSchema = z2.object({
+  id: z2.string().uuid(),
+  name: z2.string(),
+  platform: z2.enum(["ios", "android", "web"]),
+  createdAt: z2.number(),
+  lastSeenAt: z2.number(),
+  revokedAt: z2.number().nullable()
 });
-var HandshakeSchema = z.object({
-  type: z.literal("client.handshake"),
-  ticket: z.string().regex(/^[a-f0-9]{64}$/),
-  protocolVersion: z.literal(PROTOCOL_VERSION)
+var PairingResultSchema = z2.object({
+  deviceId: z2.string().uuid(),
+  deviceToken: z2.string().regex(/^[a-f0-9]{64}$/),
+  serverId: z2.string().uuid()
 });
-var HandshakeAckSchema = z.object({
-  type: z.literal("handshake.ack"),
-  serverId: z.string().uuid(),
-  protocolVersion: z.literal(PROTOCOL_VERSION)
+var HandshakeSchema = z2.object({
+  type: z2.literal("client.handshake"),
+  ticket: z2.string().regex(/^[a-f0-9]{64}$/),
+  protocolVersion: z2.literal(PROTOCOL_VERSION)
+});
+var HandshakeAckSchema = z2.object({
+  type: z2.literal("handshake.ack"),
+  serverId: z2.string().uuid(),
+  protocolVersion: z2.literal(PROTOCOL_VERSION)
 });
 
 // src/attachments.ts
@@ -413,10 +715,10 @@ var AttachmentFiles = class {
   root;
   store;
   directory(id) {
-    return path.join(this.root, z2.string().uuid().parse(id));
+    return path2.join(this.root, z3.string().uuid().parse(id));
   }
   io(operation) {
-    return Effect.tryPromise({
+    return Effect2.tryPromise({
       try: operation,
       catch: (cause) => new AttachmentError({
         message: cause instanceof Error ? cause.message : "Attachment operation failed."
@@ -425,12 +727,12 @@ var AttachmentFiles = class {
   }
   upload(projectId, part) {
     return this.io(async () => {
-      const id = randomUUID();
+      const id = randomUUID2();
       const directory = this.directory(id);
-      const source = path.join(directory, "source");
-      const nameField = z2.object({ type: z2.literal("field"), value: z2.string() }).safeParse(part.fields.name);
+      const source = path2.join(directory, "source");
+      const nameField = z3.object({ type: z3.literal("field"), value: z3.string() }).safeParse(part.fields.name);
       const originalName = nameField.success ? nameField.data.value : part.filename;
-      const name = path.basename(originalName.replaceAll("\\", "/")).replace(new RegExp("\\p{Cc}", "gu"), "").slice(0, 180) || "attachment";
+      const name = path2.basename(originalName.replaceAll("\\", "/")).replace(new RegExp("\\p{Cc}", "gu"), "").slice(0, 180) || "attachment";
       await mkdir(directory, { recursive: true });
       try {
         await pipeline(part.file, createWriteStream(source, { flags: "wx" }));
@@ -446,7 +748,7 @@ var AttachmentFiles = class {
           ...metadata,
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        await Effect.runPromise(this.store.saveAttachment(attachment));
+        await Effect2.runPromise(this.store.saveAttachment(attachment));
         return attachment;
       } catch (error) {
         await rm(directory, { recursive: true, force: true });
@@ -458,10 +760,10 @@ var AttachmentFiles = class {
     const metadata = await sharp(source, { limitInputPixels: 4e7 }).metadata().catch(() => null);
     const mimeType = metadata?.format && imageMimes.get(metadata.format);
     if (mimeType) {
-      await sharp(source, { limitInputPixels: 4e7 }).rotate().resize({ width: 2048, height: 2048, fit: "inside", withoutEnlargement: true }).png().toFile(path.join(path.dirname(source), "preview.png"));
+      await sharp(source, { limitInputPixels: 4e7 }).rotate().resize({ width: 2048, height: 2048, fit: "inside", withoutEnlargement: true }).png().toFile(path2.join(path2.dirname(source), "preview.png"));
       return { kind: "image", mimeType };
     }
-    if (!textExtensions.has(path.extname(name).toLowerCase()))
+    if (!textExtensions.has(path2.extname(name).toLowerCase()))
       throw new Error(
         "Choose a PNG, JPEG, WebP, GIF, or text/code file. PDF and Office documents aren't supported yet."
       );
@@ -477,12 +779,12 @@ var AttachmentFiles = class {
         throw new Error("Choose up to five different files.");
       const attachments2 = [];
       for (const id of ids) {
-        const attachment = await Effect.runPromise(this.store.getAttachment(id));
+        const attachment = await Effect2.runPromise(this.store.getAttachment(id));
         if (!attachment || attachment.projectId !== projectId)
           throw new Error(
             "An attachment is unavailable for this project. Remove it and upload it again."
           );
-        await stat(path.join(this.directory(id), "source"));
+        await stat(path2.join(this.directory(id), "source"));
         attachments2.push(attachment);
       }
       return attachments2;
@@ -490,7 +792,7 @@ var AttachmentFiles = class {
   }
   content(attachment, preview) {
     return createReadStream(
-      path.join(
+      path2.join(
         this.directory(attachment.id),
         preview && attachment.kind === "image" ? "preview.png" : "source"
       )
@@ -501,9 +803,9 @@ var AttachmentFiles = class {
       const images = [];
       const sections = [];
       for (const attachment of attachments2) {
-        const source = path.join(this.directory(attachment.id), "source");
+        const source = path2.join(this.directory(attachment.id), "source");
         if (attachment.kind === "image") {
-          const bytes = await readFile(path.join(this.directory(attachment.id), "preview.png"));
+          const bytes = await readFile(path2.join(this.directory(attachment.id), "preview.png"));
           images.push({ type: "image", data: bytes.toString("base64"), mimeType: "image/png" });
           sections.push(`Image attachment: ${JSON.stringify(attachment.name)}`);
         } else {
@@ -526,18 +828,18 @@ ${text.slice(0, 12e3)}${text.length > 12e3 ? "\n[Preview truncated; use the read
   cleanup() {
     return this.io(async () => {
       const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
-      const expired = await Effect.runPromise(
+      const expired = await Effect2.runPromise(
         this.store.expiredAttachments(new Date(cutoff).toISOString())
       );
       for (const attachment of expired) {
-        if (await Effect.runPromise(this.store.deleteAttachment(attachment.id)))
+        if (await Effect2.runPromise(this.store.deleteAttachment(attachment.id)))
           await rm(this.directory(attachment.id), { recursive: true, force: true });
       }
       await mkdir(this.root, { recursive: true });
       for (const entry of await readdir(this.root, { withFileTypes: true })) {
-        if (!entry.isDirectory() || !z2.string().uuid().safeParse(entry.name).success) continue;
+        if (!entry.isDirectory() || !z3.string().uuid().safeParse(entry.name).success) continue;
         const directory = this.directory(entry.name);
-        if ((await stat(directory)).mtimeMs < cutoff && !await Effect.runPromise(this.store.getAttachment(entry.name)))
+        if ((await stat(directory)).mtimeMs < cutoff && !await Effect2.runPromise(this.store.getAttachment(entry.name)))
           await rm(directory, { recursive: true, force: true });
       }
     });
@@ -552,12 +854,12 @@ var Attachments = class extends Context.Service()(
 };
 
 // src/index.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path7 from "node:path";
+import path9 from "node:path";
 import { WebSocket } from "ws";
 
 // src/event-server.ts
@@ -624,153 +926,18 @@ function attachEventServer(app2, security2, origins, snapshot) {
 }
 
 // src/security.ts
-import { createHash, randomBytes, randomInt, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
-import { Effect as Effect2 } from "effect";
-import { z as z3 } from "zod";
-var secret = () => randomBytes(32).toString("hex");
-var digest = (value) => createHash("sha256").update(value).digest("hex");
-var ServerSecurity = class {
-  constructor(store2, serverId) {
-    this.store = store2;
-    this.serverId = serverId;
-  }
-  store;
-  serverId;
-  grants = /* @__PURE__ */ new Map();
-  tickets = /* @__PURE__ */ new Map();
-  attempts = /* @__PURE__ */ new Map();
-  sockets = /* @__PURE__ */ new Map();
-  prune() {
-    const now = Date.now();
-    for (const [key, grant] of this.grants) if (grant.expiresAt <= now) this.grants.delete(key);
-    for (const [key, ticket] of this.tickets) if (ticket.expiresAt <= now) this.tickets.delete(key);
-    for (const [key, attempts] of this.attempts)
-      if (attempts.until <= now) this.attempts.delete(key);
-  }
-  createPairing() {
-    this.prune();
-    if (this.grants.size >= 10)
-      throw new Error("Too many pending enrollments. Wait for them to expire.");
-    const pairingId = secret();
-    const grant = {
-      pin: String(randomInt(1e6)).padStart(6, "0"),
-      expiresAt: Date.now() + 3e5,
-      attempts: 0
-    };
-    this.grants.set(pairingId, grant);
-    return { pairingId, pin: grant.pin, expiresAt: grant.expiresAt, serverId: this.serverId };
-  }
-  async pair(input, address) {
-    this.prune();
-    const attempts = this.attempts.get(address) ?? { count: 0, until: Date.now() + 6e4 };
-    if (attempts.count >= 20 || !this.attempts.has(address) && this.attempts.size >= 5e3)
-      return void 0;
-    attempts.count++;
-    this.attempts.set(address, attempts);
-    const grant = this.grants.get(input.pairingId);
-    if (!grant) return void 0;
-    grant.attempts++;
-    const match = timingSafeEqual(Buffer.from(grant.pin), Buffer.from(input.pin));
-    if (grant.attempts >= 3 || match) this.grants.delete(input.pairingId);
-    if (!match) return void 0;
-    const token = secret();
-    const now = Date.now();
-    const device = {
-      id: randomUUID2(),
-      name: input.deviceName,
-      platform: input.platform,
-      createdAt: now,
-      lastSeenAt: now,
-      revokedAt: null
-    };
-    await Effect2.runPromise(this.store.saveDevice(device, digest(token)));
-    return { deviceId: device.id, deviceToken: token, serverId: this.serverId };
-  }
-  authenticate(token) {
-    if (!/^[a-f0-9]{64}$/.test(token)) return void 0;
-    return Effect2.runSync(this.store.deviceForToken(digest(token)));
-  }
-  ticket(token, path8) {
-    this.prune();
-    if (!this.authenticate(token) || this.tickets.size >= 1e4) return void 0;
-    const value = secret();
-    this.tickets.set(value, { tokenHash: digest(token), expiresAt: Date.now() + 6e4, path: path8 });
-    return value;
-  }
-  redeemTicket(value, path8, consume = true) {
-    this.prune();
-    const ticket = this.tickets.get(value);
-    if (!ticket || ticket.path !== path8) return void 0;
-    if (consume) this.tickets.delete(value);
-    return Effect2.runSync(this.store.deviceForToken(ticket.tokenHash));
-  }
-  async revoke(id) {
-    const revoked = await Effect2.runPromise(this.store.revokeDevice(id));
-    for (const [socket, owner] of this.sockets)
-      if (owner === id) socket.close(4401, "Device revoked");
-    return revoked;
-  }
-};
-async function registerSecurity(app2, security2, version, allowedOrigins2) {
-  app2.addHook("onRequest", async (request, reply) => {
-    const path8 = new URL(request.url, "http://localhost");
-    reply.header("Cache-Control", "no-store");
-    if (request.method === "OPTIONS") return;
-    if (request.headers.origin && !allowedOrigins2.includes(request.headers.origin))
-      return reply.code(403).send({ error: "Browser origin is not allowed." });
-    if (path8.pathname === "/health" || path8.pathname === "/api/auth/pair" && request.method === "POST")
-      return;
-    const authorization = request.headers.authorization ?? "";
-    const token = authorization.startsWith("Bearer ") ? authorization.slice(7) : "";
-    const asset = request.method === "GET" && /^\/api\/projects\/[^/]+\/attachments\/[^/]+\/content$/.test(path8.pathname);
-    const ticket = path8.searchParams.get("ticket");
-    path8.searchParams.delete("ticket");
-    if (!security2.authenticate(token) && !(asset && ticket && security2.redeemTicket(ticket, path8.pathname + path8.search, false)))
-      return reply.code(401).send({ error: "Pair this device with your server.", code: "UNAUTHORIZED" });
-    if (!asset && request.headers["x-agentrific-protocol"] !== String(PROTOCOL_VERSION))
-      return reply.code(409).send({
-        error: "Update your Agentrific client or server.",
-        code: "VERSION_MISMATCH",
-        protocolVersion: PROTOCOL_VERSION
-      });
-  });
-  app2.get("/health", () => ({
-    status: "ok",
-    service: "agentrific-server",
-    serverId: security2.serverId,
-    serverVersion: version,
-    protocolVersion: PROTOCOL_VERSION,
-    authentication: "pairing"
-  }));
-  app2.post("/api/auth/pair", async (request, reply) => {
-    const input = PairingRequestSchema.safeParse(request.body);
-    if (!input.success)
-      return reply.code(400).send({ error: "Enter a valid pairing payload and six-digit PIN." });
-    const result = await security2.pair(input.data, request.ip);
-    return result ?? reply.code(401).send({ error: "Pairing expired, locked, or invalid. Run agentrific pair again." });
-  });
-  app2.get("/api/auth/session", (request) => ({
-    serverId: security2.serverId,
-    device: security2.authenticate((request.headers.authorization ?? "").slice(7))
-  }));
-  app2.post("/api/auth/event-ticket", (request) => ({
-    ticket: security2.ticket((request.headers.authorization ?? "").slice(7), "/api/events")
-  }));
-  app2.post("/api/auth/asset-ticket", (request, reply) => {
-    const input = z3.object({
-      path: z3.string().regex(/^\/api\/projects\/[^/?]+\/attachments\/[^/?]+\/content(?:\?preview=1)?$/)
-    }).safeParse(request.body);
-    if (!input.success) return reply.code(400).send({ error: "Choose a valid attachment." });
-    return {
-      ticket: security2.ticket((request.headers.authorization ?? "").slice(7), input.data.path)
-    };
-  });
-}
+import { createHash, randomBytes, randomInt, randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
+import { Effect as Effect4 } from "effect";
+import { z as z6 } from "zod";
+
+// src/pairing.ts
+import { z as z5 } from "zod";
+import qrcode from "qrcode-terminal";
 
 // src/control.ts
 import { createServer, createConnection } from "node:net";
 import { chmod, mkdir as mkdir2, readFile as readFile2, unlink, writeFile } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 import { Effect as Effect3 } from "effect";
 import { z as z4 } from "zod";
 var MaintenanceSchema = z4.object({
@@ -814,7 +981,7 @@ var ControlRequest = z4.discriminatedUnion("command", [
 async function acquireServerLock(directory) {
   await mkdir2(directory, { recursive: true, mode: 448 });
   await chmod(directory, 448);
-  const filename = path2.join(directory, "server.lock");
+  const filename = path3.join(directory, "server.lock");
   try {
     await writeFile(filename, String(process.pid), { flag: "wx", mode: 384 });
   } catch (cause) {
@@ -853,7 +1020,7 @@ async function acquireServerLock(directory) {
   };
 }
 async function startControl(directory, security2, status, maintenance2) {
-  const filename = path2.join(directory, "control.sock");
+  const filename = path3.join(directory, "control.sock");
   await unlink(filename).catch((error) => {
     if (!z4.object({ code: z4.literal("ENOENT") }).safeParse(error).success) throw error;
   });
@@ -914,7 +1081,7 @@ async function startControl(directory, security2, status, maintenance2) {
 // package.json
 var package_default = {
   name: "@agentrific/server",
-  version: "0.1.4",
+  version: "0.1.6",
   description: "Self-hosted control plane for long-running coding agents",
   keywords: [
     "agentrific",
@@ -977,6 +1144,180 @@ var package_default = {
 // src/version.ts
 var serverVersion = package_default.version;
 
+// src/pairing.ts
+function pairingOrigin(url) {
+  const endpoint = new URL(url);
+  if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.pathname !== "/")
+    throw new Error("Use the HTTPS server origin without a path or credentials.");
+  if (endpoint.protocol !== "https:" && !(process.env.NODE_ENV !== "production" && endpoint.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(endpoint.hostname)))
+    throw new Error("Use HTTPS. Localhost HTTP is for development builds only.");
+  return endpoint.origin;
+}
+
+// src/security.ts
+var secret = () => randomBytes(32).toString("hex");
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+var ServerSecurity = class {
+  constructor(store2, serverId) {
+    this.store = store2;
+    this.serverId = serverId;
+  }
+  store;
+  serverId;
+  grants = /* @__PURE__ */ new Map();
+  tickets = /* @__PURE__ */ new Map();
+  attempts = /* @__PURE__ */ new Map();
+  sockets = /* @__PURE__ */ new Map();
+  prune() {
+    const now = Date.now();
+    for (const [key, grant] of this.grants) if (grant.expiresAt <= now) this.grants.delete(key);
+    for (const [key, ticket] of this.tickets) if (ticket.expiresAt <= now) this.tickets.delete(key);
+    for (const [key, attempts] of this.attempts)
+      if (attempts.until <= now) this.attempts.delete(key);
+  }
+  createPairing() {
+    this.prune();
+    if (this.grants.size >= 10)
+      throw new Error("Too many pending enrollments. Wait for them to expire.");
+    const pairingId = secret();
+    const grant = {
+      pin: String(randomInt(1e6)).padStart(6, "0"),
+      expiresAt: Date.now() + 3e5,
+      attempts: 0
+    };
+    this.grants.set(pairingId, grant);
+    return { pairingId, pin: grant.pin, expiresAt: grant.expiresAt, serverId: this.serverId };
+  }
+  async pair(input, address) {
+    this.prune();
+    const attempts = this.attempts.get(address) ?? { count: 0, until: Date.now() + 6e4 };
+    if (attempts.count >= 20 || !this.attempts.has(address) && this.attempts.size >= 5e3)
+      return void 0;
+    attempts.count++;
+    this.attempts.set(address, attempts);
+    const grant = this.grants.get(input.pairingId);
+    if (!grant) return void 0;
+    grant.attempts++;
+    const match = timingSafeEqual(Buffer.from(grant.pin), Buffer.from(input.pin));
+    if (grant.attempts >= 3 || match) this.grants.delete(input.pairingId);
+    if (!match) return void 0;
+    const token = secret();
+    const now = Date.now();
+    const device = {
+      id: randomUUID3(),
+      name: input.deviceName,
+      platform: input.platform,
+      createdAt: now,
+      lastSeenAt: now,
+      revokedAt: null
+    };
+    await Effect4.runPromise(this.store.saveDevice(device, digest(token)));
+    return { deviceId: device.id, deviceToken: token, serverId: this.serverId };
+  }
+  authenticate(token) {
+    if (!/^[a-f0-9]{64}$/.test(token)) return void 0;
+    return Effect4.runSync(this.store.deviceForToken(digest(token)));
+  }
+  ticket(token, path10) {
+    this.prune();
+    if (!this.authenticate(token) || this.tickets.size >= 1e4) return void 0;
+    const value = secret();
+    this.tickets.set(value, { tokenHash: digest(token), expiresAt: Date.now() + 6e4, path: path10 });
+    return value;
+  }
+  redeemTicket(value, path10, consume = true) {
+    this.prune();
+    const ticket = this.tickets.get(value);
+    if (!ticket || ticket.path !== path10) return void 0;
+    if (consume) this.tickets.delete(value);
+    return Effect4.runSync(this.store.deviceForToken(ticket.tokenHash));
+  }
+  async revoke(id) {
+    const revoked = await Effect4.runPromise(this.store.revokeDevice(id));
+    for (const [socket, owner] of this.sockets)
+      if (owner === id) socket.close(4401, "Device revoked");
+    return revoked;
+  }
+};
+async function registerSecurity(app2, security2, version, allowedOrigins2) {
+  app2.addHook("onRequest", async (request, reply) => {
+    const path10 = new URL(request.url, "http://localhost");
+    reply.header("Cache-Control", "no-store");
+    if (request.method === "OPTIONS") return;
+    if (request.headers.origin && !allowedOrigins2.includes(request.headers.origin))
+      return reply.code(403).send({ error: "Browser origin is not allowed." });
+    if (path10.pathname === "/health" || path10.pathname === "/api/auth/pair" && request.method === "POST")
+      return;
+    const authorization = request.headers.authorization ?? "";
+    const token = authorization.startsWith("Bearer ") ? authorization.slice(7) : "";
+    const asset = request.method === "GET" && /^\/api\/projects\/[^/]+\/attachments\/[^/]+\/content$/.test(path10.pathname);
+    const ticket = path10.searchParams.get("ticket");
+    path10.searchParams.delete("ticket");
+    if (!security2.authenticate(token) && !(asset && ticket && security2.redeemTicket(ticket, path10.pathname + path10.search, false)))
+      return reply.code(401).send({ error: "Pair this device with your server.", code: "UNAUTHORIZED" });
+    if (!asset && request.headers["x-agentrific-protocol"] !== String(PROTOCOL_VERSION))
+      return reply.code(409).send({
+        error: "Update your Agentrific client or server.",
+        code: "VERSION_MISMATCH",
+        protocolVersion: PROTOCOL_VERSION
+      });
+  });
+  app2.get("/health", () => ({
+    status: "ok",
+    service: "agentrific-server",
+    serverId: security2.serverId,
+    serverVersion: version,
+    protocolVersion: PROTOCOL_VERSION,
+    authentication: "pairing"
+  }));
+  app2.post("/api/auth/pair", async (request, reply) => {
+    const input = PairingRequestSchema.safeParse(request.body);
+    if (!input.success)
+      return reply.code(400).send({ error: "Enter a valid pairing payload and six-digit PIN." });
+    const result = await security2.pair(input.data, request.ip);
+    return result ?? reply.code(401).send({ error: "Pairing expired, locked, or invalid. Run agentrific pair again." });
+  });
+  app2.post("/api/auth/pairing-invitation", (_request, reply) => {
+    const publicUrl = process.env.AGENTRIFIC_PUBLIC_URL;
+    if (!publicUrl)
+      return reply.code(503).send({
+        error: "Configure the server\u2019s public HTTPS URL and restart the server before pairing a device."
+      });
+    let url;
+    try {
+      url = pairingOrigin(publicUrl);
+    } catch {
+      return reply.code(503).send({ error: "The server\u2019s public URL is invalid. Configure a public HTTPS origin." });
+    }
+    try {
+      const grant = security2.createPairing();
+      return {
+        payload: { v: 1, url, serverId: grant.serverId, pairingId: grant.pairingId },
+        pin: grant.pin,
+        expiresAt: grant.expiresAt
+      };
+    } catch {
+      return reply.code(429).send({ error: "Too many pending pairing codes. Wait five minutes and try again." });
+    }
+  });
+  app2.get("/api/auth/session", (request) => ({
+    serverId: security2.serverId,
+    device: security2.authenticate((request.headers.authorization ?? "").slice(7))
+  }));
+  app2.post("/api/auth/event-ticket", (request) => ({
+    ticket: security2.ticket((request.headers.authorization ?? "").slice(7), "/api/events")
+  }));
+  app2.post("/api/auth/asset-ticket", (request, reply) => {
+    const input = z6.object({
+      path: z6.string().regex(/^\/api\/projects\/[^/?]+\/attachments\/[^/?]+\/content(?:\?preview=1)?$/)
+    }).safeParse(request.body);
+    if (!input.success) return reply.code(400).send({ error: "Choose a valid attachment." });
+    return {
+      ticket: security2.ticket((request.headers.authorization ?? "").slice(7), input.data.path)
+    };
+  });
+}
+
 // src/maintenance.ts
 var MaintenanceError = class extends Error {
   statusCode = 503;
@@ -1018,9 +1359,9 @@ var Maintenance = class {
   }
   attach(app2) {
     app2.addHook("onRequest", async (request, reply) => {
-      const path8 = request.url.split("?")[0];
+      const path10 = request.url.split("?")[0];
       if (["GET", "HEAD", "OPTIONS"].includes(request.method)) return;
-      const allowed = path8.startsWith("/api/auth/") || /^\/api\/sessions\/[^/]+\/stop$/.test(path8);
+      const allowed = path10.startsWith("/api/auth/") || /^\/api\/sessions\/[^/]+\/stop$/.test(path10);
       if (this.paused && !allowed)
         return reply.code(503).send({ code: "MAINTENANCE", error: new MaintenanceError().message });
       this.requests.add(request.id);
@@ -1033,10 +1374,10 @@ var Maintenance = class {
 
 // src/updates.ts
 import semver from "semver";
-import { z as z5 } from "zod";
-import { Effect as Effect4 } from "effect";
-var RegistryRelease = z5.object({
-  version: z5.string().refine((value) => semver.valid(value) !== null)
+import { z as z7 } from "zod";
+import { Effect as Effect5 } from "effect";
+var RegistryRelease = z7.object({
+  version: z7.string().refine((value) => semver.valid(value) !== null)
 });
 async function checkForUpdates() {
   const response = await fetch("https://registry.npmjs.org/@agentrific%2Fserver/latest", {
@@ -1073,7 +1414,7 @@ var UpdateDiscovery = class {
       checkedAt: null,
       error: null
     };
-    const saved = Effect4.runSync(store2.serverUpdateStatus());
+    const saved = Effect5.runSync(store2.serverUpdateStatus());
     if (saved)
       this.state = {
         ...saved,
@@ -1110,7 +1451,7 @@ var UpdateDiscovery = class {
         error: "Could not check for server updates. Try again when the registry is reachable."
       };
     }
-    await Effect4.runPromise(this.store.saveServerUpdateStatus(this.state));
+    await Effect5.runPromise(this.store.saveServerUpdateStatus(this.state));
     return this.state;
   }
   start(canCheck, onError) {
@@ -1125,14 +1466,14 @@ var UpdateDiscovery = class {
 };
 
 // src/index.ts
-import { Effect as Effect14, ManagedRuntime } from "effect";
-import { z as z13 } from "zod";
+import { Effect as Effect16, ManagedRuntime } from "effect";
+import { z as z16 } from "zod";
 
 // src/automation.ts
-import { Effect as Effect6 } from "effect";
+import { Effect as Effect7 } from "effect";
 
 // src/tasks.ts
-import { Effect as Effect5, Semaphore } from "effect";
+import { Effect as Effect6, Semaphore } from "effect";
 var TaskActionError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -1147,15 +1488,20 @@ function withTaskLock(id, operation) {
     lock = Semaphore.makeUnsafe(1);
     locks.set(id, lock);
   }
-  return Effect5.runPromise(
+  return Effect6.runPromise(
     lock.withPermit(
-      Effect5.tryPromise({
+      Effect6.tryPromise({
         try: operation,
         catch: (cause) => cause
       })
     )
   );
 }
+async function sessionTaskLockId(store2, session) {
+  if (session.taskId) return session.taskId;
+  const tasks = await Effect6.runPromise(store2.listTasks(session.projectId, true));
+  return tasks.find((task) => task.sessionId === session.id)?.id ?? `session-${session.id}`;
+}
 function taskStatusForSession(status, session) {
   if (session?.gitDelivery?.status === "pending") return "running";
   if (status === "completed" && session?.gitFlow && !["merged", "no_changes", "pr_opened"].includes(session.gitDelivery?.status ?? ""))
@@ -1192,8 +1538,8 @@ function sessionTask(session) {
   });
 }
 async function boardTasks(store2, projectId) {
-  const tasks = await Effect5.runPromise(store2.listTasks(projectId, true));
-  const sessions = await Effect5.runPromise(store2.list());
+  const tasks = await Effect6.runPromise(store2.listTasks(projectId, true));
+  const sessions = await Effect6.runPromise(store2.list());
   const linkedSessionIds = new Set(
     tasks.flatMap((task) => task.sessionId ? [task.sessionId] : [])
   );
@@ -1212,10 +1558,10 @@ async function boardTasks(store2, projectId) {
   return [...linkedTasks, ...legacyTasks].map((task) => TaskSchema.parse(task)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
 async function findTask(store2, id) {
-  const saved = await Effect5.runPromise(store2.getTask(id));
+  const saved = await Effect6.runPromise(store2.getTask(id));
   if (saved?.deletedAt) throw new TaskActionError("Task not found.", 404);
   if (saved) return saved;
-  const session = id.startsWith("session-") ? await Effect5.runPromise(store2.get(id.slice("session-".length))) : void 0;
+  const session = id.startsWith("session-") ? await Effect6.runPromise(store2.get(id.slice("session-".length))) : void 0;
   if (!session || session.taskId) throw new TaskActionError("Task not found.", 404);
   return sessionTask(session);
 }
@@ -1231,7 +1577,7 @@ function editTask(store2, id, input, resolveAttachments) {
         throw new TaskActionError("Attachment validation is unavailable.", 400);
       files = await resolveAttachments(task.projectId, attachmentIds);
     }
-    return Effect5.runPromise(
+    return Effect6.runPromise(
       store2.saveTask({
         ...task,
         ...updates2,
@@ -1242,16 +1588,25 @@ function editTask(store2, id, input, resolveAttachments) {
     );
   });
 }
-function deleteTask(store2, id) {
+function deleteTask(store2, id, cleanup = async () => {
+}) {
   return withTaskLock(id, async () => {
     const task = await findTask(store2, id);
-    const sessions = await Effect5.runPromise(store2.list());
+    const sessions = await Effect6.runPromise(store2.list());
     if (sessions.some(
       (session) => (session.taskId === task.id || session.id === task.sessionId) && (["starting", "running", "queued"].includes(session.status) || session.gitDelivery?.status === "pending")
     ))
       throw new TaskActionError("Stop the task's running agent before deleting it.", 409);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await Effect5.runPromise(store2.saveTask({ ...task, deletedAt: now, updatedAt: now }));
+    const associated = sessions.filter(
+      (session) => session.taskId === task.id || session.id === task.sessionId
+    );
+    for (const session of associated) await cleanup(session);
+    await Effect6.runPromise(
+      store2.purgeTask(
+        task.id,
+        associated.map((session) => session.id)
+      )
+    );
   });
 }
 
@@ -1277,18 +1632,18 @@ var AutomationCoordinator = class {
   start;
   canStart;
   async snapshot() {
-    const state = await Effect6.runPromise(this.store.automation());
+    const state = await Effect7.runPromise(this.store.automation());
     return {
       ...state,
       queue: automationQueue(await boardTasks(this.store), state),
-      active: activeAgents(await Effect6.runPromise(this.store.list()))
+      active: activeAgents(await Effect7.runPromise(this.store.list()))
     };
   }
   // ponytail: one server process owns this SQLite database; use a durable lease before adding replicas.
   configure(config) {
     return withTaskLock("automation", async () => {
-      const state = await Effect6.runPromise(this.store.automation());
-      await Effect6.runPromise(this.store.saveAutomation({ ...state, config, error: null }));
+      const state = await Effect7.runPromise(this.store.automation());
+      await Effect7.runPromise(this.store.saveAutomation({ ...state, config, error: null }));
       return this.snapshot();
     });
   }
@@ -1300,7 +1655,7 @@ var AutomationCoordinator = class {
         throw new TaskActionError("Queue changed. Refresh and try again.", 409);
       const order = ids.filter((id) => id !== taskId);
       order.splice(beforeId === null ? order.length : order.indexOf(beforeId), 0, taskId);
-      await Effect6.runPromise(
+      await Effect7.runPromise(
         this.store.saveAutomation({
           config: snapshot.config,
           lastMinute: snapshot.lastMinute,
@@ -1313,22 +1668,22 @@ var AutomationCoordinator = class {
   }
   tick(now = /* @__PURE__ */ new Date()) {
     return withTaskLock("automation", async () => {
-      let state = await Effect6.runPromise(this.store.automation());
+      let state = await Effect7.runPromise(this.store.automation());
       const minute = now.toISOString().slice(0, 16);
       if (!this.canStart() || !state.config.enabled || state.lastMinute !== null && state.lastMinute >= minute || !cronMatches(state.config.cron, now))
         return;
       state = { ...state, lastMinute: minute, error: null };
-      await Effect6.runPromise(this.store.saveAutomation(state));
+      await Effect7.runPromise(this.store.saveAutomation(state));
       const queue = automationQueue(await boardTasks(this.store), state);
       for (const task of queue) {
         if (!this.canStart()) break;
-        if (activeAgents(await Effect6.runPromise(this.store.list())) >= state.config.parallelism)
+        if (activeAgents(await Effect7.runPromise(this.store.list())) >= state.config.parallelism)
           break;
         try {
           await this.start(task.id);
         } catch (error) {
           if (error instanceof MaintenanceError) break;
-          await Effect6.runPromise(
+          await Effect7.runPromise(
             this.store.saveAutomation({
               ...state,
               config: { ...state.config, enabled: false },
@@ -1343,8 +1698,8 @@ var AutomationCoordinator = class {
 };
 
 // src/runtime.ts
-import path3 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import path4 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/git-flow.ts
 function gitFlowPrompt(session, message) {
@@ -1356,7 +1711,7 @@ Work on the assigned run branch ${session.branch}. Before finishing, call delive
 }
 
 // src/runtime.ts
-import { Context as Context2, Data as Data2, Effect as Effect7, Fiber, Layer as Layer2, Semaphore as Semaphore2 } from "effect";
+import { Context as Context2, Data as Data2, Effect as Effect8, Fiber, Layer as Layer2, Semaphore as Semaphore2 } from "effect";
 var AgentError = class extends Data2.TaggedError("AgentError") {
 };
 var AgentController = class {
@@ -1396,20 +1751,20 @@ var AgentController = class {
     this.emit({ type: "session.updated", session: entry.session });
   }
   operation(action) {
-    return Effect7.tryPromise({
+    return Effect8.tryPromise({
       try: action,
       catch: (cause) => new AgentError({ message: String(cause), cause })
     });
   }
   open(session) {
-    return Effect7.gen({ self: this }, function* () {
+    return Effect8.gen({ self: this }, function* () {
       const existing = this.active.get(session.id);
       if (existing) return existing;
-      const agent = yield* Effect7.tryPromise({
+      const agent = yield* Effect8.tryPromise({
         try: () => this.factory.open(
           session.id,
-          session.workspacePath ?? path3.join(this.worktreesRoot, session.id),
-          path3.join(this.sessionsRoot, session.id),
+          session.workspacePath ?? path4.join(this.worktreesRoot, session.id),
+          path4.join(this.sessionsRoot, session.id),
           session.model,
           session
         ),
@@ -1432,14 +1787,14 @@ var AgentController = class {
     });
   }
   run(entry, message) {
-    return Effect7.gen({ self: this }, function* () {
+    return Effect8.gen({ self: this }, function* () {
       let next = message;
       while (next !== void 0) {
         const current = next;
         yield* this.operation(
           () => entry.agent.prompt(gitFlowPrompt(entry.session, current.text), current.attachments)
         );
-        next = yield* Effect7.sync(() => {
+        next = yield* Effect8.sync(() => {
           const queued = entry.stopping ? void 0 : entry.pending.shift();
           if (queued === void 0) {
             entry.running = false;
@@ -1451,19 +1806,19 @@ var AgentController = class {
           yield* this.operation(() => this.onSettled(entry.session));
       }
     }).pipe(
-      Effect7.catch(
-        (error) => Effect7.sync(() => {
+      Effect8.catch(
+        (error) => Effect8.sync(() => {
           entry.pending.length = 0;
           entry.running = false;
           this.emit({ type: "error", sessionId: entry.session.id, message: error.message });
           this.status(entry, entry.stopping ? "stopped" : "failed");
         })
       ),
-      Effect7.onInterrupt(
+      Effect8.onInterrupt(
         () => this.operation(() => entry.agent.abort()).pipe(
-          Effect7.orDie,
-          Effect7.ensuring(
-            Effect7.sync(() => {
+          Effect8.orDie,
+          Effect8.ensuring(
+            Effect8.sync(() => {
               entry.pending.length = 0;
               entry.running = false;
               this.status(entry, "stopped");
@@ -1471,16 +1826,16 @@ var AgentController = class {
           )
         )
       ),
-      Effect7.ensuring(Effect7.sync(() => this.working.delete(entry.session.id)))
+      Effect8.ensuring(Effect8.sync(() => this.working.delete(entry.session.id)))
     );
   }
-  send(session, message, attachments2 = [], messageId = randomUUID3()) {
+  send(session, message, attachments2 = [], messageId = randomUUID4()) {
     return this.lock(session.id).withPermit(
-      Effect7.gen({ self: this }, function* () {
+      Effect8.gen({ self: this }, function* () {
         if (this.closed)
-          return yield* Effect7.fail(new AgentError({ message: "Server is shutting down" }));
+          return yield* Effect8.fail(new AgentError({ message: "Server is shutting down" }));
         if (!session.branch && (session.gitFlow || !session.workspacePath))
-          return yield* Effect7.fail(new AgentError({ message: "Session checkout is not ready" }));
+          return yield* Effect8.fail(new AgentError({ message: "Session checkout is not ready" }));
         if (this.hasMessage(session.id, messageId)) return;
         const entry = yield* this.open(session);
         yield* this.operation(async () => entry.agent.validateAttachments?.(attachments2));
@@ -1499,7 +1854,7 @@ var AgentController = class {
         entry.stopping = false;
         this.status(entry, "running");
         this.working.add(session.id);
-        entry.fiber = yield* Effect7.forkIn(
+        entry.fiber = yield* Effect8.forkIn(
           this.run(entry, { text: message, attachments: attachments2 }),
           this.scope,
           {
@@ -1507,22 +1862,22 @@ var AgentController = class {
           }
         );
       })
-    ).pipe(Effect7.uninterruptible);
+    ).pipe(Effect8.uninterruptible);
   }
   setModel(session, model) {
     return this.lock(session.id).withPermit(
-      Effect7.gen({ self: this }, function* () {
+      Effect8.gen({ self: this }, function* () {
         if (this.closed)
-          return yield* Effect7.fail(new AgentError({ message: "Server is shutting down" }));
+          return yield* Effect8.fail(new AgentError({ message: "Server is shutting down" }));
         const entry = yield* this.open(session);
         if (entry.running || entry.pending.length)
-          return yield* Effect7.fail(
+          return yield* Effect8.fail(
             new AgentError({
               message: "Wait for this reply to finish before changing the model."
             })
           );
         if (!entry.agent.setModel)
-          return yield* Effect7.fail(
+          return yield* Effect8.fail(
             new AgentError({ message: "This agent does not support model selection." })
           );
         yield* this.operation(() => entry.agent.setModel(model));
@@ -1534,10 +1889,10 @@ var AgentController = class {
         this.emit({ type: "session.updated", session: entry.session });
         return entry.session;
       })
-    ).pipe(Effect7.uninterruptible);
+    ).pipe(Effect8.uninterruptible);
   }
   stopEntry(entry) {
-    return Effect7.gen({ self: this }, function* () {
+    return Effect8.gen({ self: this }, function* () {
       entry.stopping = true;
       entry.pending.length = 0;
       yield* this.operation(() => entry.agent.abort());
@@ -1547,7 +1902,7 @@ var AgentController = class {
   }
   stop(session) {
     return this.lock(session.id).withPermit(
-      Effect7.gen({ self: this }, function* () {
+      Effect8.gen({ self: this }, function* () {
         const entry = this.active.get(session.id);
         if (entry) {
           yield* this.stopEntry(entry);
@@ -1558,14 +1913,26 @@ var AgentController = class {
           });
         }
       })
-    ).pipe(Effect7.uninterruptible);
+    ).pipe(Effect8.uninterruptible);
+  }
+  forget(id) {
+    return this.lock(id).withPermit(
+      Effect8.sync(() => {
+        const entry = this.active.get(id);
+        if (!entry) return;
+        if (entry.running) throw new Error("Cannot delete an active run.");
+        entry.unsubscribe();
+        entry.agent.dispose();
+        this.active.delete(id);
+      })
+    );
   }
   close() {
-    return Effect7.gen({ self: this }, function* () {
+    return Effect8.gen({ self: this }, function* () {
       this.closed = true;
       for (const [id, lock] of this.locks) {
         yield* lock.withPermit(
-          Effect7.gen({ self: this }, function* () {
+          Effect8.gen({ self: this }, function* () {
             const entry = this.active.get(id);
             if (!entry) return;
             if (entry.running) yield* this.stopEntry(entry);
@@ -1585,8 +1952,8 @@ var AgentSessions = class extends Context2.Service()(
   }) {
     return Layer2.effect(
       this,
-      Effect7.gen(function* () {
-        const scope = yield* Effect7.scope;
+      Effect8.gen(function* () {
+        const scope = yield* Effect8.scope;
         const controller = new AgentController(
           factory,
           emit,
@@ -1596,7 +1963,7 @@ var AgentSessions = class extends Context2.Service()(
           hasMessage,
           onSettled
         );
-        yield* Effect7.addFinalizer(() => controller.close().pipe(Effect7.orDie));
+        yield* Effect8.addFinalizer(() => controller.close().pipe(Effect8.orDie));
         return controller;
       })
     );
@@ -1604,8 +1971,8 @@ var AgentSessions = class extends Context2.Service()(
 };
 
 // src/delivery.ts
-import { Effect as Effect8 } from "effect";
-import { z as z7 } from "zod";
+import { Effect as Effect9 } from "effect";
+import { z as z9 } from "zod";
 
 // src/workflow-command.ts
 import { execFile } from "node:child_process";
@@ -1649,12 +2016,12 @@ function workflowError(error) {
 }
 
 // src/workflow-schema.ts
-import { z as z6 } from "zod";
-var DeliveryJobSchema = z6.object({
-  kind: z6.literal("delivery"),
-  sessionId: z6.string(),
+import { z as z8 } from "zod";
+var DeliveryJobSchema = z8.object({
+  kind: z8.literal("delivery"),
+  sessionId: z8.string(),
   request: DeliveryRequestSchema,
-  phase: z6.enum([
+  phase: z8.enum([
     "validating",
     "drafting",
     "committing",
@@ -1664,25 +2031,25 @@ var DeliveryJobSchema = z6.object({
     "opening_pr",
     "delivered"
   ]),
-  attempt: z6.number().int().positive(),
-  commitSha: z6.string().optional(),
-  title: z6.string(),
-  body: z6.string(),
-  logs: z6.string().default(""),
-  failed: z6.boolean().default(false),
-  result: z6.enum(["merged", "pr_opened", "no_changes"]).optional(),
-  url: z6.string().optional(),
-  message: z6.string().optional()
+  attempt: z8.number().int().positive(),
+  commitSha: z8.string().optional(),
+  title: z8.string(),
+  body: z8.string(),
+  logs: z8.string().default(""),
+  failed: z8.boolean().default(false),
+  result: z8.enum(["merged", "pr_opened", "no_changes"]).optional(),
+  url: z8.string().optional(),
+  message: z8.string().optional()
 });
-var PreparationJobSchema = z6.object({
-  kind: z6.literal("preparation"),
-  sessionId: z6.string(),
-  projectPath: z6.string(),
+var PreparationJobSchema = z8.object({
+  kind: z8.literal("preparation"),
+  sessionId: z8.string(),
+  projectPath: z8.string(),
   input: CreateSessionSchema,
-  stage: z6.enum(["creating", "installing", "ready", "failed"]),
-  logs: z6.string().default("")
+  stage: z8.enum(["creating", "installing", "ready", "failed"]),
+  logs: z8.string().default("")
 });
-var WorkflowJobSchema = z6.discriminatedUnion("kind", [
+var WorkflowJobSchema = z8.discriminatedUnion("kind", [
   DeliveryJobSchema,
   PreparationJobSchema
 ]);
@@ -1702,20 +2069,20 @@ var DeliveryCoordinator = class {
     return [...this.workers.keys()].map((id) => `delivery:${id}`);
   }
   async session(id) {
-    const session = await Effect8.runPromise(this.store.get(id));
+    const session = await Effect9.runPromise(this.store.get(id));
     if (!session?.gitFlow || !session.branch || !session.workspacePath)
       throw new Error("This run does not have a ready Git flow workspace.");
     return session;
   }
   async job(id) {
-    const raw = await Effect8.runPromise(this.store.workflow(`delivery:${id}`));
+    const raw = await Effect9.runPromise(this.store.workflow(`delivery:${id}`));
     return raw === void 0 ? void 0 : DeliveryJobSchema.parse(raw);
   }
   git(session, args, signal) {
     return this.command(session.workspacePath, "git", args, signal);
   }
   async record(job) {
-    await Effect8.runPromise(this.store.saveWorkflow(`delivery:${job.sessionId}`, job));
+    await Effect9.runPromise(this.store.saveWorkflow(`delivery:${job.sessionId}`, job));
     const session = await this.session(job.sessionId);
     const delivery2 = {
       status: job.failed ? "failed" : job.result ?? "pending",
@@ -1904,7 +2271,7 @@ Agentrific run ${id}.`;
     return (await this.session(id)).gitDelivery;
   }
   async recover() {
-    const jobs = await Effect8.runPromise(this.store.workflows());
+    const jobs = await Effect9.runPromise(this.store.workflows());
     for (const raw of jobs) {
       const parsed = DeliveryJobSchema.safeParse(raw);
       if (!parsed.success) continue;
@@ -1978,11 +2345,11 @@ ${workflowError(error instanceof Error ? error : String(error))}`
             "--json",
             "url,state,headRefOid"
           ]);
-          const prs = z7.array(
-            z7.object({
-              url: z7.string().url(),
-              state: z7.string(),
-              headRefOid: z7.string().optional()
+          const prs = z9.array(
+            z9.object({
+              url: z9.string().url(),
+              state: z9.string(),
+              headRefOid: z9.string().optional()
             })
           ).parse(JSON.parse(existing));
           const open = prs.find(
@@ -2024,9 +2391,9 @@ ${workflowError(error instanceof Error ? error : String(error))}`
 
 // src/preparation.ts
 import { mkdir as mkdir3, readFile as readFile3 } from "node:fs/promises";
-import path4 from "node:path";
-import { Effect as Effect9 } from "effect";
-import { z as z8 } from "zod";
+import path5 from "node:path";
+import { Effect as Effect10 } from "effect";
+import { z as z10 } from "zod";
 var PreparationCoordinator = class {
   constructor(store2, options) {
     this.store = store2;
@@ -2056,8 +2423,8 @@ var PreparationCoordinator = class {
         job.logs = workflowLog(`${job.logs}
 ${message}${logs ? `
 ${logs}` : ""}`);
-        await Effect9.runPromise(this.store.saveWorkflow(`preparation:${session.id}`, job));
-        const current = await Effect9.runPromise(this.store.get(session.id));
+        await Effect10.runPromise(this.store.saveWorkflow(`preparation:${session.id}`, job));
+        const current = await Effect10.runPromise(this.store.get(session.id));
         this.options.publish({
           type: "session.updated",
           session: {
@@ -2076,7 +2443,7 @@ ${logs}` : ""}`);
         await record("installing", "Installing run dependencies\u2026");
         await this.install(workspace, command);
         await record("ready", "Workspace ready.");
-        return await Effect9.runPromise(this.store.get(session.id));
+        return await Effect10.runPromise(this.store.get(session.id));
       } catch (error) {
         const step = job.stage === "installing" ? "Dependency installation failed" : "Workspace preparation failed";
         await record(
@@ -2120,7 +2487,7 @@ ${logs}` : ""}`);
     const workspace = session.workspacePath;
     if (branchAtWorkspace !== void 0)
       throw new Error("The run workspace already exists on a different branch.");
-    await mkdir3(path4.dirname(workspace), { recursive: true });
+    await mkdir3(path5.dirname(workspace), { recursive: true });
     try {
       await command(
         projectPath,
@@ -2140,12 +2507,12 @@ ${logs}` : ""}`);
     }
   }
   async install(workspace, command) {
-    const packageFile = await readFile3(path4.join(workspace, "package.json"), "utf8").catch(
+    const packageFile = await readFile3(path5.join(workspace, "package.json"), "utf8").catch(
       () => void 0
     );
     if (!packageFile) return;
-    const metadata = z8.object({ packageManager: z8.string().optional() }).parse(JSON.parse(packageFile));
-    const has = async (name) => readFile3(path4.join(workspace, name)).then(
+    const metadata = z10.object({ packageManager: z10.string().optional() }).parse(JSON.parse(packageFile));
+    const has = async (name) => readFile3(path5.join(workspace, name)).then(
       () => true,
       () => false
     );
@@ -2158,10 +2525,10 @@ ${logs}` : ""}`);
     else if (await has("package-lock.json")) await command(workspace, "npm", ["ci"]);
   }
   async retry(id) {
-    const raw = await Effect9.runPromise(this.store.workflow(`preparation:${id}`));
+    const raw = await Effect10.runPromise(this.store.workflow(`preparation:${id}`));
     const job = PreparationJobSchema.parse(raw);
     return withTaskLock(`repository:${job.projectPath}`, async () => {
-      const session = await Effect9.runPromise(this.store.get(id));
+      const session = await Effect10.runPromise(this.store.get(id));
       if (!session || session.preparation?.status !== "failed")
         throw new Error("This run does not need preparation retried.");
       const prepared = await this.prepare(session, job.projectPath, job.input);
@@ -2169,11 +2536,11 @@ ${logs}` : ""}`);
     });
   }
   async recover() {
-    for (const raw of await Effect9.runPromise(this.store.workflows())) {
+    for (const raw of await Effect10.runPromise(this.store.workflows())) {
       const parsed = PreparationJobSchema.safeParse(raw);
       if (!parsed.success) continue;
       const job = parsed.data;
-      const session = await Effect9.runPromise(this.store.get(job.sessionId));
+      const session = await Effect10.runPromise(this.store.get(job.sessionId));
       if (!session) continue;
       if (job.stage === "failed") {
         if (session.preparation?.status === "failed") continue;
@@ -2204,7 +2571,7 @@ ${logs}` : ""}`);
         });
         continue;
       }
-      await Effect9.runPromise(
+      await Effect10.runPromise(
         this.store.saveWorkflow(`preparation:${session.id}`, { ...job, stage: "failed" })
       );
       this.options.publish({
@@ -2226,8 +2593,8 @@ ${logs}` : ""}`);
 
 // src/delivery-writer.ts
 import { createAgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
-import { z as z9 } from "zod";
-var DraftSchema = z9.object({ title: z9.string().trim().min(1).max(120), body: z9.string().trim().min(1).max(1e4) }).strict();
+import { z as z11 } from "zod";
+var DraftSchema = z11.object({ title: z11.string().trim().min(1).max(120), body: z11.string().trim().min(1).max(1e4) }).strict();
 function deliveryWriter(models2, createSession = createAgentSession) {
   return async (run, input, diff, signal) => {
     signal?.throwIfAborted();
@@ -2269,7 +2636,7 @@ ${diff}`
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 
 // src/models.ts
-import { Effect as Effect10 } from "effect";
+import { Effect as Effect11 } from "effect";
 var legacyModel = { platformId: "openai-codex", modelId: "gpt-6-luna" };
 var makers = [
   { id: "openai", name: "OpenAI", pattern: /(?:^|[/.:\s-])(?:gpt-|o[134](?:-|$))/i },
@@ -2334,7 +2701,7 @@ var ServerModels = class {
     await this.refreshing;
   }
   async defaultReference() {
-    return await Effect10.runPromise(this.store.defaultModel()) ?? legacyModel;
+    return await Effect11.runPromise(this.store.defaultModel()) ?? legacyModel;
   }
   async defaultIdentity() {
     const selected = await this.defaultReference();
@@ -2370,19 +2737,19 @@ var ServerModels = class {
   }
   async setDefault(reference) {
     await this.resolve(reference);
-    await Effect10.runPromise(this.store.setDefaultModel(reference));
+    await Effect11.runPromise(this.store.setDefaultModel(reference));
     return this.identity(reference.platformId, reference.modelId);
   }
 };
 
 // src/pi.ts
-import { Effect as Effect11 } from "effect";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { Effect as Effect12 } from "effect";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import {
   createAgentSession as createAgentSession2,
   SessionManager as SessionManager2
 } from "@earendil-works/pi-coding-agent";
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 
 // src/delivery-tool.ts
 import { defineTool } from "@earendil-works/pi-coding-agent";
@@ -2417,8 +2784,8 @@ function deliveryTool(sessionId, delivery2) {
 }
 
 // src/pi.ts
-var ToolResultSchema = z10.object({
-  content: z10.array(z10.object({ type: z10.string(), text: z10.string().optional() })).optional()
+var ToolResultSchema = z12.object({
+  content: z12.array(z12.object({ type: z12.string(), text: z12.string().optional() })).optional()
 }).passthrough();
 var boundedJson = (value, limit) => {
   let text;
@@ -2460,7 +2827,7 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
             );
         },
         async prompt(message, attachments2 = []) {
-          const context = await Effect11.runPromise(files.prepare(attachments2));
+          const context = await Effect12.runPromise(files.prepare(attachments2));
           await session.prompt(message + context.context, { images: context.images });
           const last = session.messages.at(-1);
           if (last?.role === "assistant" && last.stopReason === "error") {
@@ -2497,7 +2864,7 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
           function handleMessage(event) {
             if (event.type === "message_start" && event.message.role === "assistant") {
               flushText();
-              assistantMessageId = randomUUID4();
+              assistantMessageId = randomUUID5();
               emit({
                 type: "message.started",
                 sessionId,
@@ -2508,7 +2875,7 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
               return true;
             }
             if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-              if (!assistantMessageId) assistantMessageId = randomUUID4();
+              if (!assistantMessageId) assistantMessageId = randomUUID5();
               pendingText += event.assistantMessageEvent.delta;
               setActivity("responding");
               if (!flushTimer) flushTimer = setTimeout(flushText, 50);
@@ -2583,18 +2950,18 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
 
 // src/projects.ts
 import { access, readdir as readdir2, realpath, stat as stat2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { z as z11 } from "zod";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { z as z13 } from "zod";
 import { constants } from "node:fs";
 import { homedir } from "node:os";
-import path5 from "node:path";
-import { Effect as Effect12, Semaphore as Semaphore3 } from "effect";
+import path6 from "node:path";
+import { Effect as Effect13, Semaphore as Semaphore3 } from "effect";
 function resolveProjectsRoot(input) {
-  return Effect12.tryPromise({
+  return Effect13.tryPromise({
     try: async () => {
       const trimmed = input.trim();
-      const expanded = trimmed === "~" ? homedir() : trimmed.startsWith("~/") ? path5.join(homedir(), trimmed.slice(2)) : trimmed;
-      if (!path5.isAbsolute(expanded))
+      const expanded = trimmed === "~" ? homedir() : trimmed.startsWith("~/") ? path6.join(homedir(), trimmed.slice(2)) : trimmed;
+      if (!path6.isAbsolute(expanded))
         throw new Error("Use an absolute server path or a path beginning with ~/.");
       const resolved = await realpath(expanded);
       if (!(await stat2(resolved)).isDirectory())
@@ -2616,63 +2983,63 @@ function projectLock(store2) {
   }
   return lock;
 }
-var ProjectId = z11.string().trim().min(1).max(255);
+var ProjectId = z13.string().trim().min(1).max(255);
 async function gitDirectory(directory) {
-  const location = path5.join(directory, ".git");
+  const location = path6.join(directory, ".git");
   const info = await stat2(location);
   if (info.isDirectory()) return location;
   const contents = await readFile4(location, "utf8");
   const match = /^gitdir: (.+)\s*$/m.exec(contents);
   if (!match) throw new Error("Invalid Git worktree metadata.");
-  const resolved = await realpath(path5.resolve(directory, match[1].trim()));
+  const resolved = await realpath(path6.resolve(directory, match[1].trim()));
   if (!(await stat2(resolved)).isDirectory()) throw new Error("Git directory is missing.");
   return resolved;
 }
 async function identity(directory, preferred) {
-  const filename = path5.join(await gitDirectory(directory), "agentrific-project-id");
+  const filename = path6.join(await gitDirectory(directory), "agentrific-project-id");
   try {
     return ProjectId.parse(await readFile4(filename, "utf8"));
   } catch (error) {
-    if (!z11.object({ code: z11.literal("ENOENT") }).safeParse(error).success) throw error;
-    const legacyFilename = path5.join(await gitDirectory(directory), "chatplans-project-id");
+    if (!z13.object({ code: z13.literal("ENOENT") }).safeParse(error).success) throw error;
+    const legacyFilename = path6.join(await gitDirectory(directory), "chatplans-project-id");
     const legacy = await readFile4(legacyFilename, "utf8").catch((cause) => {
-      if (!z11.object({ code: z11.literal("ENOENT") }).safeParse(cause).success) throw cause;
+      if (!z13.object({ code: z13.literal("ENOENT") }).safeParse(cause).success) throw cause;
       return null;
     });
-    const id = legacy === null ? preferred ?? randomUUID5() : ProjectId.parse(legacy);
+    const id = legacy === null ? preferred ?? randomUUID6() : ProjectId.parse(legacy);
     try {
       await writeFile2(filename, id + "\n", { flag: "wx" });
       return id;
     } catch (writeError) {
-      if (!z11.object({ code: z11.literal("EEXIST") }).safeParse(writeError).success) throw writeError;
+      if (!z13.object({ code: z13.literal("EEXIST") }).safeParse(writeError).success) throw writeError;
       return ProjectId.parse(await readFile4(filename, "utf8"));
     }
   }
 }
 function scanProjects(root, store2) {
-  return Effect12.tryPromise({
+  return Effect13.tryPromise({
     try: async () => {
       root = await realpath(root);
-      const registered = await Effect12.runPromise(store2.registeredProjects(root));
+      const registered = await Effect13.runPromise(store2.registeredProjects(root));
       const found = [];
       const entries = await readdir2(root, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const directory = path5.join(root, entry.name);
-        if (!await stat2(path5.join(directory, ".git")).catch(() => null)) continue;
+        const directory = path6.join(root, entry.name);
+        if (!await stat2(path6.join(directory, ".git")).catch(() => null)) continue;
         const previous = registered.find((project2) => project2.path === directory);
         let id = await identity(directory, previous?.available ? void 0 : previous?.id);
         let existing = registered.find((project2) => project2.id === id);
-        if (found.some((project2) => project2.id === id) || existing && existing.path !== directory && await stat2(path5.join(existing.path, ".git")).catch(() => null)) {
-          id = randomUUID5();
+        if (found.some((project2) => project2.id === id) || existing && existing.path !== directory && await stat2(path6.join(existing.path, ".git")).catch(() => null)) {
+          id = randomUUID6();
           await writeFile2(
-            path5.join(await gitDirectory(directory), "agentrific-project-id"),
+            path6.join(await gitDirectory(directory), "agentrific-project-id"),
             id + "\n"
           );
           existing = void 0;
         }
         const project = { id, name: entry.name, path: directory, available: true };
-        await Effect12.runPromise(store2.relocateProject(project, existing?.path));
+        await Effect13.runPromise(store2.relocateProject(project, existing?.path));
         found.push(project);
       }
       return [
@@ -2687,26 +3054,26 @@ function discoverProjects(root, store2) {
   return projectLock(store2).withPermit(scanProjects(root, store2));
 }
 function reconnectProject(root, id, input, store2) {
-  return Effect12.tryPromise({
+  return Effect13.tryPromise({
     try: async () => {
-      const projects = await Effect12.runPromise(scanProjects(root, store2));
+      const projects = await Effect13.runPromise(scanProjects(root, store2));
       const previous = projects.find((project2) => project2.id === id);
       if (!previous || previous.available)
         throw new Error("Only a missing project can be reconnected.");
-      const sessions = await Effect12.runPromise(store2.list());
+      const sessions = await Effect13.runPromise(store2.list());
       if (sessions.some(
         (session) => session.projectId === id && ["starting", "running", "queued"].includes(session.status)
       ))
         throw new Error("Stop this project's running sessions before reconnecting its folder.");
-      const directory = await Effect12.runPromise(resolveProjectsRoot(input));
-      if (path5.dirname(directory) !== await realpath(root))
+      const directory = await Effect13.runPromise(resolveProjectsRoot(input));
+      if (path6.dirname(directory) !== await realpath(root))
         throw new Error("Choose a Git repository directly inside the configured projects folder.");
-      const filename = path5.join(await gitDirectory(directory), "agentrific-project-id");
+      const filename = path6.join(await gitDirectory(directory), "agentrific-project-id");
       const replacedId = await identity(directory);
-      const project = { id, name: path5.basename(directory), path: directory, available: true };
+      const project = { id, name: path6.basename(directory), path: directory, available: true };
       await writeFile2(filename, id + "\n");
       try {
-        await Effect12.runPromise(store2.relocateProject(project, previous.path, replacedId));
+        await Effect13.runPromise(store2.relocateProject(project, previous.path, replacedId));
       } catch (error) {
         await writeFile2(filename, replacedId + "\n");
         throw error;
@@ -2718,21 +3085,67 @@ function reconnectProject(root, id, input, store2) {
 }
 
 // src/store.ts
-import { mkdirSync } from "node:fs";
-import path6 from "node:path";
+import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import path7 from "node:path";
+
+// src/push-schema.ts
+import { z as z14 } from "zod";
+var PushBindingSchema = z14.object({
+  bindingId: z14.string().uuid(),
+  installationId: z14.string().uuid(),
+  deviceId: z14.string().uuid()
+});
+var PushStateSchema = z14.object({
+  bindings: z14.array(PushBindingSchema).max(10),
+  error: z14.string().nullable()
+});
+var PendingPushSchema = PushEventSchema.extend({
+  remaining: z14.array(PushBindingSchema),
+  createdAt: z14.number(),
+  attempts: z14.number().int().nonnegative(),
+  nextAt: z14.number()
+});
+
+// src/store.ts
 import { DatabaseSync } from "node:sqlite";
-import { Context as Context3, Data as Data3, Effect as Effect13, Layer as Layer3 } from "effect";
-import { z as z12 } from "zod";
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { Context as Context3, Data as Data3, Effect as Effect14, Layer as Layer3 } from "effect";
+import { z as z15 } from "zod";
+import { randomUUID as randomUUID7 } from "node:crypto";
 var StorageError = class extends Data3.TaggedError("StorageError") {
 };
-var PayloadRow = z12.object({ payload: z12.string() });
-var EventRow = z12.object({ sequence: z12.number(), recorded_at: z12.string(), payload: z12.string() });
+var PayloadRow = z15.object({ payload: z15.string() });
+var EventRow = z15.object({ sequence: z15.number(), recorded_at: z15.string(), payload: z15.string() });
 var SqliteSessionStore = class {
   constructor(db) {
     this.db = db;
   }
   db;
+  pushState() {
+    return this.query(() => {
+      const row = this.db.prepare("SELECT payload FROM settings WHERE id = 'push-state'").get();
+      return row ? PushStateSchema.parse(JSON.parse(PayloadRow.parse(row).payload)) : { bindings: [], error: null };
+    });
+  }
+  savePushState(state) {
+    return this.query(
+      () => this.db.prepare(
+        "INSERT INTO settings(id, payload) VALUES ('push-state', ?) ON CONFLICT(id) DO UPDATE SET payload = excluded.payload"
+      ).run(JSON.stringify(PushStateSchema.parse(state)))
+    );
+  }
+  pendingPush() {
+    return this.query(
+      () => this.db.prepare("SELECT payload FROM push_outbox ORDER BY rowid LIMIT 100").all().map((row) => PendingPushSchema.parse(JSON.parse(PayloadRow.parse(row).payload)))
+    );
+  }
+  savePendingPush(job) {
+    return this.query(
+      () => this.db.prepare("UPDATE push_outbox SET payload = ? WHERE id = ?").run(JSON.stringify(PendingPushSchema.parse(job)), job.eventId)
+    );
+  }
+  removePush(eventId) {
+    return this.query(() => this.db.prepare("DELETE FROM push_outbox WHERE id = ?").run(eventId));
+  }
   serverUpdateStatus() {
     return this.query(() => {
       const row = this.db.prepare("SELECT payload FROM settings WHERE id = 'server-update-status'").get();
@@ -2748,11 +3161,11 @@ var SqliteSessionStore = class {
   }
   serverIdentity() {
     return this.query(() => {
-      this.db.prepare("INSERT OR IGNORE INTO settings(id, payload) VALUES ('server-id', ?)").run(JSON.stringify(randomUUID6()));
+      this.db.prepare("INSERT OR IGNORE INTO settings(id, payload) VALUES ('server-id', ?)").run(JSON.stringify(randomUUID7()));
       const row = PayloadRow.parse(
         this.db.prepare("SELECT payload FROM settings WHERE id = 'server-id'").get()
       );
-      return z12.string().uuid().parse(JSON.parse(row.payload));
+      return z15.string().uuid().parse(JSON.parse(row.payload));
     });
   }
   saveDevice(device, tokenHash) {
@@ -2789,7 +3202,7 @@ var SqliteSessionStore = class {
     });
   }
   query(operation) {
-    return Effect13.try({
+    return Effect14.try({
       try: operation,
       catch: (cause) => new StorageError({
         message: cause instanceof Error ? cause.message : "Session storage operation failed",
@@ -2840,10 +3253,10 @@ var SqliteSessionStore = class {
       `).all();
       const insert = this.db.prepare("INSERT OR IGNORE INTO projects(id, payload) VALUES (?, ?)");
       for (const row of legacy) {
-        const id = z12.object({ id: z12.string() }).parse(row).id;
+        const id = z15.object({ id: z15.string() }).parse(row).id;
         insert.run(
           id,
-          JSON.stringify({ id, name: id, path: path6.join(root, id), available: false })
+          JSON.stringify({ id, name: id, path: path7.join(root, id), available: false })
         );
       }
       return this.db.prepare("SELECT payload FROM projects").all().map((row) => ProjectSchema.parse(JSON.parse(PayloadRow.parse(row).payload)));
@@ -2880,7 +3293,7 @@ var SqliteSessionStore = class {
     this.db.prepare(
       "UPDATE workflows SET payload = json_set(payload, '$.projectPath', ?) WHERE json_extract(payload, '$.kind') = 'preparation' AND json_extract(payload, '$.projectPath') = ?"
     ).run(project.path, previousPath);
-    const relocate = (workspace) => workspace === previousPath || workspace.startsWith(`${previousPath}${path6.sep}`) ? project.path + workspace.slice(previousPath.length) : workspace;
+    const relocate = (workspace) => workspace === previousPath || workspace.startsWith(`${previousPath}${path7.sep}`) ? project.path + workspace.slice(previousPath.length) : workspace;
     for (const row of this.db.prepare("SELECT id, payload FROM sessions WHERE json_extract(payload, '$.projectId') = ?").all(project.id)) {
       const session = SessionSchema.parse(JSON.parse(PayloadRow.parse(row).payload));
       if (session.workspacePath) {
@@ -2955,6 +3368,31 @@ var SqliteSessionStore = class {
       return row ? TaskSchema.parse(JSON.parse(PayloadRow.parse(row).payload)) : void 0;
     });
   }
+  purgeTask(id, sessionIds) {
+    return this.query(() => {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        for (const sessionId of sessionIds) {
+          this.db.prepare("DELETE FROM events WHERE session_id = ?").run(sessionId);
+          this.db.prepare("DELETE FROM push_outbox WHERE json_extract(payload, '$.sessionId') = ?").run(sessionId);
+          this.db.prepare("DELETE FROM workflows WHERE json_extract(payload, '$.sessionId') = ?").run(sessionId);
+          this.db.prepare("DELETE FROM sessions WHERE id = ?").run(sessionId);
+        }
+        this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+        this.db.exec(`UPDATE attachments SET claimed = 0 WHERE NOT EXISTS (
+          SELECT 1 FROM tasks, json_each(tasks.payload, '$.attachments') AS file
+          WHERE json_extract(file.value, '$.id') = attachments.id
+        ) AND NOT EXISTS (
+          SELECT 1 FROM events, json_each(events.payload, '$.attachments') AS file
+          WHERE json_extract(file.value, '$.id') = attachments.id
+        )`);
+        this.db.exec("COMMIT");
+      } catch (error) {
+        this.db.exec("ROLLBACK");
+        throw error;
+      }
+    });
+  }
   saveAttachment(attachment) {
     return this.query(() => {
       this.db.prepare("INSERT INTO attachments(id, payload) VALUES (?, ?)").run(attachment.id, JSON.stringify(AttachmentSchema.parse(attachment)));
@@ -3011,7 +3449,7 @@ var SqliteSessionStore = class {
       }
     });
   }
-  append(event) {
+  append(event, notification) {
     return this.query(() => {
       const sessionId = event.type === "session.updated" ? event.session.id : event.sessionId;
       const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -3024,6 +3462,14 @@ var SqliteSessionStore = class {
         }
         if (event.type === "message.user") this.claimAttachments(event.attachments ?? []);
         const result = this.db.prepare("INSERT INTO events(session_id, recorded_at, payload) VALUES (?, ?, ?)").run(sessionId, recordedAt, JSON.stringify(event));
+        if (notification) {
+          const count = z15.object({ total: z15.number() }).parse(this.db.prepare("SELECT COUNT(*) AS total FROM push_outbox").get());
+          if (count.total >= 1e3)
+            this.db.prepare(
+              "DELETE FROM push_outbox WHERE rowid IN (SELECT rowid FROM push_outbox ORDER BY rowid LIMIT 1)"
+            ).run();
+          this.db.prepare("INSERT INTO push_outbox(id, payload) VALUES (?, ?)").run(notification.eventId, JSON.stringify(PendingPushSchema.parse(notification)));
+        }
         const record = RecordedEventSchema.parse({
           sequence: Number(result.lastInsertRowid),
           recordedAt,
@@ -3060,13 +3506,16 @@ var SessionStore = class extends Context3.Service()(
   static layer(filename) {
     return Layer3.effect(
       this,
-      Effect13.acquireRelease(
-        Effect13.try({
+      Effect14.acquireRelease(
+        Effect14.try({
           try: () => {
-            mkdirSync(path6.dirname(filename), { recursive: true });
+            mkdirSync2(path7.dirname(filename), { recursive: true });
             const db = new DatabaseSync(filename);
+            chmodSync(filename, 384);
+            for (const suffix of ["-wal", "-shm"])
+              if (existsSync2(filename + suffix)) chmodSync(filename + suffix, 384);
             try {
-              const schema = z12.object({ user_version: z12.number() }).parse(db.prepare("PRAGMA user_version").get());
+              const schema = z15.object({ user_version: z15.number() }).parse(db.prepare("PRAGMA user_version").get());
               if (schema.user_version > 1)
                 throw new Error("This database requires a newer Agentrific server.");
               db.exec(`
@@ -3077,6 +3526,7 @@ var SessionStore = class extends Context3.Service()(
               CREATE TABLE IF NOT EXISTS settings(id TEXT PRIMARY KEY, payload TEXT NOT NULL);
               CREATE TABLE IF NOT EXISTS sessions(id TEXT PRIMARY KEY, payload TEXT NOT NULL);
               CREATE TABLE IF NOT EXISTS tasks(id TEXT PRIMARY KEY, payload TEXT NOT NULL);
+              CREATE TABLE IF NOT EXISTS push_outbox(id TEXT PRIMARY KEY, payload TEXT NOT NULL);
               CREATE TABLE IF NOT EXISTS workflows(id TEXT PRIMARY KEY, payload TEXT NOT NULL);
               CREATE TABLE IF NOT EXISTS attachments(id TEXT PRIMARY KEY, payload TEXT NOT NULL, claimed INTEGER NOT NULL DEFAULT 0);
               CREATE TABLE IF NOT EXISTS events(sequence INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL REFERENCES sessions(id), recorded_at TEXT NOT NULL, payload TEXT NOT NULL);
@@ -3092,18 +3542,81 @@ var SessionStore = class extends Context3.Service()(
           },
           catch: (cause) => new StorageError({ message: "Could not open session database", cause })
         }),
-        (db) => Effect13.sync(() => db.close())
-      ).pipe(Effect13.map((db) => new SqliteSessionStore(db)))
+        (db) => Effect14.sync(() => db.close())
+      ).pipe(Effect14.map((db) => new SqliteSessionStore(db)))
     );
   }
 };
 
+// src/worktree-cleanup.ts
+import { lstat, rm as rm2 } from "node:fs/promises";
+import path8 from "node:path";
+import { Effect as Effect15 } from "effect";
+var WorktreeCleanup = class {
+  constructor(store2, root, projectsRoot) {
+    this.store = store2;
+    this.root = root;
+    this.projectsRoot = projectsRoot;
+  }
+  store;
+  root;
+  projectsRoot;
+  async remove(session, discardChanges = true) {
+    if (session.gitFlow?.workspace !== "worktree" || !session.workspacePath) return;
+    const workspace = path8.resolve(session.workspacePath);
+    const info = await lstat(workspace).catch((error) => {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    });
+    if (workspace !== path8.join(this.root, session.id) || path8.basename(session.id) !== session.id) {
+      if (!info) return;
+      throw new Error("Refusing to remove a worktree outside the managed workspaces directory.");
+    }
+    if (info?.isSymbolicLink()) throw new Error("Refusing to remove a symlink worktree.");
+    const job = await Effect15.runPromise(this.store.workflow(`preparation:${session.id}`));
+    const projects = await Effect15.runPromise(this.store.registeredProjects(this.projectsRoot));
+    const project = job?.kind === "preparation" ? job.projectPath : projects.find((item) => item.id === session.projectId)?.path;
+    if (!project) throw new Error("Reconnect the project before removing its worktree.");
+    if (info) {
+      await workflowCommand(project, "git", [
+        "worktree",
+        "remove",
+        ...discardChanges ? ["--force"] : [],
+        workspace
+      ]);
+    } else {
+      await workflowCommand(project, "git", ["worktree", "prune"]);
+    }
+  }
+  async prune(maxAgeDays, now = Date.now()) {
+    if (!Number.isFinite(maxAgeDays) || maxAgeDays <= 0) return;
+    const sessions = await Effect15.runPromise(this.store.list());
+    const failures = [];
+    for (const session of sessions) {
+      const lockId = await sessionTaskLockId(this.store, session);
+      await withTaskLock(lockId, async () => {
+        const current = await Effect15.runPromise(this.store.get(session.id));
+        if (!current || taskStatusForSession(current.status, current) !== "done" || now - Date.parse(current.updatedAt) < maxAgeDays * 864e5)
+          return;
+        await this.remove(current, false);
+      }).catch((error) => failures.push(error));
+    }
+    if (failures.length)
+      throw new AggregateError(failures, "Some completed worktrees could not be pruned.");
+  }
+};
+async function removeRunFiles(dataRoot2, sessionId) {
+  if (path8.basename(sessionId) !== sessionId || sessionId === "." || sessionId === "..")
+    throw new Error("Invalid session directory.");
+  await rm2(path8.join(dataRoot2, "pi", sessionId), { recursive: true, force: true });
+}
+
 // src/index.ts
 var host = process.env.AGENTRIFIC_HOST ?? "127.0.0.1";
 var port = Number(process.env.AGENTRIFIC_PORT ?? 4318);
-var defaultProjectsRoot = path7.resolve(process.env.AGENTRIFIC_PROJECTS_DIR ?? "./projects");
-var worktreesRoot = path7.resolve(
-  process.env.AGENTRIFIC_WORKTREES_DIR ?? path7.join(homedir2(), ".agentrific", "workspaces")
+var defaultProjectsRoot = path9.resolve(process.env.AGENTRIFIC_PROJECTS_DIR ?? "./projects");
+var worktreesRoot = path9.resolve(
+  process.env.AGENTRIFIC_WORKTREES_DIR ?? path9.join(homedir2(), ".agentrific", "workspaces")
 );
 var execFileAsync = promisify2(execFile2);
 if (host !== "127.0.0.1" && host !== "::1")
@@ -3126,13 +3639,18 @@ var app = Fastify({
     }
   }
 });
-var dataRoot = path7.resolve(process.env.AGENTRIFIC_DATA_DIR ?? "./data");
+var dataRoot = path9.resolve(process.env.AGENTRIFIC_DATA_DIR ?? "./data");
 var releaseLock = await acquireServerLock(dataRoot);
-var effects = ManagedRuntime.make(SessionStore.layer(path7.join(dataRoot, "sessions.sqlite")));
+var effects = ManagedRuntime.make(SessionStore.layer(path9.join(dataRoot, "sessions.sqlite")));
 var store = await effects.runPromise(SessionStore);
-var security = new ServerSecurity(store, await Effect14.runPromise(store.serverIdentity()));
+var security = new ServerSecurity(store, await Effect16.runPromise(store.serverIdentity()));
+var testPushUrl = process.env.AGENTRIFIC_PUSH_TEST_URL;
+if (testPushUrl && (process.env.AGENTRIFIC_TEST_MODE !== "1" || !new URL(testPushUrl).hostname.endsWith(".ts.net") || new URL(testPushUrl).protocol !== "https:"))
+  throw new Error("Test relay requires explicit test mode and Tailscale HTTPS.");
+var push = new ServerPush(store, security.serverId, dataRoot, fetch, testPushUrl);
 var allowedOrigins = [
   .../* @__PURE__ */ new Set([
+    "agentrific-desktop://app",
     ...(process.env.AGENTRIFIC_ALLOWED_ORIGINS ?? "http://localhost:8081,http://127.0.0.1:8081").split(","),
     `http://${host === "::1" ? "[::1]" : host}:${port}`,
     ...process.env.AGENTRIFIC_PUBLIC_URL ? [new URL(process.env.AGENTRIFIC_PUBLIC_URL).origin] : []
@@ -3143,14 +3661,15 @@ await app.register(cors, {
   methods: ["GET", "POST", "PATCH", "DELETE"]
 });
 await registerSecurity(app, security, serverVersion, allowedOrigins);
+registerPushRoutes(app, push, security);
 var attachmentEffects = ManagedRuntime.make(
-  Attachments.layer(path7.join(dataRoot, "attachments"), store)
+  Attachments.layer(path9.join(dataRoot, "attachments"), store)
 );
 var attachments = await attachmentEffects.runPromise(Attachments);
-await Effect14.runPromise(attachments.cleanup());
+await Effect16.runPromise(attachments.cleanup());
 var attachmentCleanup = setInterval(
   () => {
-    void Effect14.runPromise(attachments.cleanup()).catch((error) => app.log.error(error));
+    void Effect16.runPromise(attachments.cleanup()).catch((error) => app.log.error(error));
   },
   60 * 60 * 1e3
 );
@@ -3161,14 +3680,14 @@ await app.register(multipart, {
 app.post(
   "/api/projects/:projectId/attachments",
   async (request, reply) => {
-    const root = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-    const projects = await Effect14.runPromise(discoverProjects(root, store));
+    const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+    const projects = await Effect16.runPromise(discoverProjects(root, store));
     if (!projects.some((project) => project.id === request.params.projectId && project.available))
       return reply.code(404).send({ error: "Project not found." });
     try {
       const file = await request.file();
       if (!file) return reply.code(400).send({ error: "Choose a file to upload." });
-      return reply.code(201).send(await Effect14.runPromise(attachments.upload(request.params.projectId, file)));
+      return reply.code(201).send(await Effect16.runPromise(attachments.upload(request.params.projectId, file)));
     } catch (error) {
       return reply.code(400).send({ error: error instanceof Error ? error.message : "Upload failed." });
     }
@@ -3177,7 +3696,7 @@ app.post(
 app.get(
   "/api/projects/:projectId/attachments/:id/content",
   async (request, reply) => {
-    const attachment = await Effect14.runPromise(store.getAttachment(request.params.id));
+    const attachment = await Effect16.runPromise(store.getAttachment(request.params.id));
     if (!attachment || attachment.projectId !== request.params.projectId)
       return reply.code(404).send({ error: "Attachment not found." });
     const preview = request.query.preview === "1" && attachment.kind === "image";
@@ -3191,7 +3710,7 @@ app.get(
   }
 );
 function publish(event, workflowUpdate = false) {
-  const previous = event.type === "session.updated" ? Effect14.runSync(store.get(event.session.id)) : void 0;
+  const previous = event.type === "session.updated" ? Effect16.runSync(store.get(event.session.id)) : void 0;
   const emittedEvent = event.type === "session.updated" && previous && !workflowUpdate ? {
     type: "session.updated",
     session: {
@@ -3200,7 +3719,8 @@ function publish(event, workflowUpdate = false) {
       preparation: previous.preparation
     }
   } : event;
-  const record = Effect14.runSync(store.append(emittedEvent));
+  const notification = emittedEvent.type === "session.updated" ? push.pending(emittedEvent.session, previous) : void 0;
+  const record = Effect16.runSync(store.append(emittedEvent, notification));
   const message = JSON.stringify({ type: "event", record });
   for (const client of security.sockets.keys()) {
     if (!(client instanceof WebSocket) || client.readyState !== WebSocket.OPEN) continue;
@@ -3213,8 +3733,8 @@ var delivery = new DeliveryCoordinator(store, {
   publish: (event) => publish(event, true),
   draft: deliveryWriter(models),
   projectPath: async (session) => {
-    const projectsRoot = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-    const project = (await Effect14.runPromise(discoverProjects(projectsRoot, store))).find(
+    const projectsRoot = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+    const project = (await Effect16.runPromise(discoverProjects(projectsRoot, store))).find(
       (item) => item.id === session.projectId && item.available
     );
     if (!project) throw new Error("Reconnect the project folder before delivering changes.");
@@ -3227,12 +3747,27 @@ var agentEffects = ManagedRuntime.make(
     createPiFactory(attachments, models, delivery),
     publish,
     worktreesRoot,
-    path7.join(dataRoot, "pi"),
-    (sessionId, messageId) => Effect14.runSync(store.hasMessage(sessionId, messageId)),
+    path9.join(dataRoot, "pi"),
+    (sessionId, messageId) => Effect16.runSync(store.hasMessage(sessionId, messageId)),
     (session) => delivery.settled(session.id)
   )
 );
 var runtime = await agentEffects.runPromise(AgentSessions);
+var worktreeCleanup = new WorktreeCleanup(store, worktreesRoot, defaultProjectsRoot);
+var maxWorktreeAgeDays = Number(process.env.AGENTRIFIC_DONE_WORKTREE_MAX_AGE_DAYS ?? 0);
+if (!Number.isInteger(maxWorktreeAgeDays) || maxWorktreeAgeDays < 0)
+  throw new Error("AGENTRIFIC_DONE_WORKTREE_MAX_AGE_DAYS must be a nonnegative integer.");
+var pruneWorktrees = () => withTaskLock("worktree-pruning", async () => {
+  await worktreeCleanup.prune(maxWorktreeAgeDays);
+});
+var worktreeCleanupTimer = setInterval(
+  () => {
+    void pruneWorktrees().catch((error) => app.log.error(error));
+  },
+  60 * 60 * 1e3
+);
+worktreeCleanupTimer.unref();
+void pruneWorktrees().catch((error) => app.log.error(error));
 var updates = new UpdateDiscovery(store);
 var maintenance = new Maintenance(() => [
   ...runtime.workloads(),
@@ -3248,7 +3783,7 @@ var stopUpdateDiscovery = updates.start(
   () => maintenance.ready(),
   (error) => app.log.error(error)
 );
-for (const session of await Effect14.runPromise(store.list())) {
+for (const session of await Effect16.runPromise(store.list())) {
   if (session.gitDelivery?.status === "pending") {
     publish(
       {
@@ -3292,7 +3827,7 @@ async function githubCliStatus() {
 }
 app.get("/api/connections", async () => githubCliStatus());
 app.get("/api/settings", async () => ({
-  projectsRoot: await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot)),
+  projectsRoot: await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot)),
   defaultModel: await models.defaultIdentity()
 }));
 app.get("/api/models", async (_request, reply) => {
@@ -3320,7 +3855,7 @@ app.post("/api/settings/model", async (request, reply) => {
   try {
     const defaultModel = await models.setDefault(parsed.data);
     return {
-      projectsRoot: await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot)),
+      projectsRoot: await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot)),
       defaultModel
     };
   } catch {
@@ -3329,54 +3864,57 @@ app.post("/api/settings/model", async (request, reply) => {
     });
   }
 });
-app.post("/api/sessions/:id/model", async (request, reply) => {
-  const parsed = ModelReferenceSchema.safeParse(request.body);
-  const session = await Effect14.runPromise(store.get(request.params.id));
-  if (!session) return reply.code(404).send({ error: "Session not found." });
-  if (!parsed.success)
-    return reply.code(400).send({ error: "Choose a model from the server catalogue." });
-  try {
-    await models.resolve(parsed.data);
-    return await Effect14.runPromise(runtime.setModel(session, parsed.data));
-  } catch {
-    return reply.code(409).send({
-      error: "Could not change the model. Wait for the current reply to finish and choose an available model."
-    });
-  }
-});
+app.post(
+  "/api/sessions/:id/model",
+  async (request, reply) => withSessionTaskLock(request.params.id, async () => {
+    const parsed = ModelReferenceSchema.safeParse(request.body);
+    const session = await Effect16.runPromise(store.get(request.params.id));
+    if (!session) return reply.code(404).send({ error: "Session not found." });
+    if (!parsed.success)
+      return reply.code(400).send({ error: "Choose a model from the server catalogue." });
+    try {
+      await models.resolve(parsed.data);
+      return await Effect16.runPromise(runtime.setModel(session, parsed.data));
+    } catch {
+      return reply.code(409).send({
+        error: "Could not change the model. Wait for the current reply to finish and choose an available model."
+      });
+    }
+  })
+);
 app.post("/api/settings", async (request, reply) => {
   const parsed = UpdateSettingsSchema.safeParse(request.body);
   if (!parsed.success) return reply.code(400).send({ error: "Enter a projects folder." });
-  const result = await Effect14.runPromise(
-    resolveProjectsRoot(parsed.data.projectsRoot).pipe(Effect14.result)
+  const result = await Effect16.runPromise(
+    resolveProjectsRoot(parsed.data.projectsRoot).pipe(Effect16.result)
   );
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
-  return Effect14.runPromise(store.setProjectsRoot(result.success));
+  return Effect16.runPromise(store.setProjectsRoot(result.success));
 });
 app.get("/api/projects", async (_request, reply) => {
-  const root = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const result = await Effect14.runPromise(discoverProjects(root, store).pipe(Effect14.result));
+  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const result = await Effect16.runPromise(discoverProjects(root, store).pipe(Effect16.result));
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
   return result.success;
 });
 app.get("/api/projects/:id", async (request, reply) => {
-  const root = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const result = await Effect14.runPromise(discoverProjects(root, store).pipe(Effect14.result));
+  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const result = await Effect16.runPromise(discoverProjects(root, store).pipe(Effect16.result));
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
   const project = result.success.find((item) => item.id === request.params.id);
   return project ?? reply.code(404).send({ error: "Project not found on this server." });
 });
 app.post("/api/projects/:id/reconnect", async (request, reply) => {
-  const parsed = z13.object({ path: z13.string().trim().min(1).max(4096) }).safeParse(request.body);
+  const parsed = z16.object({ path: z16.string().trim().min(1).max(4096) }).safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: "Enter the project's new folder path." });
-  const root = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const result = await Effect14.runPromise(
-    reconnectProject(root, request.params.id, parsed.data.path, store).pipe(Effect14.result)
+  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const result = await Effect16.runPromise(
+    reconnectProject(root, request.params.id, parsed.data.path, store).pipe(Effect16.result)
   );
   return result._tag === "Failure" ? reply.code(400).send({ error: result.failure.message }) : result.success;
 });
-app.get("/api/sessions", () => Effect14.runPromise(store.list()));
+app.get("/api/sessions", () => Effect16.runPromise(store.list()));
 app.get(
   "/api/tasks",
   (request) => boardTasks(store, request.query.projectId)
@@ -3389,15 +3927,15 @@ app.post("/api/tasks", async (request, reply) => {
     if (!github.githubCli.authenticated)
       return reply.code(400).send({ error: "GitHub CLI must be authenticated on the server to open a PR." });
   }
-  const projectsRoot = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const projects = await Effect14.runPromise(
-    discoverProjects(projectsRoot, store).pipe(Effect14.result)
+  const projectsRoot = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const projects = await Effect16.runPromise(
+    discoverProjects(projectsRoot, store).pipe(Effect16.result)
   );
   if (projects._tag === "Failure" || !projects.success.some((project) => project.id === parsed.data.projectId && project.available))
     return reply.code(404).send({ error: "Project not found in the server's projects folder." });
   let files;
   try {
-    files = await Effect14.runPromise(
+    files = await Effect16.runPromise(
       attachments.resolve(parsed.data.projectId, parsed.data.attachmentIds ?? [])
     );
   } catch (error) {
@@ -3405,7 +3943,7 @@ app.post("/api/tasks", async (request, reply) => {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const task = TaskSchema.parse({
-    id: randomUUID7(),
+    id: randomUUID8(),
     ...parsed.data,
     attachments: files,
     status: "backlog",
@@ -3413,7 +3951,7 @@ app.post("/api/tasks", async (request, reply) => {
     createdAt: now,
     updatedAt: now
   });
-  return reply.code(201).send(await Effect14.runPromise(store.saveTask(task)));
+  return reply.code(201).send(await Effect16.runPromise(store.saveTask(task)));
 });
 app.patch("/api/tasks/:id", async (request, reply) => {
   const parsed = UpdateTaskSchema.safeParse(request.body);
@@ -3428,8 +3966,8 @@ app.patch("/api/tasks/:id", async (request, reply) => {
         return reply.code(400).send({ error: "GitHub CLI must be authenticated on the server to open a PR." });
     }
     return await editTask(store, request.params.id, parsed.data, async (projectId, ids) => {
-      const result = await Effect14.runPromise(
-        attachments.resolve(projectId, ids).pipe(Effect14.result)
+      const result = await Effect16.runPromise(
+        attachments.resolve(projectId, ids).pipe(Effect16.result)
       );
       if (result._tag === "Failure") throw new TaskActionError(result.failure.message, 400);
       return result.success;
@@ -3442,7 +3980,12 @@ app.patch("/api/tasks/:id", async (request, reply) => {
 });
 app.delete("/api/tasks/:id", async (request, reply) => {
   try {
-    await deleteTask(store, request.params.id);
+    await deleteTask(store, request.params.id, async (session) => {
+      await Effect16.runPromise(runtime.forget(session.id));
+      await worktreeCleanup.remove(session);
+      await removeRunFiles(dataRoot, session.id);
+    });
+    await Effect16.runPromise(attachments.cleanup());
     return reply.code(204).send();
   } catch (error) {
     if (error instanceof TaskActionError)
@@ -3451,31 +3994,34 @@ app.delete("/api/tasks/:id", async (request, reply) => {
   }
 });
 app.get("/api/sessions/:id", async (request, reply) => {
-  const session = await Effect14.runPromise(store.get(request.params.id));
+  const session = await Effect16.runPromise(store.get(request.params.id));
   if (!session) return reply.code(404).send({ error: "Session not found." });
   return session;
 });
-app.post("/api/sessions/:id/delivery", async (request, reply) => {
-  const session = await Effect14.runPromise(store.get(request.params.id));
-  if (!session) return reply.code(404).send({ error: "Session not found." });
-  try {
-    const result = await delivery.retry(session.id);
-    return reply.code(202).send(result);
-  } catch (error) {
-    return reply.code(409).send({ error: error instanceof Error ? error.message : "Delivery could not be retried." });
-  }
-});
+app.post(
+  "/api/sessions/:id/delivery",
+  async (request, reply) => withSessionTaskLock(request.params.id, async () => {
+    const session = await Effect16.runPromise(store.get(request.params.id));
+    if (!session) return reply.code(404).send({ error: "Session not found." });
+    try {
+      const result = await delivery.retry(session.id);
+      return reply.code(202).send(result);
+    } catch (error) {
+      return reply.code(409).send({ error: error instanceof Error ? error.message : "Delivery could not be retried." });
+    }
+  })
+);
 app.post(
   "/api/sessions/:id/preparation/retry",
-  async (request, reply) => {
+  async (request, reply) => withSessionTaskLock(request.params.id, async () => {
     let preparedSession;
     try {
       const prepared = await preparation.retry(request.params.id);
       preparedSession = prepared.session;
-      const files = await Effect14.runPromise(
+      const files = await Effect16.runPromise(
         attachments.resolve(prepared.session.projectId, prepared.input.attachmentIds ?? [])
       );
-      await Effect14.runPromise(runtime.send(prepared.session, prepared.input.prompt, files));
+      await Effect16.runPromise(runtime.send(prepared.session, prepared.input.prompt, files));
       return reply.code(202).send(prepared.session);
     } catch (error) {
       if (preparedSession) {
@@ -3489,18 +4035,18 @@ app.post(
         error: error instanceof Error ? error.message : "Preparation could not be retried."
       });
     }
-  }
+  })
 );
-var HistoryQuery = z13.object({
-  after: z13.coerce.number().int().nonnegative().default(0),
-  limit: z13.coerce.number().int().min(1).max(1e3).default(500)
+var HistoryQuery = z16.object({
+  after: z16.coerce.number().int().nonnegative().default(0),
+  limit: z16.coerce.number().int().min(1).max(1e3).default(500)
 });
 app.get("/api/sessions/:id/events", async (request, reply) => {
   const query = HistoryQuery.safeParse(request.query);
   if (!query.success) return reply.code(400).send({ error: "Invalid history cursor or limit." });
-  const session = await Effect14.runPromise(store.get(request.params.id));
+  const session = await Effect16.runPromise(store.get(request.params.id));
   if (!session) return reply.code(404).send({ error: "Session not found." });
-  return Effect14.runPromise(store.history(session.id, query.data.after, query.data.limit));
+  return Effect16.runPromise(store.history(session.id, query.data.after, query.data.limit));
 });
 async function selectSessionModel(input, hasImages) {
   try {
@@ -3520,26 +4066,26 @@ async function selectSessionModel(input, hasImages) {
   }
 }
 async function resolveSessionProject(projectId) {
-  const projectsRoot = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const project = (await Effect14.runPromise(discoverProjects(projectsRoot, store))).find(
+  const projectsRoot = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const project = (await Effect16.runPromise(discoverProjects(projectsRoot, store))).find(
     (item) => item.id === projectId && item.available
   );
   if (!project)
     return { error: "Project folder is missing. Reconnect it before starting a run.", status: 404 };
   const projectPath = await realpath2(project.path);
   const resolvedRoot = await realpath2(projectsRoot);
-  if (path7.dirname(projectPath) !== resolvedRoot)
+  if (path9.dirname(projectPath) !== resolvedRoot)
     return { error: "Project path is outside projects root.", status: 400 };
   return { projectPath };
 }
 async function resolveSessionWorkspace(id, gitFlow, projectPath) {
-  const worktreePath = path7.join(worktreesRoot, id);
+  const worktreePath = path9.join(worktreesRoot, id);
   const branch = gitFlow ? `agentrific/${id.slice(0, 8)}` : null;
   const useProjectCheckout = gitFlow?.workspace === "checkout";
   const workspacePath = !gitFlow || useProjectCheckout ? projectPath : worktreePath;
   if (useProjectCheckout) {
     const serverPath = await realpath2(process.cwd());
-    if (serverPath === projectPath || serverPath.startsWith(`${projectPath}${path7.sep}`))
+    if (serverPath === projectPath || serverPath.startsWith(`${projectPath}${path9.sep}`))
       return {
         error: "The server runs from this project. Choose a worktree for this task.",
         status: 409
@@ -3563,7 +4109,7 @@ async function createAndStartSession(input) {
   const projectPath = location.projectPath;
   let files;
   try {
-    files = await Effect14.runPromise(
+    files = await Effect16.runPromise(
       attachments.resolve(input.projectId, input.attachmentIds ?? [])
     );
   } catch (error) {
@@ -3576,11 +4122,11 @@ async function createAndStartSession(input) {
   if (selection.error !== void 0) return { error: selection.error, status: selection.status };
   const selectedModel = selection.model;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const task = input.taskId ? await Effect14.runPromise(store.getTask(input.taskId)) : void 0;
+  const task = input.taskId ? await Effect16.runPromise(store.getTask(input.taskId)) : void 0;
   if (input.taskId && sessionTaskUnavailable(task, input.projectId))
     return { error: "Task not found.", status: 404 };
   const session = SessionSchema.parse({
-    id: randomUUID7(),
+    id: randomUUID8(),
     taskId: input.taskId ?? null,
     projectId: input.projectId,
     title: task?.title ?? input.prompt.slice(0, 80),
@@ -3605,7 +4151,7 @@ async function createAndStartSession(input) {
     );
   } catch (error) {
     if (task)
-      await Effect14.runPromise(
+      await Effect16.runPromise(
         store.saveTask({ ...task, sessionId: session.id, updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
       );
     return {
@@ -3614,7 +4160,7 @@ async function createAndStartSession(input) {
     };
   }
   try {
-    await Effect14.runPromise(runtime.send(running, input.prompt, files));
+    await Effect16.runPromise(runtime.send(running, input.prompt, files));
   } catch (error) {
     publish({
       type: "session.updated",
@@ -3623,7 +4169,7 @@ async function createAndStartSession(input) {
     publish({ type: "error", sessionId: session.id, message: String(error) });
     return { error: "Could not start the agent session.", status: 500 };
   }
-  return { session: await Effect14.runPromise(store.get(session.id)), status: 201 };
+  return { session: await Effect16.runPromise(store.get(session.id)), status: 201 };
 }
 app.post("/api/sessions", async (request, reply) => {
   const parsed = CreateSessionSchema.safeParse(request.body);
@@ -3635,17 +4181,17 @@ app.post("/api/sessions", async (request, reply) => {
   if (!result.session) return reply.code(result.status).send({ error: result.error });
   return reply.code(201).send(result.session);
 });
-var StartTaskBody = z13.object({ prompt: z13.string().trim().max(2e4).optional() }).default({});
+var StartTaskBody = z16.object({ prompt: z16.string().trim().max(2e4).optional() }).default({});
 function startTask(id, instructionsOverride, automated = false) {
   return withTaskLock(
     "agent-dispatch",
     () => withTaskLock(id, async () => {
       maintenance.assertReady();
-      const task = await Effect14.runPromise(store.getTask(id));
+      const task = await Effect16.runPromise(store.getTask(id));
       if (!task || task.deletedAt) throw new TaskActionError("Task not found.", 404);
       if (automated) {
-        const state = await Effect14.runPromise(store.automation());
-        if (activeAgents(await Effect14.runPromise(store.list())) >= state.config.parallelism) return;
+        const state = await Effect16.runPromise(store.automation());
+        if (activeAgents(await Effect16.runPromise(store.list())) >= state.config.parallelism) return;
         const backlog = await boardTasks(store);
         if (!backlog.some((item) => item.id === id && item.status === "backlog")) return;
       }
@@ -3653,7 +4199,7 @@ function startTask(id, instructionsOverride, automated = false) {
       const prompt = instructions ? `${task.title}
 
 ${instructions}` : task.title;
-      const linkedSession = task.sessionId ? await Effect14.runPromise(store.get(task.sessionId)) : void 0;
+      const linkedSession = task.sessionId ? await Effect16.runPromise(store.get(task.sessionId)) : void 0;
       if (linkedSession && (["starting", "running", "queued"].includes(linkedSession.status) || linkedSession.gitDelivery?.status === "pending"))
         throw new TaskActionError("This task already has a running agent.", 409);
       const result = await createAndStartSession({
@@ -3667,7 +4213,7 @@ ${instructions}` : task.title;
       });
       if (!result.session)
         throw new TaskActionError(result.error ?? "Could not start task.", result.status);
-      const updatedTask = await Effect14.runPromise(
+      const updatedTask = await Effect16.runPromise(
         store.saveTask({
           ...task,
           status: taskStatusForSession(result.session.status, result.session),
@@ -3702,8 +4248,8 @@ app.patch("/api/automation", async (request, reply) => {
   const parsed = AutomationConfigSchema.safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: parsed.error.issues.map((issue) => issue.message).join(" ") });
-  const root = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const projects = await Effect14.runPromise(discoverProjects(root, store));
+  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const projects = await Effect16.runPromise(discoverProjects(root, store));
   if (parsed.data.projectIds.some(
     (id) => !projects.some((project) => project.id === id && project.available)
   ))
@@ -3713,7 +4259,7 @@ app.patch("/api/automation", async (request, reply) => {
   return automation.configure(parsed.data);
 });
 app.patch("/api/automation/queue", async (request, reply) => {
-  const parsed = z13.object({ taskId: z13.string().min(1), beforeId: z13.string().min(1).nullable() }).safeParse(request.body);
+  const parsed = z16.object({ taskId: z16.string().min(1), beforeId: z16.string().min(1).nullable() }).safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: "Choose a task and a queue position." });
   try {
@@ -3730,8 +4276,8 @@ var automationTimer = setInterval(() => {
 automationTimer.unref();
 app.post(
   "/api/sessions/:id/messages",
-  async (request, reply) => {
-    const session = await Effect14.runPromise(store.get(request.params.id));
+  async (request, reply) => withSessionTaskLock(request.params.id, async () => {
+    const session = await Effect16.runPromise(store.get(request.params.id));
     if (!session) return reply.code(404).send({ error: "Session not found." });
     const parsed = SendMessageSchema.safeParse(request.body);
     if (!parsed.success) return reply.code(400).send({ error: parsed.error.flatten() });
@@ -3739,27 +4285,35 @@ app.post(
       await delivery.assertCanWork(session.id);
       if (session.preparation && session.preparation.status !== "ready")
         throw new Error("Retry workspace preparation before sending a message.");
-      const files = await Effect14.runPromise(
+      const files = await Effect16.runPromise(
         attachments.resolve(session.projectId, parsed.data.attachmentIds ?? [])
       );
-      await Effect14.runPromise(
+      await Effect16.runPromise(
         runtime.send(session, parsed.data.message, files, parsed.data.clientMessageId)
       );
       return reply.code(202).send({ accepted: true });
     } catch (error) {
       return reply.code(409).send({ error: String(error) });
     }
-  }
+  })
+);
+async function withSessionTaskLock(id, operation) {
+  const session = await Effect16.runPromise(store.get(id));
+  const lockId = session ? await sessionTaskLockId(store, session) : `session-${id}`;
+  return withTaskLock(lockId, operation);
+}
+app.post(
+  "/api/sessions/:id/stop",
+  async (request, reply) => withSessionTaskLock(request.params.id, async () => {
+    const session = await Effect16.runPromise(store.get(request.params.id));
+    if (!session) return reply.code(404).send({ error: "Session not found." });
+    await Effect16.runPromise(runtime.stop(session));
+    return reply.code(202).send({ accepted: true });
+  })
 );
-app.post("/api/sessions/:id/stop", async (request, reply) => {
-  const session = await Effect14.runPromise(store.get(request.params.id));
-  if (!session) return reply.code(404).send({ error: "Session not found." });
-  await Effect14.runPromise(runtime.stop(session));
-  return reply.code(202).send({ accepted: true });
-});
 attachEventServer(app, security, allowedOrigins, () => ({
   type: "snapshot",
-  sessions: Effect14.runSync(store.list())
+  sessions: Effect16.runSync(store.list())
 }));
 var closeControl = await startControl(
   dataRoot,
@@ -3771,20 +4325,25 @@ var closeControl = await startControl(
     connectedDevices: new Set(security.sockets.values()).size,
     connectedSockets: security.sockets.size,
     memory: process.memoryUsage().rss,
-    activeRuns: activeAgents(Effect14.runSync(store.list())),
+    activeRuns: activeAgents(Effect16.runSync(store.list())),
     maintenance: maintenance.status()
   }),
   maintenance
 );
+push.start();
 app.addHook("onClose", async () => {
+  await push.close();
   maintenance.enter();
   stopUpdateDiscovery();
   await updates.settle();
   clearInterval(attachmentCleanup);
+  clearInterval(worktreeCleanupTimer);
+  await withTaskLock("worktree-pruning", async () => {
+  });
   clearInterval(automationTimer);
   await withTaskLock("automation", async () => {
   });
-  await Effect14.runPromise(runtime.close());
+  await Effect16.runPromise(runtime.close());
   await agentEffects.dispose();
   await attachmentEffects.dispose();
   await effects.dispose();