@pstdio/pocketcoder-cli 0.7.3 → 0.8.0

package/dist/index.js

@@ -109,12 +109,12 @@ var require_main = __commonJS((exports, module) => {
       err.code = "MISSING_DATA";
       throw err;
     }
-    const keys = _dotenvKey(options).split(",");
-    const length = keys.length;
+    const keys2 = _dotenvKey(options).split(",");
+    const length = keys2.length;
     let decrypted;
     for (let i = 0;i < length; i++) {
       try {
-        const key = keys[i].trim();
+        const key = keys2[i].trim();
         const attrs = _instructions(result, key);
         decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
         break;
@@ -5214,7 +5214,7 @@ function isYargsInstance(y) {
 var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 // package.json
-var version = "0.7.3";
+var version = "0.8.0";
 
 // src/command/cli-context.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
@@ -21235,6 +21235,20 @@ class OperationCapacityExceededError extends Error {
 var TEMPLATE_STATUSES = ["active", "available", "retired"];
 // ../runtime-contracts/src/stores/warm-pools.ts
 var WARM_POOL_RUNTIME_STATES = ["provisioning", "ready", "leasing", "leased", "draining", "failed"];
+// ../runtime-contracts/src/stores/workspaces.ts
+function purgedContentPatch() {
+  return {
+    launchInput: null,
+    health: {},
+    outputs: {},
+    failureLogTail: null,
+    failureLogTailTruncated: false,
+    failureLastLogSeq: null,
+    resolvedSource: null,
+    registrationDigest: null,
+    reconnectDigest: null
+  };
+}
 // ../../node_modules/.bun/drizzle-orm@1.0.0-rc.4+b8545101ea3de3ba/node_modules/drizzle-orm/sql/functions/aggregate.js
 function count2(expression) {
   return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
@@ -21284,6 +21298,9 @@ function createAccessTables(table2 = pgTable) {
     createdAt: timestamptz("created_at").notNull()
   });
   const machineKeys = table2("machine_keys", {
+    issuanceRequestId: text2("issuance_request_id"),
+    issuanceRequestDigest: text2("issuance_request_digest"),
+    managedPrincipalIds: text2("managed_principal_ids").array().notNull().default([]),
     id: uuid("id").primaryKey(),
     principalId: uuid("principal_id").notNull().references(() => principals.id),
     secretDigest: bytea2("secret_digest").$type().notNull(),
@@ -21292,7 +21309,7 @@ function createAccessTables(table2 = pgTable) {
     expiresAt: timestamptz("expires_at"),
     revokedAt: timestamptz("revoked_at"),
     lastUsedAt: timestamptz("last_used_at")
-  });
+  }, (table3) => [unique().on(table3.principalId, table3.issuanceRequestId)]);
   return { templates: templates2, principals, machineKeys };
 }
 
@@ -35640,6 +35657,58 @@ var AttachmentResolvedPayload = exports_external.object({
   descriptors: exports_external.array(AttachmentDescriptorSchema).optional(),
   missing_id: exports_external.uuid().optional()
 });
+// ../contracts/src/common/scopes.ts
+var SCOPES = [
+  "templates:read",
+  "workspaces:create",
+  "workspaces:read",
+  "workspaces:cancel",
+  "workspaces:purge",
+  "workspaces:recover",
+  "keys:read",
+  "keys:write",
+  "workspaces:preserve",
+  "workspaces:restore",
+  "checkpoints:read",
+  "checkpoints:delete",
+  "outputs:read",
+  "conversations:read",
+  "conversations:delete",
+  "services:relay",
+  "attachments:write",
+  "logs:read",
+  "network:read",
+  "terminal:attach",
+  "terminal:read",
+  "admin"
+];
+function isScope(value) {
+  return SCOPES.includes(value);
+}
+function hasScope(granted, required2) {
+  return granted.includes(required2) || granted.includes("admin");
+}
+
+// ../contracts/src/auth/keys.ts
+var KeyIssueRequestSchema = exports_external.strictObject({
+  request_id: exports_external.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/),
+  scopes: exports_external.array(exports_external.enum(SCOPES)).min(1).max(SCOPES.length),
+  expires_at: exports_external.iso.datetime()
+});
+var KeyResourceSchema = exports_external.object({
+  id: exports_external.uuid(),
+  principal_id: exports_external.uuid(),
+  scopes: exports_external.array(exports_external.string()),
+  effective_scopes: exports_external.array(exports_external.string()),
+  managed_principal_ids: exports_external.array(exports_external.uuid()),
+  issuance_request_id: exports_external.string().nullable(),
+  created_at: exports_external.iso.datetime(),
+  expires_at: exports_external.iso.datetime().nullable(),
+  revoked_at: exports_external.iso.datetime().nullable(),
+  last_used_at: exports_external.iso.datetime().nullable()
+});
+var KeyIssueResponseSchema = exports_external.object({ key: KeyResourceSchema, token: exports_external.string().nullable() });
+var KeyListResponseSchema = exports_external.object({ items: exports_external.array(KeyResourceSchema), next_cursor: exports_external.uuid().nullable() });
 // ../contracts/src/common/canonical.ts
 import { createHash as createHash2 } from "crypto";
 function canonicalJson(value) {
@@ -35695,6 +35764,8 @@ var ERROR_CODES = {
   "auth.invalid_key": 401,
   "auth.missing_scope": 403,
   "auth.disabled_principal": 403,
+  "principal.not_found": 404,
+  "key.not_found": 404,
   "validation.invalid": 400,
   "idempotency.conflict": 409,
   "capacity.queue_full": 429,
@@ -35782,33 +35853,6 @@ function CursorQuerySchema(maxLimit, defaultLimit) {
     limit: exports_external.coerce.number().int().positive().max(maxLimit).default(defaultLimit)
   });
 }
-// ../contracts/src/common/scopes.ts
-var SCOPES = [
-  "templates:read",
-  "workspaces:create",
-  "workspaces:read",
-  "workspaces:cancel",
-  "workspaces:preserve",
-  "workspaces:restore",
-  "checkpoints:read",
-  "checkpoints:delete",
-  "outputs:read",
-  "conversations:read",
-  "conversations:delete",
-  "services:relay",
-  "attachments:write",
-  "logs:read",
-  "network:read",
-  "terminal:attach",
-  "terminal:read",
-  "admin"
-];
-function isScope(value) {
-  return SCOPES.includes(value);
-}
-function hasScope(granted, required2) {
-  return granted.includes(required2) || granted.includes("admin");
-}
 // ../contracts/src/conversations/conversation.ts
 var CONVERSATION_ROLES = ["user", "assistant", "system", "tool"];
 var ConversationMetadataSchema = exports_external.record(exports_external.string().min(1).max(64), exports_external.string().max(512)).refine((value) => Object.keys(value).length <= 32, "conversation metadata has at most 32 keys");
@@ -35935,7 +35979,7 @@ var CHECKPOINT_STATES = ["creating", "ready", "failed", "deleting", "deleted"];
 function isCheckpointState(value) {
   return CHECKPOINT_STATES.some((state) => state === value);
 }
-var OPERATION_KINDS = ["preserve", "restore", "verify", "delete"];
+var OPERATION_KINDS = ["preserve", "restore", "verify", "delete", "purge"];
 var OPERATION_STATES = ["pending", "running", "succeeded", "failed"];
 var STORAGE_STATES = [
   "allocating",
@@ -37493,6 +37537,7 @@ function createWorkspaceTables(table2 = pgTable, { principals, machineKeys, temp
     createdAt: timestamptz("created_at").notNull(),
     updatedAt: timestamptz("updated_at").notNull(),
     terminalAt: timestamptz("terminal_at"),
+    purgeRequestedAt: timestamptz("purge_requested_at"),
     originWorkspaceId: uuid("origin_workspace_id"),
     restoredFromCheckpointId: uuid("restored_from_checkpoint_id"),
     sourceDescriptor: structuredJson("source_descriptor").$type(),
@@ -37612,9 +37657,9 @@ var {
 } = createSchema();
 // ../db/src/database/context.ts
 var {SQL: SQL6 } = globalThis.Bun;
-function createDatabaseContext(databaseUrl, schemaName) {
+function createDatabaseContext(databaseUrl, schemaName, options = {}) {
   const schema = assertValidSchema(schemaName);
-  const client = new SQL6(databaseUrl);
+  const client = new SQL6(databaseUrl, options);
   return {
     schema,
     client,
@@ -37726,9 +37771,63 @@ function requiredRow(row) {
   return row;
 }
 
+// ../db/src/modules/auth/key-inventory.ts
+function createKeyInventory({ db, tables: { principals: principals2, machineKeys: machineKeys2 } }) {
+  async function issue2(input) {
+    return db.transaction(async (tx) => {
+      const [principal] = await tx.select().from(principals2).where(eq(principals2.id, input.principalId)).for("update");
+      if (!principal)
+        throw new ApiError("auth.invalid_key", "Unknown principal.");
+      if (input.issuanceRequestId) {
+        const [existing] = await tx.select().from(machineKeys2).where(and(eq(machineKeys2.principalId, input.principalId), eq(machineKeys2.issuanceRequestId, input.issuanceRequestId)));
+        if (existing)
+          return {
+            key: existing,
+            created: false,
+            conflict: existing.issuanceRequestDigest !== input.issuanceRequestDigest
+          };
+      }
+      if (principal.disabledAt)
+        throw new ApiError("auth.disabled_principal", "This principal is disabled.");
+      if (input.issuanceRequestId && input.expiresAt && input.expiresAt <= new Date)
+        throw new ApiError("validation.invalid", "Key expiry must be in the future.");
+      if (input.scopes.some((scope) => !principal.scopes.includes("admin") && !principal.scopes.includes(scope))) {
+        throw new ApiError("auth.missing_scope", "Key scopes exceed the principal's authority.");
+      }
+      const [key] = await tx.insert(machineKeys2).values(input).returning();
+      return { key: requiredRow(key), created: true, conflict: false };
+    });
+  }
+  return {
+    issueMachineKey: (input) => issue2(input),
+    async insertMachineKey(input) {
+      await issue2(input);
+    },
+    async listMachineKeys(principalId, filter) {
+      return db.select().from(machineKeys2).where(and(eq(machineKeys2.principalId, principalId), filter.cursor ? gt(machineKeys2.id, filter.cursor) : undefined, filter.requestId ? eq(machineKeys2.issuanceRequestId, filter.requestId) : undefined)).orderBy(asc2(machineKeys2.id)).limit(filter.limit);
+    },
+    async revokePrincipalKeys(principalId, at) {
+      await db.transaction(async (tx) => {
+        await tx.select({ id: principals2.id }).from(principals2).where(eq(principals2.id, principalId)).for("update");
+        await tx.update(principals2).set({ disabledAt: at }).where(eq(principals2.id, principalId));
+        await tx.update(machineKeys2).set({ revokedAt: at }).where(and(eq(machineKeys2.principalId, principalId), isNull(machineKeys2.revokedAt)));
+      });
+    }
+  };
+}
+
 // ../db/src/modules/auth/repository.ts
-function createAuth({ db, tables: { principals: principals2, machineKeys: machineKeys2 } }) {
+function createAuth(context) {
+  const {
+    db,
+    tables: { principals: principals2, machineKeys: machineKeys2 }
+  } = context;
   return {
+    ...createKeyInventory(context),
+    async getPrincipal(id) {
+      const [row] = await db.select().from(principals2).where(eq(principals2.id, id));
+      return row ?? null;
+    },
     async createPrincipal(name2, scopes, templateNames) {
       const [row] = await db.insert(principals2).values({ id: randomUUID2(), name: name2, scopes, templateNames, createdAt: sql`now()` }).returning();
       return requiredRow(row);
@@ -37747,9 +37846,6 @@ function createAuth({ db, tables: { principals: principals2, machineKeys: machin
     async setPrincipalDisabled(id, disabled) {
       await db.update(principals2).set({ disabledAt: disabled ? sql`now()` : null }).where(eq(principals2.id, id));
     },
-    async insertMachineKey(row) {
-      await db.insert(machineKeys2).values(row);
-    },
     async getMachineKeyWithPrincipal(keyId) {
       const [row] = await db.select({ key: machineKeys2, principal: principals2 }).from(machineKeys2).innerJoin(principals2, eq(principals2.id, machineKeys2.principalId)).where(eq(machineKeys2.id, keyId));
       return row ?? null;
@@ -37764,16 +37860,71 @@ function createAuth({ db, tables: { principals: principals2, machineKeys: machin
   };
 }
 
+// ../db/src/modules/persistence/content.ts
+async function contentWritable(tx, tables, workspaceId) {
+  const [workspace] = await tx.select({ purgeRequestedAt: tables.workspaces.purgeRequestedAt }).from(tables.workspaces).where(eq(tables.workspaces.id, workspaceId)).for("update");
+  return !workspace?.purgeRequestedAt;
+}
+async function requireContentWritable(tx, tables, workspaceId) {
+  if (!await contentWritable(tx, tables, workspaceId)) {
+    throw new ApiError("operation.conflict", "Workspace content is being purged.");
+  }
+}
+function createContentPurge({ db, tables }) {
+  return {
+    async listWorkspaceStorage(workspaceId) {
+      return db.select().from(tables.workspaceStorage).where(eq(tables.workspaceStorage.workspaceId, workspaceId));
+    },
+    async purgeWorkspaceContent(workspaceId, at) {
+      await db.transaction(async (tx) => {
+        const [workspace] = await tx.select().from(tables.workspaces).where(eq(tables.workspaces.id, workspaceId)).for("update");
+        if (!workspace?.purgeRequestedAt)
+          throw new Error("Purge has not been admitted");
+        for (const table2 of [
+          tables.workspaceLogs,
+          tables.workspaceOutputs,
+          tables.workspaceConversationMessages,
+          tables.workspaceNetworkEvents,
+          tables.eventOutbox
+        ]) {
+          await tx.delete(table2).where(eq(table2.workspaceId, workspaceId));
+        }
+        await tx.insert(tables.workspaceConversations).values({ workspaceId, status: "deleted", deletedAt: at, updatedAt: at }).onConflictDoUpdate({
+          target: tables.workspaceConversations.workspaceId,
+          set: { status: "deleted", expiresAt: null, deletedAt: at, updatedAt: at }
+        });
+        await tx.update(tables.workspaceCheckpoints).set({ manifest: null, manifestDigest: null, sourceProvenance: null, label: null }).where(eq(tables.workspaceCheckpoints.workspaceId, workspaceId));
+        await tx.update(tables.workspaces).set({
+          launchInput: null,
+          outputs: {},
+          metadata: {},
+          health: {},
+          failureLogTail: null,
+          failureLogTailTruncated: false,
+          failureLastLogSeq: null,
+          sourceDescriptor: null,
+          resolvedSource: null,
+          registrationDigest: null,
+          reconnectDigest: null,
+          updatedAt: at
+        }).where(eq(tables.workspaces.id, workspaceId));
+      });
+    }
+  };
+}
+
 // ../db/src/modules/conversations/repository.ts
 var MAX_CONVERSATION_BYTES = 50 * 1024 * 1024;
 var MAX_CONVERSATION_MESSAGES = 1e5;
-function createConversations({
-  db,
-  tables: { workspaceConversations: conversations2, workspaceConversationMessages: messages }
-}) {
+function createConversations(context) {
+  const {
+    db,
+    tables: { workspaceConversations: conversations2, workspaceConversationMessages: messages }
+  } = context;
   return {
     async appendConversationMessage(input) {
       return db.transaction(async (tx) => {
+        await requireContentWritable(tx, context.tables, input.workspaceId);
         await lock(tx, input.workspaceId, 7081);
         const [state] = await tx.select({ status: conversations2.status }).from(conversations2).where(eq(conversations2.workspaceId, input.workspaceId)).for("update");
         if (state?.status === "deleted")
@@ -37827,12 +37978,18 @@ function createConversations({
 
 // ../db/src/modules/logs/repository.ts
 var MAX_LOG_BYTES = 10 * 1024 * 1024;
-function createLogs({ db, tables: { workspaceLogs: logs2 } }) {
+function createLogs(context) {
+  const {
+    db,
+    tables: { workspaceLogs: logs2 }
+  } = context;
   return {
     async appendLogs(workspaceId, entries) {
       if (entries.length === 0)
         return;
       await db.transaction(async (tx) => {
+        if (!await contentWritable(tx, context.tables, workspaceId))
+          return;
         await lock(tx, workspaceId, 7080);
         const [stats] = await tx.select({
           maxSeq: sql`coalesce(max(${logs2.seq}),0)`.mapWith(Number),
@@ -37872,12 +38029,18 @@ function createLogs({ db, tables: { workspaceLogs: logs2 } }) {
 }
 
 // ../db/src/modules/network-audit/repository.ts
-function createNetworkAudit({ db, tables: { workspaceNetworkEvents: events, workspaces: workspaces3 } }) {
+function createNetworkAudit(context) {
+  const {
+    db,
+    tables: { workspaceNetworkEvents: events, workspaces: workspaces3 }
+  } = context;
   return {
     async appendNetworkEvents(workspaceId, sourceSessionId, inputs) {
       if (inputs.length === 0)
         return;
       await db.transaction(async (tx) => {
+        if (!await contentWritable(tx, context.tables, workspaceId))
+          return;
         await lock(tx, workspaceId, 7348);
         for (const event of inputs) {
           const [duplicate] = await tx.select({ seq: events.seq }).from(events).where(and(eq(events.workspaceId, workspaceId), eq(events.sourceSessionId, sourceSessionId), eq(events.sourceSeq, event.source_seq)));
@@ -37919,7 +38082,11 @@ function createNetworkAudit({ db, tables: { workspaceNetworkEvents: events, work
 // ../db/src/modules/outbox/repository.ts
 import { randomUUID as randomUUID3 } from "crypto";
 var CLAIM_LEASE_MS = 60000;
-function createOutbox({ db, tables: { eventOutbox: outbox2 } }) {
+function createOutbox(context) {
+  const {
+    db,
+    tables: { eventOutbox: outbox2 }
+  } = context;
   return {
     async claimDueEvents(now, limit) {
       const due = db.select({ id: outbox2.id }).from(outbox2).where(and(isNull(outbox2.deliveredAt), lte(outbox2.nextAttemptAt, now))).orderBy(asc2(outbox2.occurredAt)).limit(limit).for("update", { skipLocked: true });
@@ -37933,23 +38100,32 @@ function createOutbox({ db, tables: { eventOutbox: outbox2 } }) {
       await db.update(outbox2).set({ attemptCount: sql`${outbox2.attemptCount}+1`, lastErrorCode: errorCode, nextAttemptAt }).where(eq(outbox2.id, id));
     },
     async appendEvent(workspaceId, eventType, payload, at) {
-      await db.insert(outbox2).values({
-        id: randomUUID3(),
-        workspaceId,
-        eventType,
-        payload: payload === null ? sql`'null'::jsonb` : payload,
-        occurredAt: at,
-        nextAttemptAt: at
+      await db.transaction(async (tx) => {
+        if (!await contentWritable(tx, context.tables, workspaceId))
+          return;
+        await tx.insert(outbox2).values({
+          id: randomUUID3(),
+          workspaceId,
+          eventType,
+          payload: payload === null ? sql`'null'::jsonb` : payload,
+          occurredAt: at,
+          nextAttemptAt: at
+        });
       });
     }
   };
 }
 
 // ../db/src/modules/outputs/repository.ts
-function createOutputs({ db, tables: { workspaceOutputs: outputs2, workspaces: workspaces3 } }) {
+function createOutputs(context) {
+  const {
+    db,
+    tables: { workspaceOutputs: outputs2, workspaces: workspaces3 }
+  } = context;
   return {
     async appendOutput(input) {
       return db.transaction(async (tx) => {
+        await requireContentWritable(tx, context.tables, input.workspaceId);
         await lock(tx, input.workspaceId, 7081);
         const [latest] = await tx.select({ seq: sql`coalesce(max(${outputs2.seq}),0)`.mapWith(Number) }).from(outputs2).where(eq(outputs2.workspaceId, input.workspaceId));
         const row = { ...input, seq: requiredRow(latest).seq + 1 };
@@ -37997,7 +38173,7 @@ function createCheckpoints({ db, tables: { workspaceCheckpoints: checkpoints } }
 function createOperations({
   db,
   schema,
-  tables: { workspaceOperations: operations, workspaceCheckpoints: checkpoints }
+  tables: { workspaceOperations: operations, workspaceCheckpoints: checkpoints, workspaces: workspaces3 }
 }) {
   const incomplete = inArray(operations.state, ["pending", "running"]);
   async function countIncomplete(tx = db) {
@@ -38011,6 +38187,15 @@ function createOperations({
         const [existing] = await tx.select().from(operations).where(and(eq(operations.principalId, input.principalId), eq(operations.kind, input.kind), eq(operations.idempotencyKey, input.idempotencyKey)));
         if (existing)
           return { operation: existing, created: false, conflict: existing.requestDigest !== input.requestDigest };
+        if (input.workspaceId) {
+          const [workspace] = await tx.select().from(workspaces3).where(eq(workspaces3.id, input.workspaceId)).for("update");
+          if (workspace?.purgeRequestedAt && input.kind !== "purge") {
+            throw new ApiError("operation.conflict", "Workspace content is being purged.");
+          }
+          if (input.kind === "purge") {
+            await tx.update(workspaces3).set({ purgeRequestedAt: workspace?.purgeRequestedAt ?? input.createdAt }).where(eq(workspaces3.id, input.workspaceId));
+          }
+        }
         if (options.maxIncompleteOperations !== undefined && await countIncomplete(tx) >= options.maxIncompleteOperations)
           throw new OperationCapacityExceededError;
         const [row] = await tx.insert(operations).values(input).returning();
@@ -38129,6 +38314,152 @@ function createTerminals({ db, tables: { workspaceTerminalSessions: sessions } }
 
 // ../db/src/modules/workspaces/events.ts
 import { randomUUID as randomUUID8 } from "crypto";
+// ../auth/src/index.ts
+import { createHmac, randomBytes, randomUUID as randomUUID5, timingSafeEqual } from "crypto";
+var KEY_PREFIX = "pkt";
+function issueMachineKey(pepper) {
+  const id = randomUUID5();
+  const secret = randomBytes(32).toString("base64url");
+  return {
+    id,
+    token: `${KEY_PREFIX}_${id}_${secret}`,
+    secretDigest: digestSecret(pepper, id, secret)
+  };
+}
+var KEY_RE = /^pkt_([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})_([A-Za-z0-9_-]+)$/;
+function parseMachineKey(token) {
+  const match = KEY_RE.exec(token);
+  if (!match) {
+    return null;
+  }
+  return { id: match[1], secret: match[2] };
+}
+function digestSecret(pepper, keyId, secret) {
+  return new Uint8Array(createHmac("sha256", pepper).update(`${keyId}:${secret}`).digest());
+}
+function verifySecret(pepper, keyId, secret, storedDigest) {
+  const computed = digestSecret(pepper, keyId, secret);
+  if (computed.length !== storedDigest.length) {
+    return false;
+  }
+  return timingSafeEqual(computed, storedDigest);
+}
+function generateOpaqueSecret() {
+  return randomBytes(32).toString("base64url");
+}
+function digestOpaque(pepper, secret) {
+  return new Uint8Array(createHmac("sha256", pepper).update(secret).digest());
+}
+function verifyOpaque(pepper, secret, storedDigest) {
+  const computed = digestOpaque(pepper, secret);
+  if (computed.length !== storedDigest.length) {
+    return false;
+  }
+  return timingSafeEqual(computed, storedDigest);
+}
+function signEvent(signingKey, timestamp4, body) {
+  const mac3 = createHmac("sha256", signingKey).update(`${timestamp4}.${body}`).digest("hex");
+  return `sha256=${mac3}`;
+}
+var EGRESS_TOKEN_PREFIX = "pce1";
+var EGRESS_TOKEN_DOMAIN = "pocketcoder-egress-audit-v1\x00";
+function issueEgressAuditToken(signingKey, subject) {
+  const payload = Buffer.from(JSON.stringify({
+    v: 1,
+    aud: "egress-audit",
+    kind: subject.kind,
+    id: subject.id,
+    exp: subject.expiresAt.getTime()
+  })).toString("base64url");
+  const signature = createHmac("sha256", signingKey).update(`${EGRESS_TOKEN_DOMAIN}${payload}`).digest("base64url");
+  return `${EGRESS_TOKEN_PREFIX}.${payload}.${signature}`;
+}
+function verifyEgressAuditToken(signingKey, token, now = new Date) {
+  const [prefix, payload, signature, extra] = token.split(".");
+  if (prefix !== EGRESS_TOKEN_PREFIX || !payload || !signature || extra)
+    return null;
+  const expected = createHmac("sha256", signingKey).update(`${EGRESS_TOKEN_DOMAIN}${payload}`).digest("base64url");
+  const actualBytes = Buffer.from(signature);
+  const expectedBytes = Buffer.from(expected);
+  if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) {
+    return null;
+  }
+  try {
+    const value = JSON.parse(Buffer.from(payload, "base64url").toString());
+    if (value.v !== 1 || value.aud !== "egress-audit" || value.kind !== "workspace" && value.kind !== "pool" || typeof value.id !== "string" || !value.id || typeof value.exp !== "number" || value.exp <= now.getTime()) {
+      return null;
+    }
+    return { kind: value.kind, id: value.id };
+  } catch {
+    return null;
+  }
+}
+var REDACT_PATTERNS = [/pkt_[0-9a-f-]{36}_[A-Za-z0-9_-]+/g, /(authorization:?\s*bearer\s+)\S+/gi];
+function redact(text6) {
+  let out = text6;
+  for (const pattern of REDACT_PATTERNS) {
+    out = out.replace(pattern, "[redacted]");
+  }
+  return out;
+}
+
+// ../runtime-core/src/keys/key-administration.ts
+function keyResource(key, principal) {
+  const scopes = key.scopes.length ? key.scopes : principal.scopes;
+  return {
+    id: key.id,
+    principal_id: key.principalId,
+    scopes: key.scopes,
+    effective_scopes: scopes.filter((scope) => principal.scopes.includes("admin") || principal.scopes.includes(scope)),
+    managed_principal_ids: key.managedPrincipalIds,
+    issuance_request_id: key.issuanceRequestId,
+    created_at: key.createdAt.toISOString(),
+    expires_at: key.expiresAt?.toISOString() ?? null,
+    revoked_at: key.revokedAt?.toISOString() ?? null,
+    last_used_at: key.lastUsedAt?.toISOString() ?? null
+  };
+}
+async function issuePrincipalKey(store, pepper, principal, request, options = {}) {
+  const scopes = [...new Set(request.scopes)].sort();
+  const managedPrincipalIds = [...new Set(options.managedPrincipalIds ?? [])].sort();
+  if (scopes.some((scope) => !(principal.scopes.includes("admin") || principal.scopes.includes(scope)))) {
+    throw new ApiError("auth.missing_scope", "Key scopes exceed the principal's authority.");
+  }
+  if (!options.operatorBootstrap && scopes.some((scope) => ["admin", "keys:read", "keys:write", "workspaces:recover"].includes(scope))) {
+    throw new ApiError("auth.missing_scope", "Delegated issuance cannot grant administrative authority.");
+  }
+  const expiresAt = request.expires_at ? new Date(request.expires_at) : null;
+  if (!expiresAt && !options.operatorBootstrap || expiresAt && !Number.isFinite(expiresAt.getTime()))
+    throw new ApiError("validation.invalid", "Invalid key expiry.");
+  if (managedPrincipalIds.length && (!options.operatorBootstrap || !principal.scopes.includes("admin"))) {
+    throw new ApiError("auth.missing_scope", "Only an operator can bootstrap delegated authority.");
+  }
+  const generated = issueMachineKey(pepper);
+  const result = await store.issueMachineKey({
+    id: generated.id,
+    secretDigest: generated.secretDigest,
+    principalId: principal.id,
+    scopes,
+    managedPrincipalIds,
+    issuanceRequestId: request.request_id,
+    issuanceRequestDigest: digestOf({
+      scopes,
+      expires_at: expiresAt?.toISOString() ?? null,
+      managed_principal_ids: managedPrincipalIds
+    }),
+    createdAt: new Date,
+    expiresAt,
+    revokedAt: null,
+    lastUsedAt: null
+  });
+  if (result.conflict)
+    throw new ApiError("idempotency.conflict", "Changed key issuance request.");
+  return {
+    created: result.created,
+    key: keyResource(result.key, principal),
+    token: result.created ? generated.token : null
+  };
+}
 // ../runtime-core/src/observability/metrics.ts
 function metricKey(name2, labels = {}) {
   const entries = Object.entries(labels).sort(([left2], [right2]) => left2.localeCompare(right2));
@@ -38224,6 +38555,25 @@ class OutboxDispatcher {
     await this.deps.store.markEventFailed(id, errorCode, new Date(this.now().getTime() + backoff));
   }
 }
+// ../runtime-core/src/scheduler/provider-termination.ts
+async function stopWorkspaceProvider(store, driver, workspace, graceSeconds, at, remove = true) {
+  if (!workspace.providerRef)
+    return;
+  const ref = { kind: workspace.providerKind ?? "", id: "", ...workspace.providerRef };
+  await driver.stop(ref, graceSeconds);
+  const evidence = await driver.terminationEvidence?.(ref);
+  if (evidence) {
+    const current = await store.getWorkspace(workspace.id);
+    if (!current?.providerRef || current.providerRef.id !== workspace.providerRef.id)
+      throw new Error("Termination provider changed");
+    await store.updateWorkspace(workspace.id, {
+      providerRef: { ...current.providerRef, terminationEvidence: evidence }
+    }, at);
+  }
+  if (remove)
+    await driver.remove(ref);
+}
+
 // ../runtime-core/src/reconciliation/reconciliation-metrics.ts
 async function measureReconciliation(metrics, kind, skipped, reconcile) {
   const startedAt = performance.now();
@@ -38278,8 +38628,7 @@ async function reconcileDeletion(deps, operation, checkpoint, now) {
 async function cleanupProvider(deps, workspace) {
   if (!workspace?.providerRef)
     return;
-  await deps.driver.stop(workspace.providerRef, 1).catch(() => {});
-  await deps.driver.remove(workspace.providerRef).catch(() => {});
+  await stopWorkspaceProvider(deps.store, deps.driver, workspace, 1, deps.now?.() ?? new Date);
 }
 async function completePreserve(deps, operation, checkpoint, workspace, now) {
   await cleanupProvider(deps, workspace);
@@ -38314,13 +38663,26 @@ async function failPreserve(deps, operation, context, now) {
   }
   await failOperation(deps, operation, "checkpoint_failed", now);
 }
+async function reconcileRestore(deps, operation, now) {
+  const target = operation.resultWorkspaceId ? await deps.store.getWorkspace(operation.resultWorkspaceId) : await deps.store.getWorkspaceByIdempotency(operation.principalId, `restore:${operation.id}`);
+  if (!target) {
+    await failOperation(deps, operation, "restore_failed", now);
+    return;
+  }
+  if (!operation.resultWorkspaceId) {
+    await deps.store.updateOperation(operation.id, { resultWorkspaceId: target.id }, now);
+  }
+  if (isTerminal(target.state))
+    await failOperation(deps, operation, "restore_failed", now);
+}
 async function reconcileOperation(deps, operation, now) {
-  const context = await loadOperationContext(deps, operation);
+  if (operation.kind === "purge")
+    return;
   if (operation.kind === "restore") {
-    if (!context.workspace)
-      await failOperation(deps, operation, "restore_failed", now);
+    await reconcileRestore(deps, operation, now);
     return;
   }
+  const context = await loadOperationContext(deps, operation);
   if (!context.checkpoint) {
     await failOperation(deps, operation, "checkpoint_storage_lost", now);
     return;
@@ -38372,22 +38734,13 @@ async function reconcilePersistence(deps) {
 }
 // ../runtime-core/src/reconciliation/reconcile.ts
 async function reconcileProviderRow(deps, row, found, now) {
-  if (row.state === "queued")
+  if (row.state === "queued" || row.state === "terminating")
     return;
   const mismatched = found && found.templateDigest !== row.templateDigest;
   if (mismatched) {
     deps.log?.(`reconcile: template digest mismatch for ${row.id}; failing workspace`);
   }
   const lost = !found || mismatched;
-  if (lost && row.state === "terminating") {
-    await deps.store.transition(row.id, {
-      from: ["terminating"],
-      to: row.terminalIntent ?? "failed",
-      reason: row.reasonCode ?? "provider_lost",
-      at: now
-    });
-    return;
-  }
   if (lost && (row.state === "connected" || row.state === "ready")) {
     await settleLostStorage(deps, row, now);
     await deps.store.transition(row.id, {
@@ -38510,95 +38863,6 @@ async function loadTemplateDir(store, dir) {
   }
   return result;
 }
-// ../auth/src/index.ts
-import { createHmac, randomBytes, randomUUID as randomUUID5, timingSafeEqual } from "crypto";
-var KEY_PREFIX = "pkt";
-function issueMachineKey(pepper) {
-  const id = randomUUID5();
-  const secret = randomBytes(32).toString("base64url");
-  return {
-    id,
-    token: `${KEY_PREFIX}_${id}_${secret}`,
-    secretDigest: digestSecret(pepper, id, secret)
-  };
-}
-var KEY_RE = /^pkt_([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})_([A-Za-z0-9_-]+)$/;
-function parseMachineKey(token) {
-  const match = KEY_RE.exec(token);
-  if (!match) {
-    return null;
-  }
-  return { id: match[1], secret: match[2] };
-}
-function digestSecret(pepper, keyId, secret) {
-  return new Uint8Array(createHmac("sha256", pepper).update(`${keyId}:${secret}`).digest());
-}
-function verifySecret(pepper, keyId, secret, storedDigest) {
-  const computed = digestSecret(pepper, keyId, secret);
-  if (computed.length !== storedDigest.length) {
-    return false;
-  }
-  return timingSafeEqual(computed, storedDigest);
-}
-function generateOpaqueSecret() {
-  return randomBytes(32).toString("base64url");
-}
-function digestOpaque(pepper, secret) {
-  return new Uint8Array(createHmac("sha256", pepper).update(secret).digest());
-}
-function verifyOpaque(pepper, secret, storedDigest) {
-  const computed = digestOpaque(pepper, secret);
-  if (computed.length !== storedDigest.length) {
-    return false;
-  }
-  return timingSafeEqual(computed, storedDigest);
-}
-function signEvent(signingKey, timestamp4, body) {
-  const mac3 = createHmac("sha256", signingKey).update(`${timestamp4}.${body}`).digest("hex");
-  return `sha256=${mac3}`;
-}
-var EGRESS_TOKEN_PREFIX = "pce1";
-var EGRESS_TOKEN_DOMAIN = "pocketcoder-egress-audit-v1\x00";
-function issueEgressAuditToken(signingKey, subject) {
-  const payload = Buffer.from(JSON.stringify({
-    v: 1,
-    aud: "egress-audit",
-    kind: subject.kind,
-    id: subject.id,
-    exp: subject.expiresAt.getTime()
-  })).toString("base64url");
-  const signature = createHmac("sha256", signingKey).update(`${EGRESS_TOKEN_DOMAIN}${payload}`).digest("base64url");
-  return `${EGRESS_TOKEN_PREFIX}.${payload}.${signature}`;
-}
-function verifyEgressAuditToken(signingKey, token, now = new Date) {
-  const [prefix, payload, signature, extra] = token.split(".");
-  if (prefix !== EGRESS_TOKEN_PREFIX || !payload || !signature || extra)
-    return null;
-  const expected = createHmac("sha256", signingKey).update(`${EGRESS_TOKEN_DOMAIN}${payload}`).digest("base64url");
-  const actualBytes = Buffer.from(signature);
-  const expectedBytes = Buffer.from(expected);
-  if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) {
-    return null;
-  }
-  try {
-    const value = JSON.parse(Buffer.from(payload, "base64url").toString());
-    if (value.v !== 1 || value.aud !== "egress-audit" || value.kind !== "workspace" && value.kind !== "pool" || typeof value.id !== "string" || !value.id || typeof value.exp !== "number" || value.exp <= now.getTime()) {
-      return null;
-    }
-    return { kind: value.kind, id: value.id };
-  } catch {
-    return null;
-  }
-}
-var REDACT_PATTERNS = [/pkt_[0-9a-f-]{36}_[A-Za-z0-9_-]+/g, /(authorization:?\s*bearer\s+)\S+/gi];
-function redact(text6) {
-  let out = text6;
-  for (const pattern of REDACT_PATTERNS) {
-    out = out.replace(pattern, "[redacted]");
-  }
-  return out;
-}
-
 // ../runtime-core/src/scheduler/scheduler-base.ts
 var FAILURE_LOG_TAIL_BYTES = 16 * 1024;
 function decodeFailureLogTail(content, truncated) {
@@ -38785,8 +39049,20 @@ class SchedulerAdmission {
         return;
     }
   }
+  async authorized(row) {
+    if (!this.context.deps.authorizeLaunch)
+      return true;
+    try {
+      return await this.context.deps.authorizeLaunch(row) === true;
+    } catch {
+      this.context.report(`admit.policy.${row.id}`, new Error("Launch policy unavailable"));
+      return false;
+    }
+  }
   async launch(row) {
     const { store, driver, secrets } = this.context.deps;
+    if (!await this.authorized(row))
+      return false;
     const now = this.context.now();
     const secret = secrets.generate();
     const registrationDigest = secrets.digest(secret);
@@ -38951,24 +39227,28 @@ class SchedulerLifecycle {
       connections.signal(row.id, "TERM");
     }
     if (updated.providerRef) {
-      this.stopAndRemove({ kind: updated.providerKind ?? "", id: "", ...updated.providerRef }, this.context.graceSeconds(updated)).then(() => this.finalize(updated, terminalState, reason, this.context.now())).catch((err) => this.context.report(`terminate.${row.id}`, err));
+      this.finalize(updated, terminalState, reason, this.context.now()).catch((err) => this.context.report(`terminate.${row.id}`, err));
     } else {
       await this.finalize(updated, terminalState, reason, at);
     }
     return updated;
   }
-  async finalize(row, terminalState, reason, at, retainStorage = false) {
+  async finalize(row, terminalState, reason, at) {
     const { store, driver, connections } = this.context.deps;
+    const retainStorage = terminalState === "failed" && row.templateSnapshot.spec.persistence.checkpoint.onFailure === "retain-for-recovery";
     if (row.providerRef) {
       try {
-        await driver.stop({ kind: row.providerKind ?? "", id: "", ...row.providerRef }, this.context.graceSeconds(row));
-        await driver.remove({
-          kind: row.providerKind ?? "",
-          id: "",
-          ...row.providerRef
-        });
+        await stopWorkspaceProvider(store, driver, row, this.context.graceSeconds(row), at);
       } catch (err) {
         this.context.report(`finalize.terminate.${row.id}`, err);
+        await store.transition(row.id, {
+          from: ["provisioning", "connected", "ready"],
+          to: "terminating",
+          reason,
+          at,
+          patch: { terminalIntent: terminalState, registrationDigest: null }
+        });
+        return;
       }
     }
     if (retainStorage) {
@@ -39008,16 +39288,12 @@ class SchedulerLifecycle {
       }
     });
   }
-  async stopAndRemove(ref, graceSeconds) {
-    await this.context.deps.driver.stop(ref, graceSeconds);
-    await this.context.deps.driver.remove(ref);
-  }
   async fail(row, reason, at) {
     const action = row.templateSnapshot.spec.persistence.checkpoint.onFailure;
     if (action === "preserve" && ["connected", "ready"].includes(row.state) && await this.requestPolicyPreserve(row, "failure")) {
       return;
     }
-    await this.finalize(row, "failed", reason, at, action === "retain-for-recovery");
+    await this.finalize(row, "failed", reason, at);
   }
   async handleProcessExit(row, exitCode, at) {
     if (exitCode === 0 && row.templateSnapshot.spec.persistence.checkpoint.onCleanExit === "preserve" && await this.requestPolicyPreserve(row, "clean_exit")) {
@@ -39062,6 +39338,8 @@ class SchedulerSweep {
     for (const row of rows) {
       try {
         await this.sweepRow(row, now);
+        if (row.providerRef)
+          await this.context.deps.driver.inspect(row.providerRef);
       } catch (err) {
         this.context.report(`sweep.${row.id}`, err);
       }
@@ -39109,9 +39387,12 @@ class SchedulerSweep {
   }
   async sweepTerminating(row, now) {
     const stuckMs = 4 * this.context.timeoutMs(row, "terminateGrace") + 5000;
-    if (now.getTime() - row.updatedAt.getTime() <= stuckMs)
+    const history = await this.context.deps.store.listStateHistory(row.id);
+    const termination = history.find((entry) => entry.toState === "terminating");
+    if (!termination || now.getTime() - termination.occurredAt.getTime() <= stuckMs)
       return;
-    await this.lifecycle.finalize(row, row.terminalIntent ?? "failed", row.reasonCode, now);
+    const terminalState = row.terminalIntent ?? "failed";
+    await this.lifecycle.finalize(row, terminalState, row.reasonCode, now);
   }
   async sweepRow(row, now) {
     switch (row.state) {
@@ -39122,8 +39403,8 @@ class SchedulerSweep {
         if (row.registrationExpiresAt && now >= row.registrationExpiresAt) {
           if (row.provisioningMode === "warm" && row.launchAttempts < this.context.deps.limits.maxLaunchAttempts) {
             if (row.providerRef) {
-              await this.context.deps.driver.stop(row.providerRef, 1).catch(() => {});
-              await this.context.deps.driver.remove(row.providerRef).catch(() => {});
+              await this.context.deps.driver.stop(row.providerRef, 1);
+              await this.context.deps.driver.remove(row.providerRef);
             }
             await this.context.deps.store.transition(row.id, {
               from: ["provisioning"],
@@ -39181,6 +39462,9 @@ class Scheduler {
     });
     return this.context.activeTick;
   }
+  async drain() {
+    await this.context.activeTick;
+  }
   async runTick() {
     await this.sweeper.sweep();
     await this.admission.admit();
@@ -39476,6 +39760,8 @@ async function appendTransition(context, tx, row, from, reason, at) {
     reasonCode: reason,
     occurredAt: at
   });
+  if (row.purgeRequestedAt)
+    return;
   const payload = buildEventEnvelope(row, at);
   await tx.insert(context.tables.eventOutbox).values({
     id: payload.id,
@@ -39520,7 +39806,7 @@ function createWarmPools(context) {
     async claimWarmPoolRuntime(claim) {
       const result = await db.transaction(async (tx) => {
         const [current] = await tx.select().from(workspaces3).where(eq(workspaces3.id, claim.workspaceId)).for("update");
-        if (current?.state !== "queued")
+        if (current?.state !== "queued" || current.purgeRequestedAt)
           return null;
         const [runtime] = await tx.select().from(runtimes).where(and(eq(runtimes.templateDigest, claim.templateDigest), eq(runtimes.driverKind, claim.driverKind), eq(runtimes.eligibilityFingerprint, claim.eligibilityFingerprint), eq(runtimes.state, "ready"), isNotNull(runtimes.providerRef))).orderBy(asc2(runtimes.readyAt)).limit(1).for("update", { skipLocked: true });
         if (!runtime)
@@ -39586,7 +39872,7 @@ function createAdmission(context) {
       const workspace = await db.transaction(async (tx) => {
         await lock(tx, `${schema}:workspace-admission`, 7351);
         const [current] = await tx.select().from(workspaces3).where(eq(workspaces3.id, claim.workspaceId)).for("update");
-        if (current?.state !== "queued")
+        if (current?.state !== "queued" || current.purgeRequestedAt)
           return null;
         const counts = await countActive(tx);
         if (counts.global >= claim.limits.globalActiveWorkspaces)
@@ -39706,7 +39992,15 @@ function createTransitions(context) {
   return {
     async updateWorkspace(id, patch, at) {
       const bumpsChange = Object.keys(patch).some((key) => CHANGE_PATCH_KEYS.has(key));
-      await db.update(workspaces3).set({ ...patch, updatedAt: at, ...bumpsChange ? { changeSeq: sql`${workspaces3.changeSeq}+1` } : {} }).where(eq(workspaces3.id, id));
+      await db.transaction(async (tx) => {
+        const [current] = await tx.select().from(workspaces3).where(eq(workspaces3.id, id)).for("update");
+        await tx.update(workspaces3).set({
+          ...patch,
+          ...current?.purgeRequestedAt ? purgedContentPatch() : {},
+          updatedAt: at,
+          ...bumpsChange ? { changeSeq: sql`${workspaces3.changeSeq}+1` } : {}
+        }).where(eq(workspaces3.id, id));
+      });
       if (bumpsChange)
         notifyChange(context, id);
     },
@@ -39715,9 +40009,12 @@ function createTransitions(context) {
         const [current] = await tx.select().from(workspaces3).where(eq(workspaces3.id, id)).for("update");
         if (!current || !req.from.includes(current.state) || !canTransition(current.state, req.to))
           return null;
+        if (current.purgeRequestedAt && ["provisioning", "connected", "ready", "preserving", "queued"].includes(req.to))
+          return null;
         const terminal = isTerminal(req.to);
         const [row] = await tx.update(workspaces3).set({
           ...req.patch,
+          ...current.purgeRequestedAt ? purgedContentPatch() : {},
           state: req.to,
           reasonCode: req.reason,
           updatedAt: req.at,
@@ -39748,9 +40045,12 @@ function createTransitions(context) {
 
 // ../db/src/store.ts
 class PostgresStore {
-  constructor(databaseUrl, schema = "pocketcoder") {
-    const context = createDatabaseContext(databaseUrl, schema);
+  constructor(databaseUrl, schema = "pocketcoder", options = {}) {
+    const context = createDatabaseContext(databaseUrl, schema, options);
     const lifecycle2 = createLifecycle(context);
+    const content = createContentPurge(context);
+    this.listWorkspaceStorage = content.listWorkspaceStorage;
+    this.purgeWorkspaceContent = content.purgeWorkspaceContent;
     this.init = lifecycle2.init;
     this.close = lifecycle2.close;
     this.acquireCoordinatorLease = lifecycle2.acquireCoordinatorLease;
@@ -39765,6 +40065,10 @@ class PostgresStore {
     this.listPrincipals = auth2.listPrincipals;
     this.updatePrincipal = auth2.updatePrincipal;
     this.setPrincipalDisabled = auth2.setPrincipalDisabled;
+    this.getPrincipal = auth2.getPrincipal;
+    this.issueMachineKey = auth2.issueMachineKey;
+    this.listMachineKeys = auth2.listMachineKeys;
+    this.revokePrincipalKeys = auth2.revokePrincipalKeys;
     this.insertMachineKey = auth2.insertMachineKey;
     this.getMachineKeyWithPrincipal = auth2.getMachineKeyWithPrincipal;
     this.revokeMachineKey = auth2.revokeMachineKey;
@@ -39837,6 +40141,8 @@ class PostgresStore {
     this.appendEvent = outbox2.appendEvent;
     this.waitForWorkspaceChange = createWorkspaceWaiter(context, workspaces3.getWorkspace);
   }
+  listWorkspaceStorage;
+  purgeWorkspaceContent;
   init;
   close;
   acquireCoordinatorLease;
@@ -39849,6 +40155,10 @@ class PostgresStore {
   listPrincipals;
   updatePrincipal;
   setPrincipalDisabled;
+  getPrincipal;
+  issueMachineKey;
+  listMachineKeys;
+  revokePrincipalKeys;
   insertMachineKey;
   getMachineKeyWithPrincipal;
   revokeMachineKey;
@@ -40174,6 +40484,51 @@ class OutputsApi extends WorkspaceCursorApi {
   }
 }
 
+// ../sdk/src/resources/keys/keys.ts
+class KeysApi {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  list(principalId, query = {}, options = {}) {
+    return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys?${queryString({ limit: query.limit, cursor: query.cursor, request_id: query.requestId })}`, KeyListResponseSchema, options);
+  }
+  async* all(principalId, query = {}, options = {}) {
+    let cursor;
+    do {
+      const page2 = await this.list(principalId, { ...query, cursor }, options);
+      yield* page2.items;
+      cursor = page2.next_cursor ?? undefined;
+    } while (cursor);
+  }
+  issue(principalId, input, options = {}) {
+    return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys`, KeyIssueResponseSchema, {
+      method: "POST",
+      body: JSON.stringify(input),
+      signal: options.signal
+    });
+  }
+  revoke(principalId, keyId, options = {}) {
+    return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys/${encodeURIComponent(keyId)}`, exports_external.object({ revoked: exports_external.literal(true) }), { method: "DELETE", signal: options.signal });
+  }
+  revokeAll(principalId, options = {}) {
+    return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys`, exports_external.object({ revoked: exports_external.literal(true) }), { method: "DELETE", signal: options.signal });
+  }
+}
+
+class RecoveryApi {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  purge(principalId, workspaceId, executionKey, options = {}) {
+    return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/workspaces/${encodeURIComponent(workspaceId)}/purge`, OperationResourceSchema, { method: "POST", headers: { "Idempotency-Key": executionKey }, body: "{}", signal: options.signal });
+  }
+  operation(principalId, operationId, options = {}) {
+    return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/operations/${encodeURIComponent(operationId)}`, OperationResourceSchema, options);
+  }
+}
+
 // ../sdk/src/resources/templates/templates.ts
 class TemplatesApi {
   transport;
@@ -40383,6 +40738,9 @@ class WorkspacesApi {
   preserve(id, input, key, options = {}) {
     return this.jsonOperation(`/v1/workspaces/${encodeURIComponent(id)}/preserve`, input, key, PreserveResponseSchema, options);
   }
+  purge(id, key, options = {}) {
+    return this.jsonOperation(`/v1/workspaces/${encodeURIComponent(id)}/purge`, {}, key, OperationResourceSchema, options);
+  }
   recreate(id, input, key, options = {}) {
     return this.jsonOperation(`/v1/workspaces/${encodeURIComponent(id)}/recreate`, input, key, RestoreResponseSchema, options);
   }
@@ -40544,6 +40902,8 @@ class PocketCoderClient {
   outputs;
   administration;
   terminals;
+  keys;
+  recovery;
   constructor(config2, fetchImpl = fetch) {
     this.transport = new PocketCoderTransport(config2, fetchImpl);
     this.templates = new TemplatesApi(this.transport);
@@ -40558,6 +40918,8 @@ class PocketCoderClient {
     this.outputs = new OutputsApi(this.transport);
     this.administration = new AdministrationApi(this.transport);
     this.terminals = new TerminalsApi(this.transport);
+    this.keys = new KeysApi(this.transport);
+    this.recovery = new RecoveryApi(this.transport);
   }
   raw(path, init = {}) {
     return this.transport.raw(path, init);
@@ -40803,7 +41165,7 @@ async function api2(path, init = {}) {
 }
 async function withStore(fn) {
   const { url: url2, schema } = dbConfig();
-  const store = new PostgresStore(url2, schema);
+  const store = new PostgresStore(url2, schema, { max: 1 });
   try {
     return await fn(store);
   } finally {
@@ -41062,66 +41424,103 @@ async function printFailureTail(workspaceId) {
   } catch {}
 }
 
+// src/commands/keys/issue.ts
+import { randomUUID as randomUUID11 } from "crypto";
+
 // src/commands/scopes.ts
 function parseScopes(value) {
-  const items = valueList(value);
-  for (const item of items)
+  return valueList(value).map((item) => {
     if (!isScope(item))
       fail(`unknown scope: ${item}`);
-  return items;
+    return item;
+  });
 }
 
 // src/commands/keys/issue.ts
 function addIssueCommand(parser2) {
-  return addAction(parser2, "issue", "Issue a machine key", (command2) => command2.option("principal", {
-    type: "string",
-    demandOption: true,
-    description: "Principal name"
-  }).option("scopes", {
+  return addAction(parser2, "issue", "Issue or reconcile a machine key", (command2) => command2.option("principal", { type: "string", description: "Principal name for local operator bootstrap" }).option("principal-id", { type: "string", description: "Target principal ID through the public API" }).option("request-id", {
     type: "string",
-    description: "Comma-separated scopes; defaults to the principal scopes"
-  }).option("expires", {
+    description: "Persist this identity before issuance to reconcile a lost response"
+  }).option("scopes", { type: "string", description: "Comma-separated restricted scopes" }).option("expires", {
     type: "string",
     default: "never",
-    description: "Expiration as ISO 8601, or never"
+    description: "ISO 8601 expiry; never is local operator only"
+  }).option("manage-principals", {
+    type: "string",
+    description: "Explicit target UUIDs for local operator bootstrap"
+  }).option("json", {
+    type: "boolean",
+    default: false,
+    description: "Print key metadata and one-time token as JSON"
+  }).conflicts("principal", "principal-id").implies("principal-id", "request-id").check((flags) => {
+    if (!flags.principal && !flags["principal-id"])
+      throw new Error("Missing required argument: principal or principal-id");
+    return true;
   }), async (flags) => {
+    const expires = need(flags, "expires");
+    const expiresAt = expires === "never" ? null : expires;
+    const scopes = typeof flags.scopes === "string" ? parseScopes(flags.scopes) : [];
+    const requestId = typeof flags["request-id"] === "string" ? flags["request-id"] : randomUUID11();
+    if (typeof flags["principal-id"] === "string") {
+      if (!expiresAt)
+        fail("public key issuance requires --expires <ISO8601>");
+      if (flags["manage-principals"])
+        fail("delegated grants require local operator bootstrap");
+      const result = await controlPlaneClient().keys.issue(flags["principal-id"], {
+        request_id: requestId,
+        scopes,
+        expires_at: expiresAt
+      });
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
     const pepper = process.env.POCKETCODER_AUTH_PEPPER;
     if (!pepper)
-      fail("POCKETCODER_AUTH_PEPPER is required to issue keys");
+      fail("POCKETCODER_AUTH_PEPPER is required to issue keys locally");
     await withStore(async (store) => {
       const name2 = need(flags, "principal");
       const principal = await store.getPrincipalByName(name2);
       if (!principal)
         fail(`unknown principal: ${name2}`);
-      const expiresRaw = typeof flags.expires === "string" ? flags.expires : "never";
-      const expiresAt = expiresRaw === "never" ? null : new Date(expiresRaw);
-      if (expiresAt && Number.isNaN(expiresAt.getTime())) {
-        fail(`invalid --expires value: ${expiresRaw}`);
-      }
-      const key = issueMachineKey(pepper);
-      await store.insertMachineKey({
-        id: key.id,
-        principalId: principal.id,
-        secretDigest: key.secretDigest,
-        scopes: typeof flags.scopes === "string" ? parseScopes(flags.scopes) : [],
-        createdAt: new Date,
-        expiresAt,
-        revokedAt: null,
-        lastUsedAt: null
-      });
-      console.log("machine key (shown once, store it now):");
-      console.log(key.token);
+      const managedPrincipalIds = typeof flags["manage-principals"] === "string" ? valueList(flags["manage-principals"]) : [];
+      for (const id of managedPrincipalIds) {
+        if (!/^[0-9a-f-]{36}$/i.test(id) || !await store.getPrincipal(id))
+          fail("unknown managed principal ID");
+      }
+      const result = await issuePrincipalKey(store, pepper, principal, { request_id: requestId, scopes, expires_at: expiresAt }, { managedPrincipalIds, operatorBootstrap: true });
+      if (flags.json || !result.token)
+        console.log(JSON.stringify({ key: result.key, token: result.token }, null, 2));
+      else {
+        console.log(`machine key (shown once; request ${requestId}):`);
+        console.log(result.token);
+      }
     });
   });
 }
 
+// src/commands/keys/list.ts
+function addListCommand2(parser2) {
+  return addAction(parser2, "list", "List authoritative key metadata through the public API", (command2) => command2.option("principal-id", { type: "string", demandOption: true }).option("request-id", { type: "string", description: "Reconcile an issuance request" }).option("cursor", { type: "string" }).option("limit", { type: "number", default: 50 }), async (flags) => {
+    const result = await controlPlaneClient().keys.list(need(flags, "principal-id"), {
+      limit: Number(flags.limit),
+      ...typeof flags.cursor === "string" ? { cursor: flags.cursor } : {},
+      ...typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+}
+
 // src/commands/keys/revoke.ts
 function addRevokeCommand(parser2) {
-  return addAction(parser2, "revoke", "Revoke a machine key", (command2) => command2.option("id", {
+  return addAction(parser2, "revoke", "Revoke a machine key", (command2) => command2.option("principal-id", { type: "string", description: "Target principal ID through the public API" }).option("id", {
     type: "string",
     demandOption: true,
     description: "Machine key ID"
   }), async (flags) => {
+    if (typeof flags["principal-id"] === "string") {
+      console.log(JSON.stringify(await controlPlaneClient().keys.revoke(flags["principal-id"], need(flags, "id")), null, 2));
+      return;
+    }
     await withStore(async (store) => {
       const id = need(flags, "id");
       const revoked = await store.revokeMachineKey(id, new Date);
@@ -41130,13 +41529,20 @@ function addRevokeCommand(parser2) {
   });
 }
 
+// src/commands/keys/revoke-all.ts
+function addRevokeAllCommand(parser2) {
+  return addAction(parser2, "revoke-all", "Disable a principal and revoke every key atomically", (command2) => command2.option("principal-id", { type: "string", demandOption: true }), async (flags) => {
+    console.log(JSON.stringify(await controlPlaneClient().keys.revokeAll(need(flags, "principal-id")), null, 2));
+  });
+}
+
 // src/commands/keys/index.ts
 function addKeyCommands(parser2) {
-  return addResource(parser2, "keys", "Manage machine keys", (commands) => addRevokeCommand(addIssueCommand(commands)));
+  return addResource(parser2, "keys", "Manage machine keys", (commands) => [addIssueCommand, addListCommand2, addRevokeCommand, addRevokeAllCommand].reduce((parser3, add) => add(parser3), commands));
 }
 
 // src/commands/pools/list.ts
-function addListCommand2(parser2) {
+function addListCommand3(parser2) {
   return addAction(parser2, "list", "List warm pool inventory and metrics", (command2) => command2.option("json", { type: "boolean", description: "Print JSON" }), async (flags) => {
     const body = await controlPlaneClient().administration.warmPools();
     if (flags.json)
@@ -41153,7 +41559,7 @@ function addListCommand2(parser2) {
 
 // src/commands/pools/index.ts
 function addPoolCommands(parser2) {
-  return addResource(parser2, "pools", "Inspect operator-managed warm capacity", addListCommand2);
+  return addResource(parser2, "pools", "Inspect operator-managed warm capacity", addListCommand3);
 }
 
 // src/commands/principals/options.ts
@@ -41179,7 +41585,7 @@ function addCreateCommand(parser2) {
 }
 
 // src/commands/principals/list.ts
-function addListCommand3(parser2) {
+function addListCommand4(parser2) {
   return addAction(parser2, "list", "List principals", unchanged, async () => {
     await withStore(async (store) => {
       for (const principal of await store.listPrincipals()) {
@@ -41208,21 +41614,72 @@ function addUpdateCommand(parser2) {
 
 // src/commands/principals/index.ts
 function addPrincipalCommands(parser2) {
-  return addResource(parser2, "principals", "Manage principals", (commands) => addListCommand3(addUpdateCommand(addCreateCommand(commands))));
+  return addResource(parser2, "principals", "Manage principals", (commands) => addListCommand4(addUpdateCommand(addCreateCommand(commands))));
 }
 
 // src/commands/server/process.ts
 import { spawn, spawnSync } from "child_process";
-import { createHash as createHash4, randomUUID as randomUUID26 } from "crypto";
-import { closeSync, existsSync as existsSync4, mkdirSync, openSync, readFileSync as readFileSync4, renameSync, rmSync, writeFileSync } from "fs";
+import { createHash as createHash4, randomUUID as randomUUID28 } from "crypto";
+import { closeSync, existsSync as existsSync4, mkdirSync, openSync, readFileSync as readFileSync6, renameSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname as dirname7, join as join8, resolve as resolve11 } from "path";
 
 // ../server/src/config/config.ts
 import { randomBytes as randomBytes2 } from "crypto";
 
+// ../server/src/lifecycle/launch-policy.ts
+import { readFileSync as readFileSync4 } from "fs";
+function launchPolicyConfig(env2) {
+  const url2 = env2.POCKETCODER_LAUNCH_POLICY_URL;
+  const tokenFile = env2.POCKETCODER_LAUNCH_POLICY_TOKEN_FILE;
+  if (!url2 && !tokenFile)
+    return;
+  if (!url2 || !tokenFile)
+    throw new Error("Launch policy requires both URL and token file");
+  const parsed = new URL(url2);
+  const loopback = parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+  if (parsed.username || parsed.password || parsed.hash || parsed.search || parsed.protocol !== "https:" && !(parsed.protocol === "http:" && loopback)) {
+    throw new Error("Launch policy requires HTTPS or a loopback HTTP endpoint");
+  }
+  return { url: url2, tokenFile };
+}
+function createLaunchPolicy(url2, token) {
+  return async (workspace) => {
+    try {
+      const response = await fetch(url2, {
+        method: "POST",
+        redirect: "error",
+        signal: AbortSignal.timeout(5000),
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify({
+          workspace_id: workspace.id,
+          principal_id: workspace.principalId,
+          external_id: workspace.externalId,
+          template_name: workspace.templateName,
+          launch_mode: workspace.launchMode,
+          metadata: workspace.metadata
+        })
+      });
+      if (response.status !== 200)
+        return false;
+      const decision = await response.json();
+      return typeof decision === "object" && decision !== null && "allowed" in decision && decision.allowed === true && "workspace_id" in decision && decision.workspace_id === workspace.id;
+    } catch {
+      return false;
+    }
+  };
+}
+function loadLaunchPolicy(config2) {
+  if (!config2)
+    return;
+  const token = readFileSync4(config2.tokenFile, "utf8").trim();
+  if (token.length < 24 || /\s/.test(token))
+    throw new Error("Invalid launch policy control token");
+  return createLaunchPolicy(config2.url, token);
+}
+
 // ../server/src/persistence/persistence-base.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 var DEFAULT_PERSISTENCE_LIMITS = {
   maxRetainedBytes: 500 * 1024 ** 3,
   maxRetainedBytesPerPrincipal: 100 * 1024 ** 3,
@@ -41365,7 +41822,7 @@ class PersistenceContext {
   async emitCheckpointEvent(type, row) {
     const at = this.now();
     await this.deps.store.appendEvent(row.workspaceId, type, {
-      id: randomUUID11(),
+      id: randomUUID12(),
       type,
       occurred_at: at.toISOString(),
       checkpoint: {
@@ -41381,7 +41838,7 @@ class PersistenceContext {
   }
 }
 // ../server/src/persistence/persistence-checkpoints.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 class PersistenceCheckpointService {
   context;
   constructor(context) {
@@ -41400,7 +41857,7 @@ class PersistenceCheckpointService {
     }
     const now = this.context.now();
     const inserted = await this.context.insertOperation({
-      id: randomUUID12(),
+      id: randomUUID13(),
       principalId: principal.id,
       kind: "verify",
       state: "running",
@@ -41479,7 +41936,7 @@ class PersistenceCheckpointService {
     });
     const at = this.context.now();
     await this.context.deps.store.appendEvent(workspaceId, "workspace.output_published", {
-      id: randomUUID12(),
+      id: randomUUID13(),
       type: "workspace.output_published",
       occurred_at: at.toISOString(),
       workspace_id: workspaceId,
@@ -41490,7 +41947,7 @@ class PersistenceCheckpointService {
 }
 
 // ../server/src/persistence/persistence-maintenance.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 
 // ../server/src/persistence/persistence-cleanup.ts
 async function cleanupPreservedStorage(context, storageId) {
@@ -41624,7 +42081,7 @@ class PersistenceMaintenanceService {
     }
     const now = this.context.now();
     const inserted = await this.context.insertOperation({
-      id: randomUUID13(),
+      id: randomUUID14(),
       principalId: principal.id,
       kind: "delete",
       state: "running",
@@ -41666,7 +42123,7 @@ class PersistenceMaintenanceService {
 }
 
 // ../server/src/persistence/persistence-preserve.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 class PreservePersistenceService {
   context;
   preserveRunner;
@@ -41692,8 +42149,8 @@ class PreservePersistenceService {
       throw new ApiError("validation.invalid", "retention may not exceed the template checkpoint policy");
     }
     this.context.storageDriver();
-    const checkpointId = randomUUID14();
-    const operationId = randomUUID14();
+    const checkpointId = randomUUID15();
+    const operationId = randomUUID15();
     const now = this.context.now();
     const operationResult = await this.context.insertOperation({
       id: operationId,
@@ -41809,11 +42266,7 @@ class PersistencePreserveRunner {
     const quiesced = native || hook ? await this.context.deps.hub.prepareCheckpoint(workspace.id, operationId, deadlineMs) : false;
     if (!workspace.providerRef)
       return quiesced;
-    await this.context.deps.driver.stop({
-      kind: workspace.providerKind ?? "",
-      id: "",
-      ...workspace.providerRef
-    }, Math.max(1, Math.ceil(parseDurationMs(workspace.templateSnapshot.spec.timeouts.terminateGrace) / 1000)));
+    await stopWorkspaceProvider(this.context.deps.store, this.context.deps.driver, workspace, Math.max(1, Math.ceil(parseDurationMs(workspace.templateSnapshot.spec.timeouts.terminateGrace) / 1000)), this.context.now(), false);
     return quiesced;
   }
   async createSnapshot(workspace, checkpoint, storage) {
@@ -41922,11 +42375,211 @@ class PersistencePreserveRunner {
   }
 }
 
-// ../server/src/persistence/persistence-restore.ts
+// ../server/src/persistence/persistence-purge.ts
 import { randomUUID as randomUUID16 } from "crypto";
 
+// ../server/src/persistence/purge-storage.ts
+class PurgeOwnershipError extends Error {
+}
+function storageTargets(workspace, allocations, physical) {
+  const ids = new Set(allocations.map((row) => row.id));
+  if (physical.some((row) => row.workspaceId === workspace.id && !ids.has(row.storageId))) {
+    throw new PurgeOwnershipError("Unrecorded workspace allocation");
+  }
+  return allocations.map((allocation) => {
+    const found = physical.find((row) => row.storageId === allocation.id);
+    if (allocation.principalId !== workspace.principalId || allocation.state === "quarantined" || found?.workspaceId && found.workspaceId !== workspace.id) {
+      throw new PurgeOwnershipError("Storage ownership is unresolved");
+    }
+    const ref = Object.keys(allocation.providerRef).length ? allocation.providerRef : found?.ref;
+    if (ref && ref.id !== allocation.id)
+      throw new PurgeOwnershipError("Mismatched allocation reference");
+    return { id: allocation.id, ref };
+  });
+}
+function checkpointTargets(checkpoints, physical, storageIds) {
+  return checkpoints.map((checkpoint) => {
+    if (!storageIds.has(checkpoint.storageId))
+      throw new PurgeOwnershipError("Checkpoint storage ownership is unresolved");
+    const ref = checkpoint.providerRef ?? physical.find((row) => row.checkpointId === checkpoint.id)?.ref;
+    if (ref && ref.id !== checkpoint.id)
+      throw new PurgeOwnershipError("Mismatched checkpoint reference");
+    return { id: checkpoint.id, ref };
+  });
+}
+async function purgeStorage(context, workspace) {
+  const { store, storageDriver } = context.deps;
+  const allocations = await store.listWorkspaceStorage(workspace.id);
+  const checkpoints = await store.listCheckpoints(workspace.principalId, { workspaceId: workspace.id });
+  if (!storageDriver) {
+    if (allocations.length || checkpoints.length || workspace.templateSnapshot.spec.persistence.mounts.length) {
+      throw new Error("Storage driver unavailable");
+    }
+    return;
+  }
+  const physicalStorage = await storageDriver.listStorage();
+  const physicalCheckpoints = await storageDriver.listCheckpoints();
+  for (const physical of physicalStorage) {
+    if (!await store.getStorage(physical.storageId))
+      throw new PurgeOwnershipError("Unrecorded storage requires reconciliation");
+  }
+  for (const physical of physicalCheckpoints) {
+    if (!await store.getCheckpoint(physical.checkpointId))
+      throw new PurgeOwnershipError("Unrecorded checkpoint requires reconciliation");
+  }
+  const allocationIds = new Set(allocations.map((row) => row.id));
+  const storage = storageTargets(workspace, allocations, physicalStorage);
+  const snapshots = checkpointTargets(checkpoints, physicalCheckpoints, allocationIds);
+  for (const checkpoint of snapshots) {
+    if (checkpoint.ref)
+      await storageDriver.deleteCheckpoint(checkpoint.ref);
+    await store.updateCheckpoint(checkpoint.id, { state: "deleted", deletedAt: context.now() }, context.now());
+  }
+  for (const allocation of storage) {
+    if (allocation.ref)
+      await storageDriver.deleteStorage(allocation.ref);
+    await store.updateWorkspaceStorage(allocation.id, { state: "deleted", deletedAt: context.now(), retainedUntil: null, lastErrorCode: null }, context.now());
+  }
+  const checkpointIds = new Set(checkpoints.map((row) => row.id));
+  const remainingStorage = (await storageDriver.listStorage()).some((row) => allocationIds.has(row.storageId) || row.workspaceId === workspace.id);
+  const remainingCheckpoints = (await storageDriver.listCheckpoints()).some((row) => checkpointIds.has(row.checkpointId));
+  if (remainingStorage || remainingCheckpoints)
+    throw new Error("Storage deletion not verified");
+}
+
+// ../server/src/persistence/persistence-purge.ts
+class PersistencePurgeService {
+  context;
+  running = new Map;
+  constructor(context) {
+    this.context = context;
+  }
+  async purge(principal, workspaceId, idempotencyKey) {
+    await this.context.deps.workspaces.getOwned(principal, workspaceId);
+    const at = this.context.now();
+    const result = await this.context.insertOperation({
+      id: randomUUID16(),
+      principalId: principal.id,
+      kind: "purge",
+      state: "pending",
+      idempotencyKey,
+      requestDigest: digestOf({ workspace_id: workspaceId }),
+      workspaceId,
+      checkpointId: null,
+      resultWorkspaceId: null,
+      reasonCode: null,
+      attemptCount: 0,
+      createdAt: at,
+      updatedAt: at,
+      completedAt: null
+    });
+    if (result.conflict)
+      throw new ApiError("idempotency.conflict", "Changed purge request.");
+    if (result.operation.state !== "succeeded")
+      this.run(result.operation).catch(() => {});
+    return result.operation;
+  }
+  async retry() {
+    const operations = await this.context.deps.store.listIncompleteOperations();
+    await Promise.all(operations.filter((operation) => operation.kind === "purge").map((operation) => this.run(operation)));
+    return (await this.context.deps.store.listIncompleteOperations()).filter((operation) => operation.kind === "purge").length;
+  }
+  run(operation) {
+    const workspaceId = operation.workspaceId;
+    if (!workspaceId)
+      return Promise.resolve();
+    const active = this.running.get(workspaceId);
+    if (active)
+      return active;
+    const task = this.attempt(operation, workspaceId).finally(() => this.running.delete(workspaceId));
+    this.running.set(workspaceId, task);
+    return task;
+  }
+  async attempt(operation, workspaceId) {
+    const { store, scheduler, driver, hub } = this.context.deps;
+    let reason = "purge_termination_unresolved";
+    try {
+      await store.updateOperation(operation.id, { state: "running", reasonCode: null, attemptCount: operation.attemptCount + 1 }, this.context.now());
+      await scheduler.drain();
+      const workspace = await store.getWorkspace(workspaceId);
+      if (!workspace)
+        throw new Error("Workspace missing");
+      if (await this.hasActiveCopies(workspaceId, workspace.state === "queued")) {
+        reason = "purge_operation_in_progress";
+        throw new Error(reason);
+      }
+      if (workspace.state === "preserving") {
+        reason = "purge_operation_in_progress";
+        throw new Error(reason);
+      }
+      if (driver.kind === "kubernetes" && (workspace.launchAttempts > 0 || workspace.providerRef)) {
+        await stopWorkspaceProvider(store, driver, workspace, 1, this.context.now(), false);
+        const stopped = await store.getWorkspace(workspaceId);
+        if (!stopped?.providerRef?.terminationEvidence)
+          throw new Error(reason);
+      }
+      hub.close(workspaceId);
+      if (!isTerminal(workspace.state)) {
+        if (workspace.state === "queued") {
+          await store.transition(workspaceId, {
+            from: ["queued"],
+            to: "canceled",
+            reason: "canceled_by_caller",
+            at: this.context.now()
+          });
+        } else {
+          await scheduler.finalize(workspace, "canceled", "canceled_by_caller", this.context.now());
+          if (!(await store.getWorkspace(workspaceId))?.terminalAt)
+            throw new Error(reason);
+        }
+      }
+      const current = await store.getWorkspace(workspaceId);
+      if (!current)
+        throw new Error("Workspace missing");
+      await stopWorkspaceProvider(store, driver, current, 1, this.context.now());
+      const providers = (await driver.list()).filter((provider) => provider.workspaceId === workspaceId);
+      if (providers.length)
+        throw new Error(reason);
+      reason = "purge_storage_unavailable";
+      await driver.purgeInput(workspaceId);
+      await purgeStorage(this.context, workspace);
+      await store.purgeWorkspaceContent(workspaceId, this.context.now());
+      const done = this.context.now();
+      await store.updateOperation(operation.id, { state: "succeeded", reasonCode: null, completedAt: done }, done);
+    } catch (error51) {
+      if (error51 instanceof PurgeOwnershipError)
+        reason = "purge_ownership_unresolved";
+      await store.updateOperation(operation.id, { state: "pending", reasonCode: reason, completedAt: null }, this.context.now());
+    }
+  }
+  async hasActiveCopies(workspaceId, queued) {
+    const operations = await this.context.deps.store.listIncompleteOperations();
+    let active = false;
+    for (const operation of operations) {
+      if (operation.kind === "purge")
+        continue;
+      if (operation.kind === "restore" && operation.resultWorkspaceId) {
+        const target = await this.context.deps.store.getWorkspace(operation.resultWorkspaceId);
+        if (target && isTerminal(target.state)) {
+          await this.context.failOperation(operation.id, "restore_failed");
+          continue;
+        }
+      }
+      if (queued && operation.kind === "restore" && operation.resultWorkspaceId === workspaceId) {
+        await this.context.failOperation(operation.id, "canceled_by_caller");
+      } else if (operation.workspaceId === workspaceId || operation.resultWorkspaceId === workspaceId) {
+        active = true;
+      }
+    }
+    return active;
+  }
+}
+
+// ../server/src/persistence/persistence-restore.ts
+import { randomUUID as randomUUID18 } from "crypto";
+
 // ../server/src/workspaces/service.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 function templateAuthorized(principal, templateName) {
   return principal.templateNames.includes("*") || principal.templateNames.includes(templateName);
 }
@@ -42041,7 +42694,7 @@ class WorkspaceService {
     this.validateCreateInput(template, body);
     const now = this.now();
     const result = await store.insertWorkspace({
-      id: randomUUID15(),
+      id: randomUUID17(),
       principalId: principal.id,
       externalId: body.external_id,
       idempotencyKey,
@@ -42150,9 +42803,9 @@ class PersistenceRestoreService {
     }
     this.context.storageDriver();
     const now = this.context.now();
-    const resultWorkspaceId = randomUUID16();
+    const resultWorkspaceId = randomUUID18();
     const operationResult = await this.context.insertOperation({
-      id: randomUUID16(),
+      id: randomUUID18(),
       principalId: principal.id,
       kind: "restore",
       state: "pending",
@@ -42213,7 +42866,7 @@ class PersistenceRestoreService {
     }
     await this.context.deps.store.updateOperation(operationResult.operation.id, { resultWorkspaceId: inserted.workspace.id }, now);
     await this.context.deps.store.appendEvent(checkpoint.workspaceId, "workspace.restore_queued", {
-      id: randomUUID16(),
+      id: randomUUID18(),
       type: "workspace.restore_queued",
       occurred_at: now.toISOString(),
       origin_workspace_id: checkpoint.workspaceId,
@@ -42232,6 +42885,9 @@ class PersistenceRestoreService {
 class PersistenceService {
   constructor(deps) {
     this.context = new PersistenceContext(deps);
+    const purge = new PersistencePurgeService(this.context);
+    this.purge = purge.purge.bind(purge);
+    this.retryPurges = purge.retry.bind(purge);
     this.preserveRunner = new PersistencePreserveRunner(this.context);
     this.preservePersistence = new PreservePersistenceService(this.context, this.preserveRunner);
     this.checkpoint = new PersistenceCheckpointService(this.context);
@@ -42248,6 +42904,8 @@ class PersistenceService {
     this.delete = this.maintenance.delete.bind(this.maintenance);
     this.restore = this.restoreService.restore.bind(this.restoreService);
   }
+  purge;
+  retryPurges;
   restoreService;
   maintenance;
   checkpoint;
@@ -42598,6 +43256,10 @@ class DockerDriver {
       await rm(this.egressInputPath(workspaceId), { force: true });
     }
   }
+  async purgeInput(workspaceId) {
+    await rm(this.inputPath(workspaceId), { force: true });
+    await rm(this.egressInputPath(workspaceId), { force: true });
+  }
   async cleanupInput(workspaceId) {
     await rm(this.inputPath(workspaceId), { force: true });
   }
@@ -42893,7 +43555,7 @@ async function restoreCheckpointContent(checkpointRoot, target, manifest) {
 }
 
 // ../drivers/src/filesystem/filesystem-inventory.ts
-import { open, readdir as readdir3, readFile, rm as rm3 } from "fs/promises";
+import { readdir as readdir3, readFile, rm as rm3 } from "fs/promises";
 import { join as join6, resolve as resolve8 } from "path";
 var STORAGE_METADATA_FILE = ".pocketcoder-storage.json";
 var CHECKPOINT_METADATA_FILE = ".pocketcoder-checkpoint.json";
@@ -42921,15 +43583,13 @@ async function discoverStorage(rootDirectory) {
 }
 async function discoverCheckpoints(rootDirectory) {
   const result = [];
-  for (const id of await readdir3(rootDirectory)) {
+  for (const entry of await readdir3(rootDirectory)) {
+    const id = entry.replace(/^\.creating-/, "");
     if (!/^[0-9a-f-]{36}$/i.test(id))
       continue;
     const root = childOf(rootDirectory, id);
-    try {
-      const handle = await open(join6(root, CHECKPOINT_METADATA_FILE), "r");
-      await handle.close();
+    if (!result.some((row) => row.checkpointId === id))
       result.push({ checkpointId: id, ref: { kind: "filesystem", id, root } });
-    } catch {}
   }
   return result;
 }
@@ -43159,6 +43819,7 @@ class FilesystemStorageDriver {
   async deleteCheckpoint(ref) {
     const checkpoint = this.checkpointRef(ref);
     await deleteCheckpointRoot(checkpoint.root);
+    await deleteCheckpointRoot(join7(this.checkpointRoot, `.creating-${checkpoint.id}`));
   }
   async listStorage() {
     await this.initRoots();
@@ -43253,6 +43914,232 @@ function discoveredWarmRuntimes(output, kind, namespace) {
   });
 }
 
+// ../drivers/src/kubernetes/kubernetes-evidence.ts
+var EVIDENCE_FINALIZER = "pocketcoder.dev/termination-evidence";
+var EVIDENCE_ANNOTATION = "pocketcoder.dev/termination-evidence";
+var NODE_ANNOTATION = "pocketcoder.dev/termination-node";
+async function patch(run, kind, name2, value) {
+  await run(["patch", kind, name2, "--type=merge", "-p", JSON.stringify(value)]);
+}
+async function podsFor(run, name2) {
+  const result = JSON.parse(await run(["get", "pods", "-l", `job-name=${name2}`, "-o", "json"]));
+  return result.items;
+}
+function owned(pod, uid) {
+  return pod.metadata.ownerReferences?.some((owner) => owner.uid === uid && owner.kind === "Job" && owner.controller);
+}
+function stopped(pod) {
+  const groups = [
+    [pod.spec.containers, pod.status?.containerStatuses],
+    [pod.spec.initContainers, pod.status?.initContainerStatuses],
+    [pod.spec.ephemeralContainers, pod.status?.ephemeralContainerStatuses]
+  ];
+  if (!pod.spec.containers?.length)
+    return false;
+  if (!pod.spec.nodeName && pod.metadata.deletionTimestamp)
+    return groups.every(([, statuses]) => !statuses?.length);
+  return groups.every(([spec, statuses]) => (spec?.length ?? 0) === (statuses?.length ?? 0) && (spec ?? []).every((container) => {
+    const status = statuses?.find((candidate) => candidate.name === container.name);
+    return status?.containerID && status.state.terminated?.containerID === status.containerID && !["ContainerStatusUnknown", "NodeLost"].includes(status.state.terminated?.reason ?? "") && status.state.terminated?.finishedAt && Number.isInteger(status.state.terminated.exitCode);
+  }));
+}
+function podEvidence(pod) {
+  return {
+    metadata: {
+      uid: pod.metadata.uid,
+      ownerReferences: pod.metadata.ownerReferences,
+      deletionTimestamp: pod.metadata.deletionTimestamp
+    },
+    spec: {
+      nodeName: pod.spec.nodeName,
+      containers: pod.spec.containers?.map(({ name: name2 }) => ({ name: name2 })),
+      initContainers: pod.spec.initContainers?.map(({ name: name2 }) => ({ name: name2 })),
+      ephemeralContainers: pod.spec.ephemeralContainers?.map(({ name: name2 }) => ({ name: name2 }))
+    },
+    status: {
+      containerStatuses: statusEvidence(pod.status?.containerStatuses),
+      initContainerStatuses: statusEvidence(pod.status?.initContainerStatuses),
+      ephemeralContainerStatuses: statusEvidence(pod.status?.ephemeralContainerStatuses)
+    }
+  };
+}
+function statusEvidence(statuses) {
+  return statuses?.map((status) => ({
+    name: status.name,
+    containerID: status.containerID,
+    state: {
+      terminated: {
+        exitCode: status.state.terminated?.exitCode,
+        finishedAt: status.state.terminated?.finishedAt,
+        containerID: status.state.terminated?.containerID,
+        reason: status.state.terminated?.reason
+      }
+    }
+  }));
+}
+async function updatePod(run, pod, update) {
+  const uid = pod.metadata.uid;
+  const owner = pod.metadata.ownerReferences?.find((item) => item.kind === "Job" && item.controller)?.uid;
+  for (let attempt = 0;; attempt++) {
+    try {
+      return await update(pod);
+    } catch (error51) {
+      if (attempt >= 4 || !(error51 instanceof Error) || !error51.message.includes("Error from server (Conflict)"))
+        throw error51;
+      await Bun.sleep(25 * (attempt + 1));
+      pod = JSON.parse(await run(["get", "pod", pod.metadata.name, "-o", "json"]));
+      if (!uid || pod.metadata.uid !== uid || !owner || !owned(pod, owner))
+        throw new Error("Termination provider changed");
+    }
+  }
+}
+async function retain(run, pod) {
+  return updatePod(run, pod, (current) => retainCurrent(run, current));
+}
+async function retainCurrent(run, pod) {
+  if (!pod.metadata.name || !pod.metadata.uid)
+    throw new Error("Termination evidence unavailable");
+  if (!pod.spec.nodeName) {
+    await patch(run, "pod", pod.metadata.name, {
+      metadata: {
+        uid: pod.metadata.uid,
+        resourceVersion: pod.metadata.resourceVersion,
+        finalizers: [...new Set([...pod.metadata.finalizers ?? [], EVIDENCE_FINALIZER])]
+      }
+    });
+    return null;
+  }
+  const cached2 = pod.metadata.annotations?.[NODE_ANNOTATION];
+  const node = cached2 ? JSON.parse(cached2) : JSON.parse(await run(["get", "node", pod.spec.nodeName, "-o", "json"]));
+  if (!node.metadata.uid || !node.spec.providerID)
+    throw new Error("Termination node identity unavailable");
+  const identity = {
+    metadata: { uid: node.metadata.uid, deletionTimestamp: node.metadata.deletionTimestamp },
+    spec: { providerID: node.spec.providerID },
+    status: { conditions: node.status?.conditions?.filter((condition) => condition.type === "Ready") }
+  };
+  await patch(run, "pod", pod.metadata.name, {
+    metadata: {
+      uid: pod.metadata.uid,
+      resourceVersion: pod.metadata.resourceVersion,
+      finalizers: [...new Set([...pod.metadata.finalizers ?? [], EVIDENCE_FINALIZER])],
+      annotations: { [NODE_ANNOTATION]: JSON.stringify(identity) }
+    }
+  });
+  return identity;
+}
+async function retainNodeIdentities(run, name2, jobUid) {
+  const pods = await podsFor(run, name2);
+  if (pods.some((pod) => !owned(pod, jobUid)))
+    throw new Error("Termination provider changed");
+  for (const pod of pods) {
+    if (pod.spec.nodeName && !pod.metadata.annotations?.[NODE_ANNOTATION])
+      await retain(run, pod);
+  }
+}
+async function retainNodes(run, pods, nodes) {
+  for (const pod of pods) {
+    if (pod.spec.nodeName && nodes[pod.spec.nodeName] && pod.metadata.finalizers?.includes(EVIDENCE_FINALIZER))
+      continue;
+    const node = await retain(run, pod);
+    if (pod.spec.nodeName)
+      nodes[pod.spec.nodeName] = node;
+  }
+}
+async function releasePods(run, name2, jobUid) {
+  for (const pod of await podsFor(run, name2)) {
+    if (!owned(pod, jobUid) || !pod.metadata.finalizers?.includes(EVIDENCE_FINALIZER))
+      continue;
+    await updatePod(run, pod, (current) => patch(run, "pod", current.metadata.name, {
+      metadata: {
+        uid: current.metadata.uid,
+        resourceVersion: current.metadata.resourceVersion,
+        finalizers: current.metadata.finalizers?.filter((item) => item !== EVIDENCE_FINALIZER) ?? []
+      }
+    }));
+  }
+}
+async function stoppedJob(run, name2, uid, deadline) {
+  while (true) {
+    const job = JSON.parse(await run(["get", "job", name2, "-o", "json"]));
+    if (job.metadata.uid !== uid)
+      throw new Error("Termination provider changed");
+    const conditions = job.status?.conditions ?? [];
+    const terminal = conditions.some((item) => ["Complete", "Failed"].includes(item.type) && item.status === "True");
+    const suspended = job.spec.suspend && conditions.some((item) => item.type === "Suspended" && item.status === "True");
+    if (terminal || suspended)
+      return job;
+    if (Date.now() >= deadline)
+      throw new Error("Job suspension unconfirmed");
+    await Bun.sleep(100);
+  }
+}
+async function captureTermination(run, name2, graceSeconds) {
+  const output = await run(["get", "job", name2, "--ignore-not-found", "-o", "json"]);
+  if (!output)
+    return;
+  const job = JSON.parse(output);
+  if (!job.metadata.uid)
+    throw new Error("Termination evidence unavailable");
+  if (job.metadata.annotations?.[EVIDENCE_ANNOTATION]) {
+    await releasePods(run, name2, job.metadata.uid);
+    return;
+  }
+  const initial = await podsFor(run, name2);
+  if (!initial.length || initial.some((pod) => !owned(pod, job.metadata.uid)))
+    throw new Error("Termination evidence unavailable");
+  const nodes = {};
+  await retainNodes(run, initial, nodes);
+  await patch(run, "job", name2, { metadata: { uid: job.metadata.uid }, spec: { suspend: true } });
+  const confirmed = await stoppedJob(run, name2, job.metadata.uid, Date.now() + (graceSeconds + 5) * 1000);
+  const retained = await podsFor(run, name2);
+  if (retained.length !== initial.length || retained.some((pod) => !initial.some((old) => old.metadata.uid === pod.metadata.uid)))
+    throw new Error("Termination provider changed");
+  await run([
+    "delete",
+    "pod",
+    "-l",
+    `job-name=${name2}`,
+    `--grace-period=${graceSeconds}`,
+    "--wait=false",
+    "--ignore-not-found"
+  ]);
+  const deadline = Date.now() + (graceSeconds + 5) * 1000;
+  while (true) {
+    const pods = await podsFor(run, name2);
+    if (pods.length !== retained.length || pods.some((pod) => !retained.some((old) => old.metadata.uid === pod.metadata.uid)))
+      throw new Error("Termination provider disappeared without evidence");
+    await retainNodes(run, pods, nodes);
+    if (pods.every(stopped)) {
+      const proof = {
+        job: {
+          metadata: { uid: job.metadata.uid, labels: job.metadata.labels },
+          spec: { suspend: confirmed.spec.suspend },
+          status: { conditions: confirmed.status?.conditions }
+        },
+        pods: pods.map(podEvidence),
+        nodes
+      };
+      await patch(run, "job", name2, {
+        metadata: { uid: job.metadata.uid, annotations: { [EVIDENCE_ANNOTATION]: JSON.stringify(proof) } }
+      });
+      await releasePods(run, name2, job.metadata.uid);
+      return;
+    }
+    if (Date.now() >= deadline)
+      throw new Error("Termination evidence unavailable");
+    await Bun.sleep(100);
+  }
+}
+async function readTerminationEvidence(run, name2) {
+  const output = await run(["get", "job", name2, "--ignore-not-found", "-o", "json"]);
+  if (!output)
+    return null;
+  const job = JSON.parse(output);
+  const value = job.metadata.annotations?.[EVIDENCE_ANNOTATION];
+  return value ? JSON.parse(value) : null;
+}
+
 // ../drivers/src/kubernetes/kubernetes-scheduling.ts
 function schedulingFields(options) {
   return {
@@ -43401,7 +44288,7 @@ function workspaceJobManifest(launch, name2, inputSecret, egressSecret, options)
       backoffLimit: 0,
       ttlSecondsAfterFinished: 3600,
       template: {
-        metadata: { labels, annotations },
+        metadata: { labels, annotations, ...options.podFinalizers ? { finalizers: options.podFinalizers } : {} },
         spec: {
           restartPolicy: "Never",
           automountServiceAccountToken: false,
@@ -43468,7 +44355,7 @@ function warmJobManifest(launch, name2, inputSecret, egressSecret, options) {
       backoffLimit: 0,
       ttlSecondsAfterFinished: 3600,
       template: {
-        metadata: { labels, annotations },
+        metadata: { labels, annotations, ...options.podFinalizers ? { finalizers: options.podFinalizers } : {} },
         spec: {
           restartPolicy: "Never",
           automountServiceAccountToken: false,
@@ -43518,6 +44405,22 @@ function warmJobManifest(launch, name2, inputSecret, egressSecret, options) {
   };
 }
 
+// ../drivers/src/kubernetes/kubernetes-stop.ts
+async function stopKubernetesJob(run, name2, graceSeconds) {
+  const job = await run(["get", "job", name2, "--ignore-not-found", "-o", "name"]);
+  if (job)
+    await run(["patch", "job", name2, "--type=merge", "-p", '{"spec":{"suspend":true}}']);
+  await run([
+    "delete",
+    "pod",
+    "-l",
+    `job-name=${name2}`,
+    `--grace-period=${graceSeconds}`,
+    "--wait=true",
+    "--ignore-not-found"
+  ]);
+}
+
 // ../drivers/src/kubernetes/kubernetes.ts
 class KubernetesDriver {
   kind = "kubernetes";
@@ -43529,7 +44432,9 @@ class KubernetesDriver {
   imagePullPolicy;
   egress;
   sidecarsSupported = false;
+  captureEvidence;
   constructor(options = {}) {
+    this.captureEvidence = options.captureTerminationEvidence ?? false;
     this.namespace = options.namespace ?? "default";
     if (!isKubernetesName(this.namespace)) {
       throw new Error("namespace must be a Kubernetes resource name");
@@ -43597,6 +44502,7 @@ class KubernetesDriver {
       nodeSelector: this.nodeSelector,
       tolerations: this.tolerations,
       imagePullPolicy: this.imagePullPolicy,
+      ...this.captureEvidence ? { podFinalizers: [EVIDENCE_FINALIZER] } : {},
       egressImage: this.egress.egressImage
     });
     try {
@@ -43650,6 +44556,7 @@ class KubernetesDriver {
       nodeSelector: this.nodeSelector,
       tolerations: this.tolerations,
       imagePullPolicy: this.imagePullPolicy,
+      ...this.captureEvidence ? { podFinalizers: [EVIDENCE_FINALIZER] } : {},
       egressImage: this.egress.egressImage
     });
     try {
@@ -43672,38 +44579,36 @@ class KubernetesDriver {
     }
   }
   async inspect(ref) {
-    try {
-      const output = await kubectl(this.kubectlBin, this.namespace, ["get", "job", ref.id, "-o", "json"]);
-      const job = JSON.parse(output);
-      const running = (job.status?.active ?? 0) > 0;
-      const completedExitCode = job.status?.succeeded ? 0 : 1;
-      return {
-        exists: true,
-        running,
-        exitCode: running || !(job.status?.succeeded || job.status?.failed) ? null : completedExitCode
-      };
-    } catch {
+    const output = await kubectl(this.kubectlBin, this.namespace, [
+      "get",
+      "job",
+      ref.id,
+      "--ignore-not-found",
+      "-o",
+      "json"
+    ]);
+    if (!output)
       return { exists: false, running: false, exitCode: null };
-    }
+    const job = JSON.parse(output);
+    if (this.captureEvidence) {
+      if (!job.metadata?.uid)
+        throw new Error("Termination evidence unavailable");
+      await retainNodeIdentities((args) => kubectl(this.kubectlBin, this.namespace, args), ref.id, job.metadata.uid);
+    }
+    const running = (job.status?.active ?? 0) > 0;
+    const completedExitCode = job.status?.succeeded ? 0 : 1;
+    return {
+      exists: true,
+      running,
+      exitCode: running || !(job.status?.succeeded || job.status?.failed) ? null : completedExitCode
+    };
   }
   async stop(ref, graceSeconds) {
-    await kubectl(this.kubectlBin, this.namespace, [
-      "patch",
-      "job",
-      ref.id,
-      "--type=merge",
-      "-p",
-      '{"spec":{"suspend":true}}'
-    ]).catch(() => {});
-    await kubectl(this.kubectlBin, this.namespace, [
-      "delete",
-      "pod",
-      "-l",
-      `job-name=${ref.id}`,
-      `--grace-period=${graceSeconds}`,
-      "--wait=true",
-      "--ignore-not-found"
-    ]).catch(() => {});
+    if (this.captureEvidence) {
+      await captureTermination((args) => kubectl(this.kubectlBin, this.namespace, args), ref.id, graceSeconds);
+      return;
+    }
+    await stopKubernetesJob((args) => kubectl(this.kubectlBin, this.namespace, args), ref.id, graceSeconds);
   }
   async remove(ref) {
     await kubectl(this.kubectlBin, this.namespace, [
@@ -43711,19 +44616,31 @@ class KubernetesDriver {
       "job",
       ref.id,
       "--ignore-not-found",
+      "--cascade=foreground",
       "--wait=true"
-    ]).catch(() => {});
+    ]);
     const inputSecret = typeof ref.inputSecret === "string" ? ref.inputSecret : `${ref.id}-input`;
-    await kubectl(this.kubectlBin, this.namespace, ["delete", "secret", inputSecret, "--ignore-not-found"]).catch(() => {});
+    await kubectl(this.kubectlBin, this.namespace, ["delete", "secret", inputSecret, "--ignore-not-found"]);
     if (typeof ref.egressSecret === "string") {
-      await kubectl(this.kubectlBin, this.namespace, [
-        "delete",
-        "secret",
-        ref.egressSecret,
-        "--ignore-not-found"
-      ]).catch(() => {});
+      await kubectl(this.kubectlBin, this.namespace, ["delete", "secret", ref.egressSecret, "--ignore-not-found"]);
     }
   }
+  async terminationEvidence(ref) {
+    if (!this.captureEvidence)
+      return null;
+    return readTerminationEvidence((args) => kubectl(this.kubectlBin, this.namespace, args), ref.id);
+  }
+  async purgeInput(workspaceId) {
+    const name2 = resourceName(workspaceId);
+    await kubectl(this.kubectlBin, this.namespace, [
+      "delete",
+      "secret",
+      `${name2}-input`,
+      `${name2}-egress`,
+      "--ignore-not-found",
+      "--wait=true"
+    ]);
+  }
   async cleanupInput(workspaceId) {
     await kubectl(this.kubectlBin, this.namespace, [
       "delete",
@@ -44248,6 +45165,7 @@ function loadConfig(env2 = process.env) {
   }
   return {
     listenHost: env2.POCKETCODER_HOST ?? "127.0.0.1",
+    launchPolicy: launchPolicyConfig(env2),
     listenPort,
     storeKind,
     databaseUrl,
@@ -44276,8 +45194,7 @@ function loadConfig(env2 = process.env) {
 }
 
 // ../memory-store/src/modules/auth/memory-store-auth.ts
-import { randomUUID as randomUUID17 } from "crypto";
-
+import { randomUUID as randomUUID19 } from "crypto";
 class MemoryAuthStore {
   context;
   constructor(context) {
@@ -44288,7 +45205,7 @@ class MemoryAuthStore {
       throw new Error(`principal exists: ${name2}`);
     }
     const row = {
-      id: randomUUID17(),
+      id: randomUUID19(),
       name: name2,
       scopes,
       templateNames,
@@ -44301,6 +45218,21 @@ class MemoryAuthStore {
   async getPrincipalByName(name2) {
     return this.context.principals.find((p) => p.name === name2) ?? null;
   }
+  async getPrincipal(id) {
+    return this.context.principals.find((row) => row.id === id) ?? null;
+  }
+  async listMachineKeys(principalId, filter) {
+    return this.context.keys.filter((row) => row.principalId === principalId && (!filter.cursor || row.id > filter.cursor) && (!filter.requestId || row.issuanceRequestId === filter.requestId)).sort((a, b) => a.id.localeCompare(b.id)).slice(0, filter.limit).map((row) => ({ ...row }));
+  }
+  async revokePrincipalKeys(principalId, at) {
+    const principal = this.context.principals.find((row) => row.id === principalId);
+    if (!principal)
+      return;
+    principal.disabledAt = at;
+    for (const key of this.context.keys)
+      if (key.principalId === principalId)
+        key.revokedAt ??= at;
+  }
   async listPrincipals() {
     return this.context.principals.map((p) => ({ ...p }));
   }
@@ -44319,7 +45251,32 @@ class MemoryAuthStore {
     }
   }
   async insertMachineKey(row) {
+    await this.issueMachineKey({
+      ...row,
+      issuanceRequestId: row.issuanceRequestId ?? null,
+      issuanceRequestDigest: row.issuanceRequestDigest ?? null,
+      managedPrincipalIds: row.managedPrincipalIds ?? []
+    });
+  }
+  async issueMachineKey(row) {
+    const principal = this.context.principals.find((principal2) => principal2.id === row.principalId);
+    if (!principal)
+      throw new ApiError("auth.invalid_key", "Unknown principal.");
+    const existing = row.issuanceRequestId ? this.context.keys.find((key) => key.principalId === row.principalId && key.issuanceRequestId === row.issuanceRequestId) : null;
+    if (existing)
+      return {
+        key: { ...existing },
+        created: false,
+        conflict: existing.issuanceRequestDigest !== row.issuanceRequestDigest
+      };
+    if (principal.disabledAt)
+      throw new ApiError("auth.disabled_principal", "This principal is disabled.");
+    if (row.issuanceRequestId && row.expiresAt && row.expiresAt <= new Date)
+      throw new ApiError("validation.invalid", "Key expiry must be in the future.");
+    if (row.scopes.some((scope) => !principal.scopes.includes("admin") && !principal.scopes.includes(scope)))
+      throw new ApiError("auth.missing_scope", "Key scopes exceed the principal's authority.");
     this.context.keys.push({ ...row });
+    return { key: { ...row }, created: true, conflict: false };
   }
   async getMachineKeyWithPrincipal(keyId) {
     const key = this.context.keys.find((k) => k.id === keyId);
@@ -44345,7 +45302,7 @@ class MemoryAuthStore {
 }
 
 // ../memory-store/src/state/memory-store-base.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 var ACTIVE_STATES = [
   "provisioning",
   "connected",
@@ -44419,7 +45376,7 @@ class MemoryState {
   }
   appendHistory(row, from, to, reason, at) {
     this.history.push({
-      id: randomUUID18(),
+      id: randomUUID20(),
       workspaceId: row.id,
       fromState: from,
       toState: to,
@@ -44428,6 +45385,8 @@ class MemoryState {
     });
   }
   appendWorkspaceEvent(row, at) {
+    if (row.purgeRequestedAt)
+      return;
     const payload = buildEventEnvelope(row, at);
     this.outbox.push({
       id: payload.id,
@@ -44453,6 +45412,8 @@ class MemoryConversationStore {
     const state = this.context.conversationStates.get(input.workspaceId);
     if (state?.status === "deleted")
       throw new Error("conversation.deleted");
+    if (this.context.workspaces.get(input.workspaceId)?.purgeRequestedAt)
+      throw new Error("conversation.deleted");
     const rows = this.context.conversations.get(input.workspaceId) ?? [];
     const existing = rows.find((row) => row.messageId === input.messageId);
     if (existing)
@@ -44528,6 +45489,8 @@ class MemoryLogStore {
     this.context = context;
   }
   async appendLogs(workspaceId, entries) {
+    if (this.context.workspaces.get(workspaceId)?.purgeRequestedAt)
+      return;
     const list = this.context.logs.get(workspaceId) ?? [];
     let bytes = this.context.logBytes.get(workspaceId) ?? 0;
     let seq = list.length > 0 ? list[list.length - 1]?.seq ?? 0 : 0;
@@ -44564,6 +45527,8 @@ class MemoryLogStore {
     };
   }
   async appendNetworkEvents(workspaceId, sourceSessionId, events) {
+    if (this.context.workspaces.get(workspaceId)?.purgeRequestedAt)
+      return;
     const rows = this.context.networkEvents.get(workspaceId) ?? [];
     const seen = new Set(rows.map((row) => `${row.sourceSessionId}:${row.source_seq}`));
     const workspace = this.context.workspaces.get(workspaceId);
@@ -44585,7 +45550,7 @@ class MemoryLogStore {
 }
 
 // ../memory-store/src/modules/outbox/memory-store-outbox.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 
 class MemoryOutboxStore {
   context;
@@ -44616,8 +45581,10 @@ class MemoryOutboxStore {
     this.context.claimedEvents.delete(id);
   }
   async appendEvent(workspaceId, eventType, payload, at) {
+    if (this.context.workspaces.get(workspaceId)?.purgeRequestedAt)
+      return;
     this.context.outbox.push({
-      id: randomUUID19(),
+      id: randomUUID21(),
       workspaceId,
       eventType,
       payload,
@@ -44630,6 +45597,52 @@ class MemoryOutboxStore {
   }
 }
 
+// ../memory-store/src/modules/persistence/memory-store-content.ts
+function createContentPurge2(context) {
+  return {
+    async listWorkspaceStorage(workspaceId) {
+      return [...context.storage.values()].filter((row) => row.workspaceId === workspaceId).map((row) => ({ ...row }));
+    },
+    async purgeWorkspaceContent(workspaceId, at) {
+      const workspace = context.workspaces.get(workspaceId);
+      if (!workspace?.purgeRequestedAt)
+        throw new Error("Purge has not been admitted");
+      context.logs.delete(workspaceId);
+      context.logBytes.delete(workspaceId);
+      context.outputs.delete(workspaceId);
+      context.conversations.delete(workspaceId);
+      context.conversationBytes.delete(workspaceId);
+      context.networkEvents.delete(workspaceId);
+      context.outbox = context.outbox.filter((row) => row.workspaceId !== workspaceId);
+      context.conversationStates.set(workspaceId, {
+        workspaceId,
+        status: "deleted",
+        expiresAt: null,
+        deletedAt: at,
+        updatedAt: at
+      });
+      for (const checkpoint of context.checkpoints.values()) {
+        if (checkpoint.workspaceId === workspaceId)
+          Object.assign(checkpoint, { manifest: null, manifestDigest: null, sourceProvenance: null, label: null });
+      }
+      Object.assign(workspace, {
+        launchInput: null,
+        outputs: {},
+        metadata: {},
+        health: {},
+        failureLogTail: null,
+        failureLogTailTruncated: false,
+        failureLastLogSeq: null,
+        sourceDescriptor: null,
+        resolvedSource: null,
+        registrationDigest: null,
+        reconnectDigest: null,
+        updatedAt: at
+      });
+    }
+  };
+}
+
 // ../memory-store/src/modules/persistence/memory-store-operations.ts
 class MemoryOperationStore {
   context;
@@ -44649,6 +45662,12 @@ class MemoryOperationStore {
       throw new OperationCapacityExceededError;
     }
     this.assertOperationReferences(row);
+    const workspace = row.workspaceId ? this.context.workspaces.get(row.workspaceId) : null;
+    if (workspace?.purgeRequestedAt && row.kind !== "purge") {
+      throw new ApiError("operation.conflict", "Workspace content is being purged.");
+    }
+    if (workspace && row.kind === "purge")
+      workspace.purgeRequestedAt ??= row.createdAt;
     this.context.operations.set(row.id, { ...row });
     return { operation: { ...row }, created: true, conflict: false };
   }
@@ -44671,12 +45690,12 @@ class MemoryOperationStore {
   async listIncompleteOperations() {
     return [...this.context.operations.values()].filter((row) => row.state === "pending" || row.state === "running").map((row) => ({ ...row }));
   }
-  async updateOperation(id, patch, at) {
+  async updateOperation(id, patch2, at) {
     const row = this.context.operations.get(id);
     if (!row)
       return;
-    this.assertOperationReferences({ ...row, ...patch });
-    Object.assign(row, patch);
+    this.assertOperationReferences({ ...row, ...patch2 });
+    Object.assign(row, patch2);
     row.updatedAt = at;
   }
   async checkpointUsage(principalId) {
@@ -44693,6 +45712,8 @@ class MemoryOperationStore {
     const workspace = this.context.workspaces.get(input.workspaceId);
     if (!workspace)
       throw new Error("workspace not found");
+    if (workspace.purgeRequestedAt)
+      throw new ApiError("operation.conflict", "Workspace content is being purged.");
     const list = this.context.outputs.get(input.workspaceId) ?? [];
     const row = { ...input, seq: list.length + 1 };
     list.push(row);
@@ -44727,11 +45748,11 @@ class MemoryPersistenceStore {
     const row = this.context.storage.get(id);
     return row ? { ...row } : null;
   }
-  async updateWorkspaceStorage(id, patch, at) {
+  async updateWorkspaceStorage(id, patch2, at) {
     const row = this.context.storage.get(id);
     if (!row)
       return;
-    Object.assign(row, patch);
+    Object.assign(row, patch2);
     row.updatedAt = at;
   }
   async insertCheckpoint(row) {
@@ -44748,24 +45769,24 @@ class MemoryPersistenceStore {
   async listCheckpoints(principalId, filter = {}) {
     return [...this.context.checkpoints.values()].filter((row) => row.principalId === principalId && (!filter.workspaceId || row.workspaceId === filter.workspaceId) && (!filter.state || row.state === filter.state)).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()).map((row) => ({ ...row }));
   }
-  async updateCheckpoint(id, patch, at) {
+  async updateCheckpoint(id, patch2, at) {
     const row = this.context.checkpoints.get(id);
     if (!row)
       return;
     if (row.state === "ready") {
       const mutable = new Set(["state", "reasonCode", "expiresAt", "deletedAt"]);
-      for (const key of Object.keys(patch)) {
+      for (const key of Object.keys(patch2)) {
         if (!mutable.has(key))
           throw new Error("ready checkpoints are immutable");
       }
     }
-    Object.assign(row, patch);
+    Object.assign(row, patch2);
     row.updatedAt = at;
   }
 }
 
 // ../memory-store/src/modules/templates/memory-store-templates.ts
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID22 } from "crypto";
 
 class MemoryTemplateStore {
   context;
@@ -44781,7 +45802,7 @@ class MemoryTemplateStore {
       return { row: existing, created: false, conflict: false };
     }
     const row = {
-      id: randomUUID20(),
+      id: randomUUID22(),
       name: input.name,
       version: input.version,
       digest: input.digest,
@@ -44887,16 +45908,16 @@ class MemoryWarmPoolStore {
   async listWarmPoolRuntimes() {
     return [...this.context.warmPoolRuntimes.values()].map((row) => ({ ...row }));
   }
-  async updateWarmPoolRuntime(id, patch, at) {
+  async updateWarmPoolRuntime(id, patch2, at) {
     const row = this.context.warmPoolRuntimes.get(id);
     if (!row)
       return;
-    Object.assign(row, patch);
+    Object.assign(row, patch2);
     row.updatedAt = at;
   }
   async claimWarmPoolRuntime(claim) {
     const workspace = this.context.workspaces.get(claim.workspaceId);
-    if (workspace?.state !== "queued")
+    if (workspace?.state !== "queued" || workspace.purgeRequestedAt)
       return null;
     const runtime = [...this.context.warmPoolRuntimes.values()].filter((row) => row.state === "ready" && row.templateDigest === claim.templateDigest && row.driverKind === claim.driverKind && row.eligibilityFingerprint === claim.eligibilityFingerprint).sort((a, b) => (a.readyAt?.getTime() ?? 0) - (b.readyAt?.getTime() ?? 0))[0];
     if (!runtime?.providerRef)
@@ -44958,7 +45979,7 @@ class MemoryAdmissionStore {
   }
   async claimWorkspaceAdmission(claim) {
     const workspace = this.context.workspaces.get(claim.workspaceId);
-    if (workspace?.state !== "queued")
+    if (workspace?.state !== "queued" || workspace.purgeRequestedAt)
       return null;
     const counts = this.activeCounts();
     if (counts.global >= claim.limits.globalActiveWorkspaces)
@@ -44981,12 +46002,14 @@ class MemoryAdmissionStore {
       }
     });
   }
-  async updateWorkspace(id, patch, at) {
+  async updateWorkspace(id, patch2, at) {
     const row = this.context.workspaces.get(id);
     if (!row)
       return;
-    Object.assign(row, patch);
-    const changed = Object.keys(patch).some((key) => CHANGE_PATCH_KEYS2.has(key));
+    Object.assign(row, patch2);
+    if (row.purgeRequestedAt)
+      Object.assign(row, purgedContentPatch());
+    const changed = Object.keys(patch2).some((key) => CHANGE_PATCH_KEYS2.has(key));
     if (changed)
       row.changeSeq += 1;
     row.updatedAt = at;
@@ -45035,12 +46058,16 @@ class MemoryAdmissionStore {
       return null;
     if (!canTransition(row.state, req.to))
       return null;
+    if (row.purgeRequestedAt && ["provisioning", "connected", "ready", "preserving", "queued"].includes(req.to))
+      return null;
     const fromState = row.state;
     row.state = req.to;
     if (req.reason !== undefined)
       row.reasonCode = req.reason;
     if (req.patch)
       Object.assign(row, req.patch);
+    if (row.purgeRequestedAt)
+      Object.assign(row, purgedContentPatch());
     row.changeSeq += 1;
     row.updatedAt = req.at;
     if (isTerminal(req.to)) {
@@ -45137,6 +46164,7 @@ class MemoryWorkspaceStore {
       createdAt: row.createdAt,
       updatedAt: row.createdAt,
       terminalAt: null,
+      purgeRequestedAt: null,
       originWorkspaceId: row.originWorkspaceId ?? null,
       restoredFromCheckpointId: row.restoredFromCheckpointId ?? null,
       sourceDescriptor: row.sourceDescriptor ?? null,
@@ -45189,6 +46217,9 @@ class MemoryWorkspaceStore {
 class MemoryStore {
   constructor() {
     this.context = new MemoryState;
+    const content = createContentPurge2(this.context);
+    this.listWorkspaceStorage = content.listWorkspaceStorage;
+    this.purgeWorkspaceContent = content.purgeWorkspaceContent;
     this.persistence = new MemoryPersistenceStore(this.context);
     this.operation = new MemoryOperationStore(this.context);
     this.template = new MemoryTemplateStore(this.context);
@@ -45233,6 +46264,10 @@ class MemoryStore {
     this.listPrincipals = this.auth.listPrincipals.bind(this.auth);
     this.updatePrincipal = this.auth.updatePrincipal.bind(this.auth);
     this.setPrincipalDisabled = this.auth.setPrincipalDisabled.bind(this.auth);
+    this.getPrincipal = this.auth.getPrincipal.bind(this.auth);
+    this.issueMachineKey = this.auth.issueMachineKey.bind(this.auth);
+    this.listMachineKeys = this.auth.listMachineKeys.bind(this.auth);
+    this.revokePrincipalKeys = this.auth.revokePrincipalKeys.bind(this.auth);
     this.insertMachineKey = this.auth.insertMachineKey.bind(this.auth);
     this.getMachineKeyWithPrincipal = this.auth.getMachineKeyWithPrincipal.bind(this.auth);
     this.revokeMachineKey = this.auth.revokeMachineKey.bind(this.auth);
@@ -45283,6 +46318,8 @@ class MemoryStore {
   operation;
   persistence;
   context;
+  listWorkspaceStorage;
+  purgeWorkspaceContent;
   init;
   acquireCoordinatorLease;
   close;
@@ -45316,6 +46353,10 @@ class MemoryStore {
   listPrincipals;
   updatePrincipal;
   setPrincipalDisabled;
+  getPrincipal;
+  issueMachineKey;
+  listMachineKeys;
+  revokePrincipalKeys;
   insertMachineKey;
   getMachineKeyWithPrincipal;
   revokeMachineKey;
@@ -45563,10 +46604,10 @@ function mapValues(object2, mapper) {
   });
   return result;
 }
-function omit2(object2, keys) {
+function omit2(object2, keys2) {
   const result = {};
   Object.entries(object2).forEach(([key, value]) => {
-    if (!keys.some((keyToOmit) => keyToOmit === key)) {
+    if (!keys2.some((keyToOmit) => keyToOmit === key)) {
       result[key] = value;
     }
   });
@@ -45941,8 +46982,8 @@ class DiscriminatedUnionTransformer {
       const refId = Metadata.getRefId(obj);
       const value = (_a4 = obj.def.shape) === null || _a4 === undefined ? undefined : _a4[discriminator];
       if (isZodType(value, "ZodEnum")) {
-        const keys = Object.values(value._zod.def.entries).filter(isString);
-        keys.forEach((enumValue) => {
+        const keys2 = Object.values(value._zod.def.entries).filter(isString);
+        keys2.forEach((enumValue) => {
           mapping[enumValue] = generateSchemaRef(refId);
         });
         return;
@@ -46069,8 +47110,8 @@ class RecordTransformer {
     const keyType = zodSchema.keyType;
     const propertiesSchema = isAnyZodType(propertiesType) ? mapItem(propertiesType) : {};
     if (isZodType(keyType, "ZodEnum")) {
-      const keys = Object.values(keyType._zod.def.entries).filter(isString);
-      const properties = keys.reduce((acc, curr) => Object.assign(Object.assign({}, acc), { [curr]: propertiesSchema }), {});
+      const keys2 = Object.values(keyType._zod.def.entries).filter(isString);
+      const properties = keys2.reduce((acc, curr) => Object.assign(Object.assign({}, acc), { [curr]: propertiesSchema }), {});
       return Object.assign(Object.assign({}, mapNullableType("object")), { properties });
     }
     return Object.assign(Object.assign({}, mapNullableType("object")), { additionalProperties: propertiesSchema });
@@ -47372,9 +48413,9 @@ var handleParsingNestedValues = (form, key, value) => {
     return;
   }
   let nestedForm = form;
-  const keys = key.split(".");
-  keys.forEach((key2, index2) => {
-    if (index2 === keys.length - 1) {
+  const keys2 = key.split(".");
+  keys2.forEach((key2, index2) => {
+    if (index2 === keys2.length - 1) {
       nestedForm[key2] = value;
     } else {
       if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
@@ -47410,8 +48451,8 @@ var HonoRequest = class {
   }
   #getAllDecodedParams() {
     const decoded = {};
-    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-    for (const key of keys) {
+    const keys2 = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys2) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value !== undefined) {
         decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
@@ -48170,9 +49211,9 @@ function buildMatcherFromPreprocessedRoutes(routes) {
       if (!map2) {
         continue;
       }
-      const keys = Object.keys(map2);
-      for (let k = 0, len3 = keys.length;k < len3; k++) {
-        map2[keys[k]] = paramReplacementMap[map2[keys[k]]];
+      const keys2 = Object.keys(map2);
+      for (let k = 0, len3 = keys2.length;k < len3; k++) {
+        map2[keys2[k]] = paramReplacementMap[map2[keys2[k]]];
       }
     }
   }
@@ -48975,10 +50016,10 @@ var createBunWebSocket = () => ({
 });
 
 // ../server/src/http/middleware.ts
-import { randomUUID as randomUUID21 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 var requestId = async (c, next) => {
   const candidate = c.req.header("x-request-id");
-  const id = candidate && /^[A-Za-z0-9._-]{1,128}$/.test(candidate) ? candidate : randomUUID21();
+  const id = candidate && /^[A-Za-z0-9._-]{1,128}$/.test(candidate) ? candidate : randomUUID23();
   c.set("requestId", id);
   c.header("x-request-id", id);
   await next();
@@ -49025,6 +50066,7 @@ function machineAuth(store, pepper) {
     c.set("principal", found.principal);
     c.set("scopes", effectiveScopes);
     c.set("keyId", found.key.id);
+    c.set("managedPrincipalIds", found.key.managedPrincipalIds);
     store.touchMachineKey(found.key.id, now).catch(() => {});
     await next();
   };
@@ -49039,7 +50081,7 @@ function requireScope(scope) {
 }
 function errorHandler2(logger) {
   return (err, c) => {
-    const id = c.get("requestId") ?? randomUUID21();
+    const id = c.get("requestId") ?? randomUUID23();
     if (err instanceof ApiError) {
       return c.json(errorEnvelope(err.code, err.message, id, err.details), err.status);
     }
@@ -49141,8 +50183,219 @@ function registerAdministrationRoutes({
   });
 }
 
+// ../../node_modules/.bun/hono@4.12.32/node_modules/hono/dist/middleware/body-limit/index.js
+var ERROR_MESSAGE = "Payload Too Large";
+var bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new HTTPException(413, { res });
+  });
+  const maxSize = options.maxSize;
+  return async function bodyLimit2(c, next) {
+    if (!c.req.raw.body) {
+      return next();
+    }
+    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+    const hasContentLength = c.req.raw.headers.has("content-length");
+    if (hasContentLength && !hasTransferEncoding) {
+      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
+      return contentLength > maxSize ? onError(c) : next();
+    }
+    let size = 0;
+    const chunks = [];
+    const rawReader = c.req.raw.body.getReader();
+    for (;; ) {
+      const { done, value } = await rawReader.read();
+      if (done) {
+        break;
+      }
+      size += value.length;
+      if (size > maxSize) {
+        return onError(c);
+      }
+      chunks.push(value);
+    }
+    const requestInit = {
+      body: new ReadableStream({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(chunk);
+          }
+          controller.close();
+        }
+      }),
+      duplex: "half"
+    };
+    c.req.raw = new Request(c.req.raw, requestInit);
+    return next();
+  };
+};
+
+// ../server/src/administration/principal-authority.ts
+async function managedPrincipal(context, store, id) {
+  if (!context.get("managedPrincipalIds").includes(id))
+    throw new ApiError("principal.not_found", "Unknown principal.");
+  const principal = await store.getPrincipal(id);
+  if (!principal)
+    throw new ApiError("principal.not_found", "Unknown principal.");
+  return principal;
+}
+
+// ../server/src/administration/keys-routes.ts
+var principalParams = exports_external.object({ principalId: exports_external.uuid() });
+var revokedSchema = exports_external.object({ revoked: exports_external.literal(true) });
+function registerKeyRoutes(app, store, pepper) {
+  app.use("/v1/principals/*", bodyLimit({
+    maxSize: 16384,
+    onError: () => {
+      throw new ApiError("validation.invalid", "Request body exceeds 16384 bytes.");
+    }
+  }));
+  app.openapi(createRoute({
+    method: "get",
+    path: "/v1/principals/{principalId}/keys",
+    operationId: "listPrincipalKeys",
+    tags: ["Keys"],
+    middleware: [requireScope("keys:read")],
+    request: {
+      params: principalParams,
+      query: exports_external.object({
+        limit: exports_external.coerce.number().int().min(1).max(100).default(50),
+        cursor: exports_external.uuid().optional(),
+        request_id: exports_external.string().min(1).max(128).optional()
+      })
+    },
+    responses: {
+      200: {
+        description: "Authoritative key metadata",
+        content: { "application/json": { schema: KeyListResponseSchema } }
+      },
+      ...COMMON_ERROR_RESPONSES
+    }
+  }), async (c) => {
+    const principal = await managedPrincipal(c, store, c.req.valid("param").principalId);
+    const query = c.req.valid("query");
+    const keys2 = await store.listMachineKeys(principal.id, {
+      limit: query.limit + 1,
+      ...query.cursor ? { cursor: query.cursor } : {},
+      ...query.request_id ? { requestId: query.request_id } : {}
+    });
+    const items = keys2.slice(0, query.limit).map((key) => keyResource(key, principal));
+    return c.json({ items, next_cursor: keys2.length > query.limit ? items.at(-1)?.id ?? null : null }, 200);
+  });
+  app.openapi(createRoute({
+    method: "post",
+    path: "/v1/principals/{principalId}/keys",
+    operationId: "issuePrincipalKey",
+    tags: ["Keys"],
+    middleware: [requireScope("keys:write")],
+    request: {
+      params: principalParams,
+      body: { content: { "application/json": { schema: KeyIssueRequestSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Reconciled issuance; secret unavailable",
+        content: { "application/json": { schema: KeyIssueResponseSchema } }
+      },
+      201: {
+        description: "Issued key; secret shown once",
+        content: { "application/json": { schema: KeyIssueResponseSchema } }
+      },
+      ...COMMON_ERROR_RESPONSES
+    }
+  }), async (c) => {
+    const principal = await managedPrincipal(c, store, c.req.valid("param").principalId);
+    const result = await issuePrincipalKey(store, pepper, principal, c.req.valid("json"));
+    return c.json({ key: result.key, token: result.token }, result.created ? 201 : 200);
+  });
+  app.openapi(createRoute({
+    method: "delete",
+    path: "/v1/principals/{principalId}/keys/{keyId}",
+    operationId: "revokePrincipalKey",
+    tags: ["Keys"],
+    middleware: [requireScope("keys:write")],
+    request: { params: principalParams.extend({ keyId: exports_external.uuid() }) },
+    responses: {
+      200: { description: "Key revoked", content: { "application/json": { schema: revokedSchema } } },
+      ...COMMON_ERROR_RESPONSES
+    }
+  }), async (c) => {
+    const { principalId, keyId } = c.req.valid("param");
+    await managedPrincipal(c, store, principalId);
+    const found = await store.getMachineKeyWithPrincipal(keyId);
+    if (!found || found.key.principalId !== principalId)
+      throw new ApiError("key.not_found", "Unknown key.");
+    await store.revokeMachineKey(keyId, new Date);
+    return c.json({ revoked: true }, 200);
+  });
+  app.openapi(createRoute({
+    method: "delete",
+    path: "/v1/principals/{principalId}/keys",
+    operationId: "revokeAllPrincipalKeys",
+    tags: ["Keys"],
+    middleware: [requireScope("keys:write")],
+    request: { params: principalParams },
+    responses: {
+      200: {
+        description: "Principal disabled and all keys revoked atomically",
+        content: { "application/json": { schema: revokedSchema } }
+      },
+      ...COMMON_ERROR_RESPONSES
+    }
+  }), async (c) => {
+    const principal = await managedPrincipal(c, store, c.req.valid("param").principalId);
+    await store.revokePrincipalKeys(principal.id, new Date);
+    return c.json({ revoked: true }, 200);
+  });
+}
+
+// ../server/src/administration/recovery-routes.ts
+function registerOperatorRecoveryRoutes(app, store, persistence2) {
+  const responses = {
+    202: {
+      description: "Recovery purge accepted",
+      content: { "application/json": { schema: OperationResourceSchema } }
+    },
+    ...COMMON_ERROR_RESPONSES
+  };
+  app.openapi(createRoute({
+    method: "post",
+    path: "/v1/principals/{principalId}/workspaces/{id}/purge",
+    operationId: "recoverWorkspacePurge",
+    tags: ["Recovery"],
+    middleware: [requireScope("workspaces:recover")],
+    request: {
+      params: exports_external.object({ principalId: exports_external.uuid(), id: exports_external.uuid() }),
+      headers: IdempotencyHeadersSchema,
+      body: { content: { "application/json": { schema: exports_external.strictObject({}) } } }
+    },
+    responses
+  }), async (c) => {
+    const principal = await managedPrincipal(c, store, c.req.valid("param").principalId);
+    return c.json(toOperationResource(await persistence2.purge(principal, c.req.valid("param").id, c.req.valid("header")["Idempotency-Key"])), 202);
+  });
+  app.openapi(createRoute({
+    method: "get",
+    path: "/v1/principals/{principalId}/operations/{id}",
+    operationId: "getRecoveryOperation",
+    tags: ["Recovery"],
+    middleware: [requireScope("workspaces:recover")],
+    request: { params: exports_external.object({ principalId: exports_external.uuid(), id: exports_external.uuid() }) },
+    responses: { 200: responses[202], ...COMMON_ERROR_RESPONSES }
+  }), async (c) => {
+    const principal = await managedPrincipal(c, store, c.req.valid("param").principalId);
+    const operation = await store.getOperation(c.req.valid("param").id);
+    if (!operation || operation.principalId !== principal.id || operation.kind !== "purge")
+      throw new ApiError("workspace.not_found", "Unknown operation.");
+    return c.json(toOperationResource(operation), 200);
+  });
+}
+
 // ../server/src/attachments/attachments.ts
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 var ACK_TIMEOUT_MS = 30000;
 var RESULT_TIMEOUT_MS = 30000;
 var RESOLVE_TIMEOUT_MS = 1e4;
@@ -49283,6 +50536,8 @@ function attachmentUploadHandler(deps) {
     const id = c.req.param("id") ?? "";
     const attachmentId = (c.req.param("attachmentId") ?? "").toLowerCase();
     const row = await deps.service.getOwned(principal, id);
+    if (row.purgeRequestedAt)
+      throw new ApiError("operation.conflict", "Workspace content is being purged.");
     if (isTerminal(row.state)) {
       throw new ApiError("workspace.terminal", "This workspace has ended.");
     }
@@ -49294,7 +50549,7 @@ function attachmentUploadHandler(deps) {
     }
     const headers = uploadHeaders(c);
     const conn = liveConnection(deps.hub, id);
-    const operationId = randomUUID22();
+    const operationId = randomUUID24();
     deps.hub.openAttachment(conn, operationId);
     try {
       const result = await streamUpload(deps.hub, conn, operationId, c.req.raw.body, headers, attachmentId);
@@ -49319,7 +50574,7 @@ function abandonUpload(hub, workspaceId, conn, operationId, error51) {
   hub.send(conn, "attachment_abort", { operation_id: operationId, reason });
 }
 async function resolveDescriptors(hub, conn, attachmentIds) {
-  const operationId = randomUUID22();
+  const operationId = randomUUID24();
   hub.openAttachment(conn, operationId);
   try {
     hub.send(conn, "attachment_resolve", {
@@ -49373,7 +50628,7 @@ ${attachmentManifest(descriptors)}`;
 }
 
 // ../server/src/control-channel/hub.ts
-import { randomUUID as randomUUID23 } from "crypto";
+import { randomUUID as randomUUID25 } from "crypto";
 
 // ../server/src/relay/relay-stream-channel.ts
 class RelayStreamRegistry {
@@ -49857,12 +51112,12 @@ class Hub {
   relay(workspaceId, request) {
     const conn = this.byWorkspace.get(workspaceId);
     if (!conn?.registered) {
-      return Promise.resolve({ request_id: randomUUID23(), headers: {}, error_code: "unreachable" });
+      return Promise.resolve({ request_id: randomUUID25(), headers: {}, error_code: "unreachable" });
     }
     if (conn.inflight.size + conn.streams.size >= MAX_INFLIGHT_RELAY) {
-      return Promise.resolve({ request_id: randomUUID23(), headers: {}, error_code: "deadline" });
+      return Promise.resolve({ request_id: randomUUID25(), headers: {}, error_code: "deadline" });
     }
-    const requestId2 = randomUUID23();
+    const requestId2 = randomUUID25();
     return new Promise((resolve11) => {
       const timer = setTimeout(() => {
         conn.inflight.delete(requestId2);
@@ -49874,7 +51129,7 @@ class Hub {
   }
   relayStream(workspaceId, request, maxResponseBytes) {
     const conn = this.byWorkspace.get(workspaceId);
-    const requestId2 = randomUUID23();
+    const requestId2 = randomUUID25();
     if (!conn?.registered) {
       return Promise.resolve({ request_id: requestId2, headers: {}, error_code: "unreachable" });
     }
@@ -50088,7 +51343,7 @@ async function authenticateConnection(deps, credentials) {
     return { error: "Missing workspace credentials." };
   }
   const row = await deps.store.getWorkspace(credentials.workspaceId);
-  if (!row || isTerminal(row.state))
+  if (!row || row.purgeRequestedAt || isTerminal(row.state))
     return { error: "Unknown workspace." };
   if (sourceCredentialReference2(row) && credentials.protocolVersion < SOURCE_CREDENTIAL_MIN_PROTOCOL_VERSION) {
     return { error: "Source credentials require agent protocol version 6." };
@@ -50534,7 +51789,7 @@ function agentWsEvents(deps) {
   };
 }
 // ../server/src/conversations/conversations-routes.ts
-import { randomUUID as randomUUID24 } from "crypto";
+import { randomUUID as randomUUID26 } from "crypto";
 
 // ../server/src/http/pagination.ts
 function encodeCursor(scope, value) {
@@ -50648,7 +51903,7 @@ function registerConversationRoutes({
     await store.deleteConversation(workspace.id, at);
     if (previous?.status !== "deleted") {
       await store.appendEvent(workspace.id, "workspace.conversation_deleted", {
-        id: randomUUID24(),
+        id: randomUUID26(),
         type: "workspace.conversation_deleted",
         occurred_at: at.toISOString(),
         workspace_id: workspace.id
@@ -50846,7 +52101,9 @@ var HEALTHY_CHECKS = {
   database: "ok",
   schema: "ok",
   reconciliation: "ok",
-  coordinator: "ok"
+  coordinator: "ok",
+  "policy-reconciliation": "disabled",
+  cleanup: "ok"
 };
 
 class Readiness {
@@ -51090,6 +52347,40 @@ function registerCheckpointRoutes(deps) {
   });
 }
 
+// ../server/src/persistence/purge-routes.ts
+function registerPurgeRoutes(app, persistence2) {
+  app.openapi(createRoute({
+    method: "post",
+    path: "/v1/workspaces/{id}/purge",
+    operationId: "purgeWorkspace",
+    tags: ["Workspaces"],
+    middleware: [
+      requireScope("workspaces:purge"),
+      bodyLimit({
+        maxSize: 1024,
+        onError: () => {
+          throw new ApiError("validation.invalid", "Purge requires an empty JSON object.");
+        }
+      })
+    ],
+    request: {
+      params: exports_external.object({ id: exports_external.uuid() }),
+      headers: IdempotencyHeadersSchema,
+      body: { content: { "application/json": { schema: exports_external.strictObject({}) } } }
+    },
+    responses: {
+      202: {
+        description: "Durable purge accepted",
+        content: { "application/json": { schema: OperationResourceSchema } }
+      },
+      ...COMMON_ERROR_RESPONSES
+    }
+  }), async (c) => {
+    const operation = await persistence2.purge(c.get("principal"), c.req.valid("param").id, c.req.valid("header")["Idempotency-Key"]);
+    return c.json(toOperationResource(operation), 202);
+  });
+}
+
 // ../server/src/persistence/recovery-routes.ts
 function registerRecoveryRoutes({
   app,
@@ -51201,6 +52492,14 @@ function registerRecoveryRoutes({
 
 // ../server/src/relay/relay.ts
 var SAFE_RESPONSE_HEADERS = ["content-type", "cache-control"];
+function assertRelayReady(row) {
+  if (row.purgeRequestedAt)
+    throw new ApiError("operation.conflict", "Workspace content is being purged.");
+  if (isTerminal(row.state))
+    throw new ApiError("workspace.terminal", "This workspace has ended.");
+  if (row.state !== "ready")
+    throw new ApiError("workspace.not_ready", "Workspace is not ready.");
+}
 function requestPath(c, prefix) {
   const rawPath = c.req.path.startsWith(prefix) ? c.req.path.slice(prefix.length) : "";
   return rawPath === "" ? "/" : rawPath;
@@ -51299,12 +52598,7 @@ function relayHandler(deps, options) {
     const id = c.req.param("id") ?? "";
     const serviceName = options?.service ?? c.req.param("service") ?? "";
     const row = await deps.service.getOwned(principal, id);
-    if (isTerminal(row.state)) {
-      throw new ApiError("workspace.terminal", "This workspace has ended.");
-    }
-    if (row.state !== "ready") {
-      throw new ApiError("workspace.not_ready", "Workspace is not ready.");
-    }
+    assertRelayReady(row);
     const prefix = options?.pathPrefix?.(id) ?? `/v1/workspaces/${id}/services/${serviceName}`;
     const path = requestPath(c, prefix);
     const method = c.req.method;
@@ -51316,6 +52610,8 @@ function relayHandler(deps, options) {
     let bodyB64 = await requestBody(c, method, match2.route.maxRequestBytes);
     if (options?.transformBodyB64)
       bodyB64 = await options.transformBodyB64(c, bodyB64);
+    if ((await deps.store.getWorkspace(id))?.purgeRequestedAt)
+      throw new ApiError("operation.conflict", "Workspace content is being purged.");
     if (!deps.hub.isConnected(id)) {
       throw new ApiError("workspace.disconnected", "The workspace supervisor is not currently connected.");
     }
@@ -51425,7 +52721,7 @@ function registerCatalogRoutes({ app, store }) {
 }
 
 // ../server/src/terminals/terminal-ws.ts
-import { randomUUID as randomUUID25 } from "crypto";
+import { randomUUID as randomUUID27 } from "crypto";
 var SessionIdSchema = exports_external.uuid();
 function terminalConnectValidator(deps) {
   return async (c, next) => {
@@ -51438,6 +52734,8 @@ function terminalConnectValidator(deps) {
 async function terminalCapability(deps, c) {
   const workspaceId = c.req.param("id") ?? "";
   const workspace = await deps.service.getOwned(c.get("principal"), workspaceId);
+  if (workspace.purgeRequestedAt)
+    throw new ApiError("operation.conflict", "Workspace content is being purged.");
   if (isTerminal(workspace.state)) {
     throw new ApiError("workspace.terminal", "This workspace has ended.");
   }
@@ -51466,7 +52764,7 @@ async function terminalSession(deps, c, workspaceId, maxSessions) {
   if (c.req.header("upgrade")?.toLowerCase() !== "websocket") {
     throw new ApiError("validation.invalid", "WebSocket upgrade required.");
   }
-  const sessionId = parsedSessionId?.data ?? randomUUID25();
+  const sessionId = parsedSessionId?.data ?? randomUUID27();
   if (requested) {
     const session2 = await deps.store.getTerminalSession(sessionId);
     if (!session2 || session2.workspaceId !== workspaceId) {
@@ -51769,6 +53067,7 @@ function buildServer(deps) {
   }) : undefined;
   const persistenceHolder = {};
   const scheduler = new Scheduler({
+    ...deps.authorizeLaunch ? { authorizeLaunch: deps.authorizeLaunch } : {},
     store,
     driver,
     ...deps.storageDriver ? { storageDriver: deps.storageDriver } : {},
@@ -51869,9 +53168,12 @@ function buildServer(deps) {
   });
   app.use("/v1/*", machineAuth(store, pepper));
   registerCatalogRoutes({ app, store });
+  registerKeyRoutes(app, store, pepper);
+  registerOperatorRecoveryRoutes(app, store, persistence2);
   registerAdministrationRoutes({ app, persistence: persistence2, warmPool });
   registerCheckpointRoutes({ app, store, service, persistence: persistence2 });
   registerRecoveryRoutes({ app, store, service, persistence: persistence2 });
+  registerPurgeRoutes(app, persistence2);
   registerConversationRoutes({ app, store, service });
   registerWorkspaceRoutes({ app, store, service });
   registerDiagnosticRoutes({ app, store, service });
@@ -51907,6 +53209,98 @@ function buildServer(deps) {
   };
 }
 
+// ../server/src/lifecycle/policy-reconciliation.ts
+import { readFileSync as readFileSync5 } from "fs";
+
+class PolicyReconciliation {
+  store;
+  url;
+  token;
+  active;
+  constructor(store, url2, token) {
+    this.store = store;
+    this.url = url2;
+    this.token = token;
+  }
+  async post(path, body) {
+    try {
+      const response = await fetch(`${this.url.replace(/\/$/, "")}/${path}`, {
+        method: "POST",
+        redirect: "error",
+        signal: AbortSignal.timeout(5000),
+        headers: { authorization: `Bearer ${this.token}`, "content-type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok)
+        throw new Error("policy response");
+      return await response.json();
+    } catch {
+      throw new Error("Policy reconciliation unavailable");
+    }
+  }
+  tick() {
+    this.active ??= this.reconcile().finally(() => {
+      this.active = undefined;
+    });
+    return this.active;
+  }
+  async drain() {
+    await this.active?.catch(() => {});
+  }
+  async reconcile() {
+    const pending = await this.post("pending", {});
+    if (typeof pending !== "object" || pending === null || !("workspace_ids" in pending) || !Array.isArray(pending.workspace_ids)) {
+      throw new Error("Invalid policy reconciliation response");
+    }
+    let failed = false;
+    for (const id of pending.workspace_ids) {
+      try {
+        if (typeof id !== "string")
+          throw new Error("Invalid workspace identity");
+        const row = await this.store.getWorkspace(id);
+        if (!row)
+          throw new Error("Missing reconciliation workspace");
+        const ref = row.providerRef;
+        const result = await this.post("reconcile", {
+          workspace_id: row.id,
+          principal_id: row.principalId,
+          external_id: row.externalId,
+          template_name: row.templateName,
+          launch_mode: row.launchMode,
+          metadata: row.metadata,
+          state: row.state,
+          reason_code: row.reasonCode,
+          launch_attempts: row.launchAttempts,
+          provider_kind: row.providerKind,
+          provider_ref: ref ? {
+            id: ref.id,
+            namespace: ref.namespace,
+            poolRuntimeId: ref.poolRuntimeId,
+            terminationEvidence: ref.terminationEvidence
+          } : null
+        });
+        if (typeof result !== "object" || result === null || !("workspace_id" in result) || result.workspace_id !== row.id || !("released" in result) || typeof result.released !== "boolean") {
+          throw new Error("Invalid policy reconciliation response");
+        }
+        if ("reason" in result && ["termination-unproven", "provider-unavailable"].includes(String(result.reason)))
+          failed = true;
+      } catch {
+        failed = true;
+      }
+    }
+    if (failed)
+      throw new Error("Policy reconciliation unavailable or termination unproven");
+  }
+}
+function loadPolicyReconciliation(store, config2) {
+  if (!config2)
+    return;
+  const token = readFileSync5(config2.tokenFile, "utf8").trim();
+  if (token.length < 24 || /\s/.test(token))
+    throw new Error("Invalid launch policy control token");
+  return new PolicyReconciliation(store, config2.url, token);
+}
+
 // ../server/src/lifecycle/lifecycle.ts
 var defaultLog = (message) => console.log(`[pocketcoder-server] ${message}`);
 async function initializeStore(config2, log) {
@@ -51944,6 +53338,7 @@ function createWorkspaceDriver(config2) {
     return new KubernetesDriver({
       ...egress,
       namespace: config2.kubernetesNamespace,
+      captureTerminationEvidence: Boolean(config2.launchPolicy),
       nodeSelector: config2.kubernetesNodeSelector ?? undefined,
       tolerations: config2.kubernetesTolerations,
       ...config2.kubernetesServiceAccount ? { serviceAccountName: config2.kubernetesServiceAccount } : {}
@@ -52006,6 +53401,7 @@ function startExclusiveTimer(intervalMs, task, errorContext, log) {
 }
 async function startPocketCoderServer(config2 = loadConfig(), options = {}) {
   const log = options.log ?? defaultLog;
+  const authorizeLaunch = loadLaunchPolicy(config2.launchPolicy);
   const logger = createStructuredLogger((record3) => log(JSON.stringify(record3)));
   const metrics = new RuntimeMetrics;
   log(`config: ${JSON.stringify(configSummary(config2))}`);
@@ -52021,7 +53417,11 @@ async function startPocketCoderServer(config2 = loadConfig(), options = {}) {
     const storageDriver = createStorageDriver(config2);
     const secretResolver = createSecretResolver(config2);
     const readiness = new Readiness({ reconciliation: "pending" }, metrics);
+    const policyReconciliation = loadPolicyReconciliation(store, config2.launchPolicy);
+    if (policyReconciliation)
+      readiness.set("policy-reconciliation", "pending");
     const { app, websocket: websocket2, scheduler, persistence: persistence2, warmPool } = buildServer({
+      ...authorizeLaunch ? { authorizeLaunch } : {},
       store,
       driver,
       ...storageDriver ? { storageDriver } : {},
@@ -52048,6 +53448,9 @@ async function startPocketCoderServer(config2 = loadConfig(), options = {}) {
     const schedulerTimer = startExclusiveTimer(config2.schedulerIntervalMs, async () => {
       try {
         await scheduler.tick();
+        const pendingPurges = await persistence2.retryPurges();
+        readiness.set("cleanup", pendingPurges > 0 ? "pending" : "ok");
+        metrics.observe("purge.pending", pendingPurges);
         readiness.set("coordinator", "ok");
       } catch (error51) {
         readiness.set("coordinator", "failed");
@@ -52055,6 +53458,15 @@ async function startPocketCoderServer(config2 = loadConfig(), options = {}) {
       }
     }, "scheduler tick failed", log);
     const outboxTimer = startExclusiveTimer(config2.outboxIntervalMs, () => outbox2.tick(), "outbox tick failed", log);
+    const policyTimer = policyReconciliation ? startExclusiveTimer(config2.schedulerIntervalMs, async () => {
+      try {
+        await policyReconciliation.tick();
+        readiness.set("policy-reconciliation", "ok");
+      } catch (error51) {
+        readiness.set("policy-reconciliation", "failed");
+        throw error51;
+      }
+    }, "policy reconciliation failed", log) : null;
     const warmPoolTimer = warmPool && warmPoolContinuously ? startExclusiveTimer(config2.schedulerIntervalMs, () => warmPool.reconcile(), "warm pool reconciliation failed", log) : null;
     const retentionTimer = startExclusiveTimer(60000, async () => {
       const { deleted, skipped } = await persistence2.pruneExpired();
@@ -52075,6 +53487,9 @@ async function startPocketCoderServer(config2 = loadConfig(), options = {}) {
       clearInterval(schedulerTimer);
       clearInterval(outboxTimer);
       clearInterval(retentionTimer);
+      if (policyTimer)
+        clearInterval(policyTimer);
+      await policyReconciliation?.drain();
       if (warmPoolTimer)
         clearInterval(warmPoolTimer);
       throw error51;
@@ -52096,6 +53511,9 @@ async function startPocketCoderServer(config2 = loadConfig(), options = {}) {
           clearInterval(schedulerTimer);
           clearInterval(outboxTimer);
           clearInterval(retentionTimer);
+          if (policyTimer)
+            clearInterval(policyTimer);
+          await policyReconciliation?.drain();
           if (warmPoolTimer)
             clearInterval(warmPoolTimer);
           await server.stop(true);
@@ -52146,7 +53564,7 @@ function stateFromJson(value) {
 }
 function readState() {
   try {
-    return stateFromJson(JSON.parse(readFileSync4(statePath(), "utf8")));
+    return stateFromJson(JSON.parse(readFileSync6(statePath(), "utf8")));
   } catch {
     return null;
   }
@@ -52154,7 +53572,7 @@ function readState() {
 function writeState(state) {
   const path = statePath();
   mkdirSync(dirname7(path), { recursive: true, mode: 448 });
-  const temporary = `${path}.${process.pid}.${randomUUID26()}.tmp`;
+  const temporary = `${path}.${process.pid}.${randomUUID28()}.tmp`;
   writeFileSync(temporary, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
   renameSync(temporary, path);
@@ -52226,7 +53644,7 @@ function selfInvocation(args) {
 }
 function logTail(path) {
   try {
-    const content = readFileSync4(path, "utf8");
+    const content = readFileSync6(path, "utf8");
     return content.slice(Math.max(0, content.length - 4000)).trim();
   } catch {
     return "";
@@ -52263,7 +53681,7 @@ async function startManagedServer(options) {
   if (existing)
     removeState();
   const config2 = loadConfig();
-  const instanceToken = randomUUID26();
+  const instanceToken = randomUUID28();
   const state = {
     version: 1,
     pid: 0,
@@ -52442,7 +53860,7 @@ function addStorageCommands(parser2) {
 }
 
 // src/commands/templates/list.ts
-function addListCommand4(parser2) {
+function addListCommand5(parser2) {
   return addAction(parser2, "list", "List authorized template versions through the REST API", (command2) => command2.option("json", { type: "boolean", description: "Print JSON" }), async (flags) => {
     const items = await controlPlaneClient().templates.list();
     if (flags.json)
@@ -52535,7 +53953,7 @@ function addValidateCommand(parser2) {
 
 // src/commands/templates/index.ts
 function addTemplateCommands(parser2) {
-  return addResource(parser2, "templates", "Validate and inspect templates", (commands) => addListDatabaseCommand(addListCommand4(addRenderCommand(addValidateCommand(commands)))));
+  return addResource(parser2, "templates", "Validate and inspect templates", (commands) => addListDatabaseCommand(addListCommand5(addRenderCommand(addValidateCommand(commands)))));
 }
 
 // src/commands/workspaces/chat-session.ts
@@ -52567,8 +53985,8 @@ async function waitForAgentInput(id, options, deps) {
 }
 
 // src/commands/workspaces/attachments.ts
-import { randomUUID as randomUUID27 } from "crypto";
-import { readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { randomUUID as randomUUID29 } from "crypto";
+import { readFileSync as readFileSync7, statSync as statSync4 } from "fs";
 import { basename as basename2, extname as extname2 } from "path";
 var MEDIA_TYPES = {
   ".csv": "text/csv",
@@ -52600,12 +54018,12 @@ async function uploadAttachments(api3, workspaceId, paths, log) {
     const name2 = basename2(path);
     let bytes;
     try {
-      bytes = readFileSync5(path);
+      bytes = readFileSync7(path);
     } catch {
       throw new Error(`could not read attachment file: ${path}`);
     }
     log(`uploading ${name2} (${bytes.byteLength} bytes)`);
-    const id = randomUUID27();
+    const id = randomUUID29();
     const response = await api3(`/v1/workspaces/${workspaceId}/attachments/${id}`, {
       method: "PUT",
       headers: {
@@ -52673,7 +54091,7 @@ function fileFlags(value) {
 }
 
 // src/commands/workspaces/chat-cursor.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname8, join as join10 } from "path";
 function cursorFile() {
@@ -52682,7 +54100,7 @@ function cursorFile() {
 }
 function readCursors(path) {
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return {};
   }
@@ -53050,7 +54468,7 @@ function addChatCommand(parser2) {
 }
 
 // src/commands/workspaces/create.ts
-import { randomUUID as randomUUID28 } from "crypto";
+import { randomUUID as randomUUID30 } from "crypto";
 
 // src/commands/workspaces/launch-input.ts
 function parseLaunchInput(value, fail2) {
@@ -53157,7 +54575,7 @@ async function waitForReady(initial, flags, { client, fail: failCommand }) {
 }
 async function createWorkspace(flags, deps) {
   const template = required2(flags, "template", deps.fail);
-  const externalId = typeof flags["external-id"] === "string" ? flags["external-id"] : `pcd-${randomUUID28()}`;
+  const externalId = typeof flags["external-id"] === "string" ? flags["external-id"] : `pcd-${randomUUID30()}`;
   const launchInput = parseLaunchInput(flags.input, deps.fail);
   const created = await deps.client.workspaces.create({
     externalId,
@@ -53226,7 +54644,7 @@ async function listWorkspaces(flags) {
   else
     printWorkspaces(items);
 }
-function addListCommand5(parser2) {
+function addListCommand6(parser2) {
   return addAction(parser2, "list", "List workspaces", (command2) => command2.option("active", { type: "boolean", description: "Only show nonterminal workspaces" }).option("state", { type: "string", description: "Filter by state" }).option("template", { type: "string", description: "Filter by template name" }).option("external-id", { type: "string", description: "Filter by external ID" }).option("limit", { type: "string", description: "Maximum number of workspaces" }).option("json", { type: "boolean", description: "Print JSON" }), listWorkspaces);
 }
 
@@ -53269,14 +54687,29 @@ function addOutputsCommand(parser2) {
 }
 
 // src/commands/workspaces/preserve.ts
-import { randomUUID as randomUUID29 } from "crypto";
+import { randomUUID as randomUUID31 } from "crypto";
 function addPreserveCommand(parser2) {
   return addAction(parser2, "preserve", "Stop and checkpoint a persistence-enabled workspace", (command2) => command2.option("id", { type: "string", demandOption: true, description: "Workspace ID" }).option("retention", { type: "string" }).option("label", { type: "string" }), async (flags) => {
     const id = need(flags, "id");
     const result = await controlPlaneClient().workspaces.preserve(id, {
       ...typeof flags.retention === "string" ? { retention: flags.retention } : {},
       ...typeof flags.label === "string" ? { label: flags.label } : {}
-    }, `preserve-${id}-${randomUUID29()}`);
+    }, `preserve-${id}-${randomUUID31()}`);
+    console.log(JSON.stringify(result, null, 2));
+  });
+}
+
+// src/commands/workspaces/purge.ts
+function addPurgeCommand(parser2) {
+  return addAction(parser2, "purge", "Purge owned workspace content and return a durable operation", (command2) => command2.option("id", { type: "string", demandOption: true, description: "Workspace ID" }).option("request-id", {
+    type: "string",
+    demandOption: true,
+    description: "Stable request ID; use a new ID for backup replay"
+  }).option("principal-id", { type: "string", description: "Explicit target for delegated operator recovery" }), async (flags) => {
+    const client = controlPlaneClient();
+    const id = need(flags, "id");
+    const key = need(flags, "request-id");
+    const result = typeof flags["principal-id"] === "string" ? await client.recovery.purge(flags["principal-id"], id, key) : await client.workspaces.purge(id, key);
     console.log(JSON.stringify(result, null, 2));
   });
 }
@@ -53451,7 +54884,7 @@ function addTerminalSessionsCommand(parser2) {
 // src/commands/workspaces/index.ts
 function addWorkspaceCommands(parser2) {
   const actions = [
-    addListCommand5,
+    addListCommand6,
     addCreateCommand2,
     addGetCommand2,
     addLogsCommand,
@@ -53460,6 +54893,7 @@ function addWorkspaceCommands(parser2) {
     addTerminalCommand,
     addCancelCommand,
     addPreserveCommand,
+    addPurgeCommand,
     addRestoreCommand,
     addRecreateCommand,
     addOutputsCommand,