openmates 0.27.0-alpha.2 → 0.27.0-alpha.21

package/dist/chunk-4IRYB3YN.js

@@ -0,0 +1,1320 @@
+// src/tasksCli.ts
+import { createHash as createHash2, createHmac as createHmac3, hkdfSync as hkdfSync2, randomBytes, randomUUID } from "crypto";
+
+// src/crypto.ts
+import { webcrypto, createHash, createHmac } from "crypto";
+import { argon2id } from "hash-wasm";
+import nacl from "tweetnacl";
+var cryptoApi = globalThis.crypto ?? webcrypto;
+var SIGNUP_KDF_ITERATIONS = 1e5;
+var PASSWORD_KDF_V2 = Object.freeze({
+  version: 2,
+  algorithm: "argon2id",
+  memoryKiB: 65536,
+  iterations: 3,
+  parallelism: 1,
+  hashLength: 32
+});
+var AES_GCM_IV_LENGTH = 12;
+var EMAIL_SALT_LENGTH = 16;
+var MASTER_KEY_LENGTH = 32;
+var NACL_NONCE_LENGTH = 24;
+var CIPHERTEXT_MAGIC_0 = 79;
+var CIPHERTEXT_MAGIC_1 = 77;
+var FINGERPRINT_LENGTH = 4;
+var CIPHERTEXT_HEADER_LENGTH = 2 + FINGERPRINT_LENGTH;
+var API_KEY_PREFIX = "sk-api-";
+var API_KEY_RANDOM_LENGTH = 32;
+var API_KEY_CHARS = "ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456789";
+var CHAT_RECOVERY_PROTOCOL_VERSION = 1;
+var CHAT_RECOVERY_MAX_PAYLOAD_BYTES = 16 * 1024 * 1024;
+var CHAT_RECOVERY_KEY_BYTES = 32;
+var CHAT_RECOVERY_NONCE_BYTES = 12;
+var CHAT_RECOVERY_AAD_PREFIX = new TextEncoder().encode("OMCR1");
+var CHAT_RECOVERY_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function base64ToBytes(input) {
+  return new Uint8Array(Buffer.from(input, "base64"));
+}
+function bytesToBase64(input) {
+  return Buffer.from(input).toString("base64");
+}
+function bytesToBase64Url(input) {
+  return Buffer.from(input).toString("base64url");
+}
+function toArrayBuffer(input) {
+  const output = new ArrayBuffer(input.byteLength);
+  new Uint8Array(output).set(input);
+  return output;
+}
+function base64UrlToBytes(input, field, expectedLength) {
+  if (!input || input.includes("=")) {
+    throw new Error(`${field} must be non-empty unpadded base64url`);
+  }
+  const decoded = new Uint8Array(Buffer.from(input, "base64url"));
+  if (bytesToBase64Url(decoded) !== input) {
+    throw new Error(`${field} must be canonical base64url`);
+  }
+  if (expectedLength !== void 0 && decoded.length !== expectedLength) {
+    throw new Error(`${field} must decode to ${expectedLength} bytes`);
+  }
+  return decoded;
+}
+async function deriveTeamInviteKey(input) {
+  const secretBytes = base64UrlToBytes(input.inviteSecret, "invite secret", 32);
+  const salt = await sha256(new TextEncoder().encode("openmates:team-invite:v1"));
+  const info = concatBytes(
+    lengthPrefix(new TextEncoder().encode(input.recipientEmail.trim().toLowerCase())),
+    lengthPrefix(new TextEncoder().encode(input.inviteId)),
+    lengthPrefix(new TextEncoder().encode(input.teamId)),
+    lengthPrefix(new TextEncoder().encode(input.origin.replace(/\/$/, "")))
+  );
+  return hkdfSha256(secretBytes, salt, info);
+}
+function uint32(value, field) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw new Error(`${field} must be an unsigned 32-bit integer`);
+  }
+  const encoded = new Uint8Array(4);
+  new DataView(encoded.buffer).setUint32(0, value, false);
+  return encoded;
+}
+function recoveryKeyVersion(value) {
+  if (value === 0) {
+    throw new Error("key_version must be greater than zero");
+  }
+  return uint32(value, "key_version");
+}
+function canonicalUuid(value, field) {
+  if (!CHAT_RECOVERY_UUID_PATTERN.test(value)) {
+    throw new Error(`${field} must be a canonical lowercase UUID`);
+  }
+  return new TextEncoder().encode(value);
+}
+function concatBytes(...values) {
+  const output = new Uint8Array(values.reduce((total, value) => total + value.length, 0));
+  let offset = 0;
+  for (const value of values) {
+    output.set(value, offset);
+    offset += value.length;
+  }
+  return output;
+}
+function lengthPrefix(value) {
+  return concatBytes(uint32(value.length, "length"), value);
+}
+async function sha256(input) {
+  return new Uint8Array(await cryptoApi.subtle.digest("SHA-256", toArrayBuffer(input)));
+}
+async function hkdfSha256(input, salt, info) {
+  const key = await cryptoApi.subtle.importKey("raw", toArrayBuffer(input), "HKDF", false, ["deriveBits"]);
+  const bits = await cryptoApi.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: toArrayBuffer(salt),
+      info: toArrayBuffer(info)
+    },
+    key,
+    256
+  );
+  return new Uint8Array(bits);
+}
+function recoveryOutputAssociatedData(identity) {
+  if (!["message", "embed", "diff", "summary", "checkpoint"].includes(identity.outputKind)) {
+    throw new Error("unsupported recovery output kind");
+  }
+  if (!Number.isSafeInteger(identity.outputVersion) || identity.outputVersion < 1) {
+    throw new Error("output version must be positive");
+  }
+  const subject = new TextEncoder().encode(identity.subjectId);
+  if (!subject.length || subject.length > 255 || Array.from(identity.subjectId).some((character) => character.charCodeAt(0) < 32)) {
+    throw new Error("subjectId must be a bounded stable identifier");
+  }
+  return concatBytes(
+    new TextEncoder().encode("OMCR2"),
+    ...[identity.ownerId, identity.rootChatId, identity.targetChatId, identity.turnId, identity.recordId].map((value) => lengthPrefix(canonicalUuid(value, "recovery_identity"))),
+    lengthPrefix(subject),
+    lengthPrefix(new TextEncoder().encode(identity.outputKind)),
+    recoveryKeyVersion(identity.keyVersion),
+    uint32(identity.outputVersion, "output_version")
+  );
+}
+async function deriveChatCompletionRecoveryKeypair(chatKey, chatId, keyVersion) {
+  const rawChatKey = base64UrlToBytes(chatKey, "chat_key", CHAT_RECOVERY_KEY_BYTES);
+  const salt = await sha256(new TextEncoder().encode("openmates:chat-recovery:v1"));
+  const info = concatBytes(lengthPrefix(canonicalUuid(chatId, "chat_id")), recoveryKeyVersion(keyVersion));
+  const privateKey = await hkdfSha256(rawChatKey, salt, info);
+  return {
+    privateKey: bytesToBase64Url(privateKey),
+    publicKey: bytesToBase64Url(nacl.scalarMult.base(privateKey))
+  };
+}
+function buildRecoveryAssociatedData(values) {
+  const associatedData = concatBytes(
+    CHAT_RECOVERY_AAD_PREFIX,
+    lengthPrefix(canonicalUuid(values.owner_id, "owner_id")),
+    lengthPrefix(canonicalUuid(values.chat_id, "chat_id")),
+    lengthPrefix(canonicalUuid(values.turn_id, "turn_id")),
+    lengthPrefix(canonicalUuid(values.job_id, "job_id")),
+    lengthPrefix(canonicalUuid(values.assistant_message_id, "assistant_message_id")),
+    recoveryKeyVersion(values.key_version)
+  );
+  return bytesToBase64Url(associatedData);
+}
+function recoveryAssociatedData(identity) {
+  return base64UrlToBytes(
+    buildRecoveryAssociatedData({
+      owner_id: identity.ownerId,
+      chat_id: identity.chatId,
+      turn_id: identity.turnId,
+      job_id: identity.jobId,
+      assistant_message_id: identity.assistantMessageId,
+      key_version: identity.keyVersion
+    }),
+    "associated_data"
+  );
+}
+async function recoveryEnvelopeKey(sharedSecret, associatedData) {
+  if (sharedSecret.every((value) => value === 0)) {
+    throw new Error("X25519 shared secret must not be all zero");
+  }
+  const salt = await sha256(new TextEncoder().encode("openmates:chat-recovery-envelope:v1"));
+  return hkdfSha256(sharedSecret, salt, await sha256(associatedData));
+}
+async function openChatCompletionRecoveryEnvelope(envelope, options) {
+  if (!envelope || Object.keys(envelope).sort().join(",") !== "ciphertext,epk,nonce,v" || envelope.v !== CHAT_RECOVERY_PROTOCOL_VERSION) {
+    throw new Error("invalid recovery envelope fields or version");
+  }
+  const recoveryPrivateKey = base64UrlToBytes(
+    options.recoveryPrivateKey,
+    "recovery_private_key",
+    CHAT_RECOVERY_KEY_BYTES
+  );
+  const ephemeralPublicKey = base64UrlToBytes(envelope.epk, "epk", CHAT_RECOVERY_KEY_BYTES);
+  const nonce = base64UrlToBytes(envelope.nonce, "nonce", CHAT_RECOVERY_NONCE_BYTES);
+  const ciphertext = base64UrlToBytes(envelope.ciphertext, "ciphertext");
+  if (ciphertext.length < 16 || ciphertext.length - 16 > CHAT_RECOVERY_MAX_PAYLOAD_BYTES) {
+    throw new Error("ciphertext payload size is invalid");
+  }
+  const associatedData = recoveryAssociatedData(options);
+  const sharedSecret = nacl.scalarMult(recoveryPrivateKey, ephemeralPublicKey);
+  const envelopeKeyBytes = await recoveryEnvelopeKey(sharedSecret, associatedData);
+  const envelopeKey = await cryptoApi.subtle.importKey(
+    "raw",
+    toArrayBuffer(envelopeKeyBytes),
+    { name: "AES-GCM" },
+    false,
+    ["decrypt"]
+  );
+  return new Uint8Array(await cryptoApi.subtle.decrypt(
+    { name: "AES-GCM", iv: toArrayBuffer(nonce), additionalData: toArrayBuffer(associatedData) },
+    envelopeKey,
+    toArrayBuffer(ciphertext)
+  ));
+}
+async function openRecoveryOutputEnvelope(envelope, options) {
+  if (!envelope || Object.keys(envelope).sort().join(",") !== "ciphertext,epk,nonce,v" || envelope.v !== 2) {
+    throw new Error("invalid recovery output envelope fields or version");
+  }
+  const privateKey = base64UrlToBytes(options.recoveryPrivateKey, "recovery_private_key", CHAT_RECOVERY_KEY_BYTES);
+  const epk = base64UrlToBytes(envelope.epk, "epk", CHAT_RECOVERY_KEY_BYTES);
+  const nonce = base64UrlToBytes(envelope.nonce, "nonce", CHAT_RECOVERY_NONCE_BYTES);
+  const ciphertext = base64UrlToBytes(envelope.ciphertext, "ciphertext");
+  if (ciphertext.length < 16 || ciphertext.length - 16 > CHAT_RECOVERY_MAX_PAYLOAD_BYTES) {
+    throw new Error("ciphertext payload size is invalid");
+  }
+  const aad = recoveryOutputAssociatedData(options);
+  const sharedSecret = nacl.scalarMult(privateKey, epk);
+  const keyBytes = await recoveryEnvelopeKey(sharedSecret, aad);
+  const key = await cryptoApi.subtle.importKey("raw", toArrayBuffer(keyBytes), { name: "AES-GCM" }, false, ["decrypt"]);
+  return new Uint8Array(await cryptoApi.subtle.decrypt(
+    { name: "AES-GCM", iv: toArrayBuffer(nonce), additionalData: toArrayBuffer(aad) },
+    key,
+    toArrayBuffer(ciphertext)
+  ));
+}
+function generateSalt(length = EMAIL_SALT_LENGTH) {
+  return cryptoApi.getRandomValues(new Uint8Array(length));
+}
+function generateSecureRecoveryKey(length = 24) {
+  const uppercaseChars = "ABCDEFGHJKLMNPQRSTUVWXYZ";
+  const lowercaseChars = "abcdefghijkmnopqrstuvwxyz";
+  const numberChars = "23456789";
+  const specialChars = "#-=+_&%$";
+  const allChars = uppercaseChars + lowercaseChars + numberChars + specialChars;
+  const result = new Array(length);
+  const requiredSets = [uppercaseChars, lowercaseChars, numberChars, specialChars];
+  for (let index = 0; index < requiredSets.length && index < length; index += 1) {
+    const chars = requiredSets[index];
+    result[index] = chars.charAt(secureRandomIndex(chars.length));
+  }
+  for (let index = requiredSets.length; index < length; index += 1) {
+    result[index] = allChars.charAt(secureRandomIndex(allChars.length));
+  }
+  for (let index = result.length - 1; index > 0; index -= 1) {
+    const swapIndex = secureRandomIndex(index + 1);
+    [result[index], result[swapIndex]] = [result[swapIndex], result[index]];
+  }
+  return result.join("");
+}
+function secureRandomIndex(upperBound) {
+  if (!Number.isInteger(upperBound) || upperBound <= 0 || upperBound > 256) {
+    throw new RangeError("secure random upper bound must be between 1 and 256");
+  }
+  const maxUnbiasedValue = Math.floor(256 / upperBound) * upperBound;
+  while (true) {
+    const value = cryptoApi.getRandomValues(new Uint8Array(1))[0];
+    if (value < maxUnbiasedValue) return value % upperBound;
+  }
+}
+async function hashEmail(email) {
+  const hashBuffer = await cryptoApi.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(email)
+  );
+  return bytesToBase64(new Uint8Array(hashBuffer));
+}
+async function hashKey(key, salt) {
+  const keyBytes = new TextEncoder().encode(key);
+  const dataToHash = salt ? new Uint8Array(keyBytes.length + salt.length) : keyBytes;
+  if (salt) {
+    dataToHash.set(keyBytes);
+    dataToHash.set(salt, keyBytes.length);
+  }
+  const hashBuffer = await cryptoApi.subtle.digest("SHA-256", toArrayBuffer(dataToHash));
+  return bytesToBase64(new Uint8Array(hashBuffer));
+}
+async function deriveKeyFromPassword(password, salt) {
+  const keyMaterial = await cryptoApi.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await cryptoApi.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: toArrayBuffer(salt),
+      iterations: SIGNUP_KDF_ITERATIONS,
+      hash: "SHA-256"
+    },
+    keyMaterial,
+    256
+  );
+  return new Uint8Array(derivedBits);
+}
+async function derivePasswordMaterialV2(password, salt) {
+  if (!password || salt.length < 16) throw new Error("Argon2id password derivation requires a password and at least 16 salt bytes");
+  const output = await argon2id({
+    password,
+    salt,
+    memorySize: PASSWORD_KDF_V2.memoryKiB,
+    iterations: PASSWORD_KDF_V2.iterations,
+    parallelism: PASSWORD_KDF_V2.parallelism,
+    hashLength: PASSWORD_KDF_V2.hashLength,
+    outputType: "binary"
+  });
+  if (!(output instanceof Uint8Array) || output.length !== PASSWORD_KDF_V2.hashLength) {
+    throw new Error("Argon2id password derivation failed");
+  }
+  return output;
+}
+async function derivePasswordKeysV2(password, userEmailSalt) {
+  const material = await derivePasswordMaterialV2(password, userEmailSalt);
+  const hkdfKey = await cryptoApi.subtle.importKey("raw", toArrayBuffer(material), "HKDF", false, ["deriveBits"]);
+  const expand = async (label) => new Uint8Array(await cryptoApi.subtle.deriveBits({
+    name: "HKDF",
+    hash: "SHA-256",
+    salt: new Uint8Array(0),
+    info: new TextEncoder().encode(label)
+  }, hkdfKey, 256));
+  try {
+    return {
+      authKey: await expand("openmates/password-v2/auth"),
+      wrapKey: await expand("openmates/password-v2/wrap")
+    };
+  } finally {
+    material.fill(0);
+  }
+}
+function passwordProofV2(authKey, nonceB64url, purpose) {
+  if (!/^[a-z0-9_]+$/.test(purpose)) throw new Error("Invalid password proof purpose");
+  const nonce = base64UrlToBytes(nonceB64url, "password challenge nonce", 32);
+  return createHmac("sha256", authKey).update(Buffer.from(`openmates/password-v2/proof\0${purpose}\0`, "utf8")).update(nonce).digest("base64url");
+}
+async function unwrapPasswordMasterKey(params) {
+  let wrappingKeyBytes = null;
+  try {
+    const salt = base64ToBytes(params.saltB64);
+    if (params.credentialVersion === 2) {
+      const keys = await derivePasswordKeysV2(params.password, salt);
+      keys.authKey.fill(0);
+      wrappingKeyBytes = keys.wrapKey;
+    } else if (params.credentialVersion == null || params.credentialVersion === 1) {
+      wrappingKeyBytes = await deriveKeyFromPassword(params.password, salt);
+    } else {
+      return null;
+    }
+    const wrappingKey = await cryptoApi.subtle.importKey(
+      "raw",
+      toArrayBuffer(wrappingKeyBytes),
+      { name: "AES-GCM" },
+      false,
+      ["decrypt"]
+    );
+    return new Uint8Array(await cryptoApi.subtle.decrypt(
+      { name: "AES-GCM", iv: toArrayBuffer(base64ToBytes(params.keyIvB64)) },
+      wrappingKey,
+      toArrayBuffer(base64ToBytes(params.encryptedMasterKeyB64))
+    ));
+  } catch {
+    return null;
+  } finally {
+    wrappingKeyBytes?.fill(0);
+  }
+}
+async function encryptEmail(email, key) {
+  if (key.length !== MASTER_KEY_LENGTH) {
+    throw new Error(`Email encryption key must be 32 bytes, got ${key.length}`);
+  }
+  const nonce = nacl.randomBytes(NACL_NONCE_LENGTH);
+  const ciphertext = nacl.secretbox(new TextEncoder().encode(email), nonce, key);
+  const combined = new Uint8Array(nonce.length + ciphertext.length);
+  combined.set(nonce);
+  combined.set(ciphertext, nonce.length);
+  return bytesToBase64(combined);
+}
+async function encryptRawKeyWithAesGcm(rawKey, wrappingKeyBytes) {
+  const iv = cryptoApi.getRandomValues(new Uint8Array(AES_GCM_IV_LENGTH));
+  const wrappingKey = await cryptoApi.subtle.importKey(
+    "raw",
+    toArrayBuffer(wrappingKeyBytes),
+    { name: "AES-GCM" },
+    false,
+    ["encrypt"]
+  );
+  const encrypted = await cryptoApi.subtle.encrypt(
+    { name: "AES-GCM", iv: toArrayBuffer(iv) },
+    wrappingKey,
+    toArrayBuffer(rawKey)
+  );
+  return {
+    wrapped: bytesToBase64(new Uint8Array(encrypted)),
+    iv: bytesToBase64(iv)
+  };
+}
+async function createPasswordMigrationMaterialV2(password, masterKeyB64, userEmailSaltB64) {
+  const userEmailSalt = base64ToBytes(userEmailSaltB64);
+  const { authKey, wrapKey } = await derivePasswordKeysV2(password, userEmailSalt);
+  try {
+    const wrapper = await encryptRawKeyWithAesGcm(base64ToBytes(masterKeyB64), wrapKey);
+    return {
+      oldLookupHash: await hashKey(password, userEmailSalt),
+      passwordAuthKey: Buffer.from(authKey).toString("base64url"),
+      encryptedMasterKey: wrapper.wrapped,
+      saltB64: userEmailSaltB64,
+      keyIv: wrapper.iv
+    };
+  } finally {
+    authKey.fill(0);
+    wrapKey.fill(0);
+  }
+}
+async function createSignupCryptoMaterial(email, password) {
+  const normalizedEmail = email.trim().toLowerCase();
+  const emailSalt = generateSalt(EMAIL_SALT_LENGTH);
+  const masterKey = generateSalt(MASTER_KEY_LENGTH);
+  const emailEncryptionKeyB64 = await deriveEmailEncryptionKeyB64(normalizedEmail, bytesToBase64(emailSalt));
+  const emailEncryptionKey = base64ToBytes(emailEncryptionKeyB64);
+  const { authKey, wrapKey } = await derivePasswordKeysV2(password, emailSalt);
+  const encryptedMasterKey = await encryptRawKeyWithAesGcm(masterKey, wrapKey);
+  const passwordAuthKey = Buffer.from(authKey).toString("base64url");
+  authKey.fill(0);
+  wrapKey.fill(0);
+  return {
+    hashedEmail: await hashEmail(normalizedEmail),
+    encryptedEmail: await encryptEmail(normalizedEmail, emailEncryptionKey),
+    encryptedEmailWithMasterKey: await encryptWithAesGcmCombined(normalizedEmail, masterKey),
+    userEmailSaltB64: bytesToBase64(emailSalt),
+    emailEncryptionKeyB64,
+    masterKeyB64: bytesToBase64(masterKey),
+    encryptedMasterKey: encryptedMasterKey.wrapped,
+    keyIv: encryptedMasterKey.iv,
+    saltB64: bytesToBase64(emailSalt),
+    credentialVersion: 2,
+    passwordAuthKey
+  };
+}
+async function createRecoveryKeyMaterial(masterKeyB64, userEmailSaltB64) {
+  const recoveryKey = generateSecureRecoveryKey();
+  const userEmailSalt = base64ToBytes(userEmailSaltB64);
+  const wrappingSalt = generateSalt(EMAIL_SALT_LENGTH);
+  const wrappingKey = await deriveKeyFromPassword(recoveryKey, wrappingSalt);
+  const encryptedMasterKey = await encryptRawKeyWithAesGcm(base64ToBytes(masterKeyB64), wrappingKey);
+  return {
+    recoveryKey,
+    lookupHash: await hashKey(recoveryKey, userEmailSalt),
+    wrappedMasterKey: encryptedMasterKey.wrapped,
+    keyIv: encryptedMasterKey.iv,
+    saltB64: bytesToBase64(wrappingSalt)
+  };
+}
+function splitApiKeyCredential(value) {
+  const [bearer, decryptionSecret, extra] = value.split(".");
+  if (extra || decryptionSecret !== void 0 && !decryptionSecret) {
+    throw new Error("Invalid API key setup credential");
+  }
+  return { bearer, decryptionSecret: decryptionSecret ?? null };
+}
+function generateApiKey() {
+  let result = API_KEY_PREFIX;
+  const maxUnbiasedValue = Math.floor(256 / API_KEY_CHARS.length) * API_KEY_CHARS.length;
+  while (result.length < API_KEY_PREFIX.length + API_KEY_RANDOM_LENGTH) {
+    const randomValues = cryptoApi.getRandomValues(new Uint8Array(API_KEY_RANDOM_LENGTH));
+    for (const value of randomValues) {
+      if (value >= maxUnbiasedValue) continue;
+      result += API_KEY_CHARS.charAt(value % API_KEY_CHARS.length);
+      if (result.length >= API_KEY_PREFIX.length + API_KEY_RANDOM_LENGTH) break;
+    }
+  }
+  return result;
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+async function createApiKeyCryptoMaterial(name, masterKeyB64) {
+  const masterKey = base64ToBytes(masterKeyB64);
+  const bearer = generateApiKey();
+  const decryptionSecret = generateApiKey().slice(API_KEY_PREFIX.length);
+  const apiKey = `${bearer}.${decryptionSecret}`;
+  const keyPrefix = `${bearer.slice(0, 12)}...`;
+  const wrappingSalt = generateSalt(EMAIL_SALT_LENGTH);
+  const wrappingKey = await deriveKeyFromPassword(decryptionSecret, wrappingSalt);
+  const encryptedMasterKey = await encryptRawKeyWithAesGcm(masterKey, wrappingKey);
+  return {
+    apiKey,
+    apiKeyHash: sha256Hex(bearer),
+    encryptedName: await encryptWithAesGcmCombined(name.trim(), masterKey),
+    encryptedKeyPrefix: await encryptWithAesGcmCombined(keyPrefix, masterKey),
+    encryptedMasterKey: encryptedMasterKey.wrapped,
+    keyIv: encryptedMasterKey.iv,
+    saltB64: bytesToBase64(wrappingSalt)
+  };
+}
+async function unwrapApiKeyMasterKey(params) {
+  try {
+    const { decryptionSecret } = splitApiKeyCredential(params.apiKey);
+    const wrappingKeyBytes = await deriveKeyFromPassword(decryptionSecret ?? params.apiKey, base64ToBytes(params.saltB64));
+    const wrappingKey = await cryptoApi.subtle.importKey(
+      "raw",
+      toArrayBuffer(wrappingKeyBytes),
+      { name: "AES-GCM" },
+      false,
+      ["decrypt"]
+    );
+    const decrypted = await cryptoApi.subtle.decrypt(
+      { name: "AES-GCM", iv: toArrayBuffer(base64ToBytes(params.keyIvB64)) },
+      wrappingKey,
+      toArrayBuffer(base64ToBytes(params.encryptedMasterKeyB64))
+    );
+    return new Uint8Array(decrypted);
+  } catch {
+    return null;
+  }
+}
+async function decryptWithAesGcmCombined(encryptedWithIvB64, rawKeyBytes, associatedData) {
+  try {
+    const combined = base64ToBytes(encryptedWithIvB64);
+    if (combined.length <= AES_GCM_IV_LENGTH) {
+      return null;
+    }
+    let offset = 0;
+    if (combined.length > CIPHERTEXT_HEADER_LENGTH + AES_GCM_IV_LENGTH && combined[0] === CIPHERTEXT_MAGIC_0 && combined[1] === CIPHERTEXT_MAGIC_1) {
+      offset = CIPHERTEXT_HEADER_LENGTH;
+    }
+    const iv = combined.slice(offset, offset + AES_GCM_IV_LENGTH);
+    const ciphertext = combined.slice(offset + AES_GCM_IV_LENGTH);
+    const key = await cryptoApi.subtle.importKey(
+      "raw",
+      toArrayBuffer(rawKeyBytes),
+      { name: "AES-GCM" },
+      false,
+      ["decrypt"]
+    );
+    const decrypted = await cryptoApi.subtle.decrypt(
+      {
+        name: "AES-GCM",
+        iv: toArrayBuffer(iv),
+        ...associatedData ? { additionalData: toArrayBuffer(new TextEncoder().encode(associatedData)) } : {}
+      },
+      key,
+      toArrayBuffer(ciphertext)
+    );
+    return new TextDecoder().decode(decrypted);
+  } catch {
+    return null;
+  }
+}
+async function deriveEmailEncryptionKeyB64(email, emailSaltB64) {
+  const encoder = new TextEncoder();
+  const emailBytes = encoder.encode(email);
+  const saltBytes = base64ToBytes(emailSaltB64);
+  const combined = new Uint8Array(emailBytes.length + saltBytes.length);
+  combined.set(emailBytes);
+  combined.set(saltBytes, emailBytes.length);
+  const hashBuffer = await cryptoApi.subtle.digest("SHA-256", toArrayBuffer(combined));
+  return bytesToBase64(new Uint8Array(hashBuffer));
+}
+async function decryptBytesWithAesGcm(encryptedWithIvB64, rawKeyBytes) {
+  try {
+    const combined = base64ToBytes(encryptedWithIvB64);
+    if (combined.length <= AES_GCM_IV_LENGTH) {
+      return null;
+    }
+    let offset = 0;
+    if (combined.length > CIPHERTEXT_HEADER_LENGTH + AES_GCM_IV_LENGTH && combined[0] === CIPHERTEXT_MAGIC_0 && combined[1] === CIPHERTEXT_MAGIC_1) {
+      offset = CIPHERTEXT_HEADER_LENGTH;
+    }
+    const iv = combined.slice(offset, offset + AES_GCM_IV_LENGTH);
+    const ciphertext = combined.slice(offset + AES_GCM_IV_LENGTH);
+    const key = await cryptoApi.subtle.importKey(
+      "raw",
+      toArrayBuffer(rawKeyBytes),
+      { name: "AES-GCM" },
+      false,
+      ["decrypt"]
+    );
+    const decrypted = await cryptoApi.subtle.decrypt(
+      { name: "AES-GCM", iv: toArrayBuffer(iv) },
+      key,
+      toArrayBuffer(ciphertext)
+    );
+    return new Uint8Array(decrypted);
+  } catch {
+    return null;
+  }
+}
+async function deriveEmbedKeyFromChatKey(chatKey, embedId) {
+  const hkdfKey = await cryptoApi.subtle.importKey(
+    "raw",
+    toArrayBuffer(new Uint8Array(chatKey)),
+    "HKDF",
+    false,
+    ["deriveBits"]
+  );
+  const salt = new TextEncoder().encode("openmates-embed-key-v1");
+  const info = new TextEncoder().encode(embedId);
+  const derivedBits = await cryptoApi.subtle.deriveBits(
+    { name: "HKDF", hash: "SHA-256", salt: toArrayBuffer(salt), info: toArrayBuffer(info) },
+    hkdfKey,
+    256
+  );
+  return new Uint8Array(derivedBits);
+}
+async function encryptBytesWithAesGcm(data, rawKeyBytes) {
+  const iv = cryptoApi.getRandomValues(new Uint8Array(AES_GCM_IV_LENGTH));
+  const key = await cryptoApi.subtle.importKey(
+    "raw",
+    toArrayBuffer(rawKeyBytes),
+    { name: "AES-GCM" },
+    false,
+    ["encrypt"]
+  );
+  const encrypted = await cryptoApi.subtle.encrypt(
+    { name: "AES-GCM", iv: toArrayBuffer(iv) },
+    key,
+    toArrayBuffer(data)
+  );
+  const cipherBytes = new Uint8Array(encrypted);
+  const combined = new Uint8Array(iv.length + cipherBytes.length);
+  combined.set(iv);
+  combined.set(cipherBytes, iv.length);
+  return bytesToBase64(combined);
+}
+async function encryptWithAesGcmCombined(plaintext, rawKeyBytes, associatedData) {
+  const iv = cryptoApi.getRandomValues(new Uint8Array(AES_GCM_IV_LENGTH));
+  const key = await cryptoApi.subtle.importKey(
+    "raw",
+    toArrayBuffer(rawKeyBytes),
+    { name: "AES-GCM" },
+    false,
+    ["encrypt"]
+  );
+  const encrypted = await cryptoApi.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv: toArrayBuffer(iv),
+      ...associatedData ? { additionalData: toArrayBuffer(new TextEncoder().encode(associatedData)) } : {}
+    },
+    key,
+    new TextEncoder().encode(plaintext)
+  );
+  const cipherBytes = new Uint8Array(encrypted);
+  const combined = new Uint8Array(iv.length + cipherBytes.length);
+  combined.set(iv);
+  combined.set(cipherBytes, iv.length);
+  return bytesToBase64(combined);
+}
+function hashItemKey(appId, itemKey) {
+  const raw = `${appId}-${itemKey}-${Date.now()}`;
+  return createHash("sha256").update(raw).digest("hex").slice(0, 32);
+}
+
+// src/objectSlugs.ts
+import { createHmac as createHmac2, hkdfSync } from "crypto";
+var SLUG_LOOKUP_HASH_INFO = "openmates-object-slug-index-v1";
+var MAX_SLUG_LENGTH = 80;
+function normalizeObjectSlug(value) {
+  const normalized = value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/'/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  const slug = normalized.slice(0, MAX_SLUG_LENGTH).replace(/-+$/g, "");
+  if (!slug) throw new Error("Object slug must contain at least one letter or number.");
+  return slug;
+}
+async function buildEncryptedObjectSlugMetadata(input) {
+  const slug = normalizeObjectSlug(input.value);
+  return {
+    slug,
+    encrypted_slug: await encryptWithAesGcmCombined(slug, input.encryptionKey),
+    slug_lookup_hash: objectSlugLookupHash(slug, input.lookupKey)
+  };
+}
+async function decryptObjectSlug(encryptedSlug, encryptionKey) {
+  if (!encryptedSlug) return "";
+  return await decryptWithAesGcmCombined(encryptedSlug, encryptionKey) ?? "";
+}
+function objectSlugMatches(slug, query) {
+  if (!slug) return false;
+  try {
+    return normalizeObjectSlug(slug) === normalizeObjectSlug(query);
+  } catch {
+    return false;
+  }
+}
+function objectSlugLookupHash(slug, lookupKey) {
+  const indexKey = Buffer.from(
+    hkdfSync("sha256", Buffer.from(lookupKey), Buffer.alloc(0), SLUG_LOOKUP_HASH_INFO, 32)
+  );
+  return createHmac2("sha256", indexKey).update(slug).digest("hex");
+}
+
+// src/tasksCli.ts
+var TASK_STATUSES = ["backlog", "todo", "in_progress", "blocked", "done"];
+var DEFAULT_STANDALONE_PREFIX = "TASK";
+var PRIORITY_LEVELS = ["none", "low", "medium", "high", "urgent"];
+var LABEL_INDEX_INFO = "openmates-task-label-index-v1";
+var EXTERNAL_CHAT_INDEX_INFO = "openmates-task-external-chat-index-v1";
+var EXTERNAL_CHAT_PROVIDERS = ["codex"];
+var BLOCKED_REASON_CODES = [
+  "needs_user_input",
+  "waiting_for_approval",
+  "missing_credentials",
+  "ambiguous_requirement",
+  "external_dependency",
+  "environment_unavailable",
+  "verification_failed",
+  "other"
+];
+function taskLookupScopes(scope) {
+  return TASK_STATUSES.map((status) => ({ ...scope, status }));
+}
+function taskEditLookupScope(scope) {
+  return { teamId: scope.teamId, personal: scope.personal };
+}
+function workflowProjectionDeleteGuidance(task) {
+  const workflowId = task.workflowId ?? "<workflow-id>";
+  const lines = [`Task ${task.shortId} is a read-only workflow projection, not an ordinary task.`];
+  if (task.projectionKind === "next_run" && task.canDelete !== false) {
+    lines.push(`To skip this scheduled run, retry: openmates tasks delete ${task.shortId} --confirm`);
+  } else if (task.workflowRunId && task.canCancel) {
+    lines.push(`To cancel this run: openmates workflows run-cancel ${workflowId} ${task.workflowRunId}`);
+  }
+  lines.push(`To deactivate the full workflow: openmates workflows disable ${workflowId}`);
+  return lines.join("\n");
+}
+function parseExternalChatRef(value) {
+  const separator = value.indexOf(":");
+  const provider = value.slice(0, separator).trim().toLowerCase();
+  const id = value.slice(separator + 1).trim();
+  if (separator <= 0 || !id) throw new Error("--external-chat requires provider:id.");
+  if (!EXTERNAL_CHAT_PROVIDERS.includes(provider)) throw new Error(`Unsupported external chat provider '${provider}'. Use codex.`);
+  return { provider, id };
+}
+function externalChatLookupHash(masterKey, context) {
+  const indexKey = Buffer.from(hkdfSync2("sha256", Buffer.from(masterKey), Buffer.alloc(0), EXTERNAL_CHAT_INDEX_INFO, 32));
+  return createHmac3("sha256", indexKey).update(`${context.provider}\0${context.id}`).digest("hex");
+}
+function normalizeBlockedReasonCode(value) {
+  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (!BLOCKED_REASON_CODES.includes(normalized)) {
+    throw new Error(`Unknown blocked reason code '${value}'. Expected one of: ${BLOCKED_REASON_CODES.join(", ")}`);
+  }
+  return normalized;
+}
+function normalizeTaskStatus(value) {
+  if (value === void 0) return void 0;
+  if (TASK_STATUSES.includes(value)) return value;
+  throw new Error(`Unknown task status '${value}'. Expected one of: ${TASK_STATUSES.join(", ")}`);
+}
+function parseAssignee(value) {
+  const normalized = value?.trim().toLowerCase().replace(/-/g, "_");
+  if (!normalized || normalized === "user") return { assigneeType: "user", assigneeIdentity: null, assigneeHash: null };
+  if (normalized === "openmates") return { assigneeType: "openmates", assigneeIdentity: "openmates", assigneeHash: null };
+  if (normalized === "external_ai" || normalized === "codex") return { assigneeType: "external_ai", assigneeIdentity: "codex", assigneeHash: null };
+  if (normalized === "unassigned") return { assigneeType: "unassigned", assigneeIdentity: null, assigneeHash: null };
+  return { assigneeType: "user", assigneeIdentity: null, assigneeHash: value };
+}
+function splitCsvFlag(value) {
+  if (typeof value !== "string") return [];
+  return value.split(/[,\n]/).map((item) => item.trim()).filter(Boolean);
+}
+function parseDueAt(value) {
+  if (value === void 0) return void 0;
+  if (value === false || value === true) throw new Error("--due requires a timestamp or date value.");
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) return Math.floor(numeric);
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) throw new Error(`Invalid --due value '${value}'.`);
+  return Math.floor(parsed / 1e3);
+}
+function normalizeLabels(labels) {
+  const output = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const label of labels ?? []) {
+    const normalized = label.trim().toLowerCase().replace(/\s+/g, " ");
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    output.push(normalized);
+  }
+  return output;
+}
+function labelHashes(masterKey, labels) {
+  const indexKey = Buffer.from(hkdfSync2("sha256", Buffer.from(masterKey), Buffer.alloc(0), LABEL_INDEX_INFO, 32));
+  return normalizeLabels(labels).map((label) => createHmac3("sha256", indexKey).update(label).digest("hex"));
+}
+function normalizeTaskPriority(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return 0;
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0 || value > 4) throw new Error(`Invalid task priority '${value}'.`);
+    return value;
+  }
+  const normalized = value.trim().toLowerCase();
+  const index = PRIORITY_LEVELS.indexOf(normalized);
+  if (index < 0) throw new Error(`Unknown task priority '${value}'. Expected one of: ${PRIORITY_LEVELS.join(", ")}`);
+  return index;
+}
+function taskPriorityLevel(priority) {
+  return PRIORITY_LEVELS[Math.max(0, Math.min(4, Math.trunc(priority ?? 0)))] ?? "none";
+}
+async function buildCreateUserTaskInput(masterKey, input) {
+  if (input.chatId && input.externalChat) throw new Error("A task cannot use both native chat and external chat context.");
+  const taskKey = randomBytes(32);
+  const encryptedTaskKey = await encryptBytesWithAesGcm(taskKey, masterKey);
+  const timestamp = nowSeconds();
+  const assignee = parseAssignee(input.assign);
+  const linkedProjectIds = input.projectIds ?? [];
+  const labels = normalizeLabels(input.labels ?? input.tags ?? []);
+  const status = input.status ?? "todo";
+  const slugMetadata = await buildEncryptedObjectSlugMetadata({
+    value: input.slug ?? input.title,
+    encryptionKey: taskKey,
+    lookupKey: masterKey
+  });
+  return {
+    task_id: input.taskId ?? randomUUIDCompat(),
+    short_id: void 0,
+    version: 1,
+    encrypted_task_key: encryptedTaskKey,
+    encrypted_slug: slugMetadata.encrypted_slug,
+    slug_lookup_hash: slugMetadata.slug_lookup_hash,
+    encrypted_title: await encryptWithAesGcmCombined(input.title, taskKey),
+    encrypted_description: await encryptWithAesGcmCombined(input.description ?? "", taskKey),
+    encrypted_labels: await encryptWithAesGcmCombined(JSON.stringify(labels), taskKey),
+    encrypted_tags: await encryptWithAesGcmCombined(JSON.stringify(labels), taskKey),
+    label_hashes: labelHashes(masterKey, labels),
+    encrypted_linked_project_ids: await encryptWithAesGcmCombined(JSON.stringify(linkedProjectIds), taskKey),
+    status,
+    assignee_type: assignee.assigneeType,
+    assignee_identity: assignee.assigneeIdentity,
+    assignee_hash: assignee.assigneeHash,
+    primary_chat_id: input.chatId ?? null,
+    ...input.externalChat ? {
+      external_chat_provider: input.externalChat.provider,
+      external_chat_lookup_hash: externalChatLookupHash(masterKey, input.externalChat),
+      encrypted_external_chat_id: await encryptWithAesGcmCombined(input.externalChat.id, taskKey),
+      encrypted_external_chat_title: await encryptWithAesGcmCombined(input.externalChat.title ?? "", taskKey)
+    } : {},
+    linked_project_ids: linkedProjectIds,
+    plan_id: input.planId ?? null,
+    due_at: input.dueAt ?? null,
+    priority: normalizeTaskPriority(input.priority) ?? 0,
+    position: timestamp,
+    created_at: timestamp,
+    updated_at: timestamp,
+    plaintext_title: assignee.assigneeType === "openmates" ? input.title : void 0,
+    plaintext_description: assignee.assigneeType === "openmates" ? input.description : void 0
+  };
+}
+async function buildUpdateUserTaskInput(task, masterKey, input, projectContext) {
+  if (input.chatId && input.externalChat) throw new Error("A task cannot use both native chat and external chat context.");
+  const taskKey = await taskKeyFromRecord(task.encrypted, masterKey);
+  const patch = { version: task.version, updated_at: nowSeconds() };
+  if (input.title !== void 0) patch.encrypted_title = await encryptWithAesGcmCombined(input.title, taskKey);
+  if (input.description !== void 0) patch.encrypted_description = await encryptWithAesGcmCombined(input.description, taskKey);
+  if (input.slug !== void 0) {
+    const slugMetadata = await buildEncryptedObjectSlugMetadata({
+      value: input.slug,
+      encryptionKey: taskKey,
+      lookupKey: masterKey
+    });
+    patch.encrypted_slug = slugMetadata.encrypted_slug;
+    patch.slug_lookup_hash = slugMetadata.slug_lookup_hash;
+  }
+  if (input.status !== void 0) patch.status = input.status;
+  if (input.assign !== void 0) {
+    const assignee = parseAssignee(input.assign);
+    patch.assignee_type = assignee.assigneeType;
+    patch.assignee_identity = assignee.assigneeIdentity;
+    patch.assignee_hash = assignee.assigneeHash;
+  }
+  if (input.chatId !== void 0) {
+    patch.primary_chat_id = input.chatId;
+    patch.external_chat_provider = null;
+    patch.external_chat_lookup_hash = null;
+    patch.encrypted_external_chat_id = null;
+    patch.encrypted_external_chat_title = null;
+  }
+  if (input.externalChat) {
+    patch.primary_chat_id = null;
+    patch.external_chat_provider = input.externalChat.provider;
+    patch.external_chat_lookup_hash = externalChatLookupHash(masterKey, input.externalChat);
+    patch.encrypted_external_chat_id = await encryptWithAesGcmCombined(input.externalChat.id, taskKey);
+    patch.encrypted_external_chat_title = await encryptWithAesGcmCombined(input.externalChat.title ?? "", taskKey);
+  }
+  if (input.projectIds !== void 0) {
+    if (!projectContext) throw new Error("Project relinking requires task wrappers and authorized project keys.");
+    const projectIds = [...new Set(input.projectIds)];
+    const hashId = (id) => createHash2("sha256").update(id).digest("hex");
+    const chatId = input.externalChat ? null : input.chatId !== void 0 ? input.chatId : task.primaryChatId;
+    const planId = input.planId !== void 0 ? input.planId : task.planId;
+    const wrappers = [{
+      key_type: "master",
+      encrypted_task_key: task.encrypted.encrypted_task_key,
+      created_at: nowSeconds()
+    }];
+    for (const wrapper of projectContext.keyWrappers) {
+      if (wrapper.key_type === "master" || wrapper.key_type === "project") continue;
+      if (wrapper.key_type === "chat" && (!chatId || wrapper.hashed_chat_id !== hashId(chatId))) continue;
+      if (wrapper.key_type === "plan" && (!planId || wrapper.hashed_plan_id !== hashId(planId))) continue;
+      if (!["chat", "plan", "team"].includes(String(wrapper.key_type))) throw new Error("Unsupported task key wrapper type.");
+      if (typeof wrapper.encrypted_task_key !== "string" || !wrapper.encrypted_task_key) throw new Error("Missing encrypted task wrapper key.");
+      const retained = {};
+      for (const field of ["key_type", "encrypted_task_key", "hashed_chat_id", "hashed_plan_id", "hashed_team_id", "team_key_epoch", "created_at", "expires_at"]) {
+        if (wrapper[field] !== void 0) retained[field] = wrapper[field];
+      }
+      wrappers.push(retained);
+    }
+    if (chatId && !wrappers.some((wrapper) => wrapper.key_type === "chat")) throw new Error("Missing required primary chat key wrapper.");
+    if (planId && !wrappers.some((wrapper) => wrapper.key_type === "plan")) throw new Error("Missing required plan key wrapper.");
+    for (const projectId of projectIds) {
+      const projectKey = projectContext.projectKeys.get(projectId);
+      if (!projectKey) throw new Error(`Missing authorized project key for ${projectId}.`);
+      wrappers.push({
+        key_type: "project",
+        hashed_project_id: hashId(projectId),
+        encrypted_task_key: await encryptBytesWithAesGcm(taskKey, projectKey),
+        created_at: nowSeconds()
+      });
+    }
+    patch.key_wrappers = wrappers;
+    patch.linked_project_ids = projectIds;
+    patch.encrypted_linked_project_ids = await encryptWithAesGcmCombined(JSON.stringify(projectIds), taskKey);
+  }
+  if (input.planId !== void 0) patch.plan_id = input.planId;
+  const priority = normalizeTaskPriority(input.priority);
+  if (priority !== void 0) patch.priority = priority;
+  const replaceLabels = input.labels ?? input.tags;
+  if (replaceLabels !== void 0 || input.addLabels !== void 0 || input.addTags !== void 0 || input.removeLabels !== void 0 || input.removeTags !== void 0) {
+    const remove = new Set(normalizeLabels([...input.removeLabels ?? [], ...input.removeTags ?? []]));
+    const base = replaceLabels !== void 0 ? normalizeLabels(replaceLabels) : task.labels;
+    const labels = normalizeLabels([...base.filter((label) => !remove.has(label)), ...input.addLabels ?? [], ...input.addTags ?? []]);
+    patch.encrypted_labels = await encryptWithAesGcmCombined(JSON.stringify(labels), taskKey);
+    patch.encrypted_tags = await encryptWithAesGcmCombined(JSON.stringify(labels), taskKey);
+    patch.label_hashes = labelHashes(masterKey, labels);
+  }
+  return patch;
+}
+async function buildCreateTaskActivityInput(task, masterKey, input) {
+  const taskKey = await taskKeyFromRecord(task.encrypted, masterKey);
+  const entryId = input.entryId ?? randomUUIDCompat();
+  return {
+    entry_id: entryId,
+    encrypted_message: await encryptWithAesGcmCombined(input.message, taskKey, `task_activity_comment:${task.taskId}:${entryId}:v1`),
+    ...input.embedKeyMaterial ? { encrypted_embed_key_material: await encryptWithAesGcmCombined(input.embedKeyMaterial, taskKey, `task_activity_embed_keys:${task.taskId}:${entryId}:v1`) } : {},
+    embed_refs: input.embedRefs ?? [],
+    created_at: input.createdAt ?? nowSeconds()
+  };
+}
+async function decryptTaskActivityEntry(task, masterKey, record) {
+  const base = {
+    entryId: record.entry_id,
+    taskId: record.task_id,
+    kind: record.kind,
+    actorType: record.actor_type,
+    actorHash: record.actor_hash,
+    actorIdentity: record.actor_identity ?? null,
+    actorDisplayName: record.actor_display_name ?? null,
+    actorProfileImageUrl: record.actor_profile_image_url ?? null,
+    authorHash: record.author_hash ?? record.actor_hash ?? null,
+    eventType: record.event_type,
+    sourceSurface: record.source_surface,
+    previousStatus: record.previous_status ?? null,
+    nextStatus: record.next_status ?? null,
+    createdAt: record.created_at,
+    deletedAt: record.deleted_at ?? null,
+    deletedByHash: record.deleted_by_hash ?? null,
+    deletedByDisplayName: record.deleted_by_display_name ?? null,
+    embedRefs: record.kind === "tombstone" ? [] : record.embed_refs
+  };
+  if (record.kind === "tombstone") return base;
+  if (record.kind !== "comment") return base;
+  if (!record.encrypted_message) {
+    throw new Error(`Task Activity entry ${record.entry_id} is missing encrypted content.`);
+  }
+  const taskKey = await taskKeyFromRecord(task.encrypted, masterKey);
+  const message = await decryptWithAesGcmCombined(record.encrypted_message, taskKey, `task_activity_comment:${task.taskId}:${record.entry_id}:v1`);
+  if (message === null) throw new Error(`Failed to decrypt Task Activity entry ${record.entry_id}.`);
+  const embedKeyMaterial = record.encrypted_embed_key_material ? await decryptWithAesGcmCombined(record.encrypted_embed_key_material, taskKey, `task_activity_embed_keys:${task.taskId}:${record.entry_id}:v1`) : null;
+  if (record.encrypted_embed_key_material && embedKeyMaterial === null) {
+    throw new Error(`Failed to decrypt Task Activity embed key material ${record.entry_id}.`);
+  }
+  return { ...base, message, ...embedKeyMaterial !== null ? { embedKeyMaterial } : {} };
+}
+async function decryptTaskActivityEntries(task, masterKey, records) {
+  const entries = [];
+  for (const record of records) entries.push(await decryptTaskActivityEntry(task, masterKey, record));
+  return entries;
+}
+async function decryptUserTask(record, masterKey) {
+  if (record.source === "workflow_run") return workflowProjectionToTask(record);
+  if (typeof record.version !== "number") throw new Error(`Task ${record.task_id} is missing version.`);
+  const taskKey = await taskKeyFromRecord(record, masterKey);
+  const labels = parseStringArray(await decryptOptional(record.encrypted_labels || record.encrypted_tags, taskKey));
+  const linkedProjectIds = parseStringArray(await decryptOptional(record.encrypted_linked_project_ids, taskKey));
+  const externalChat = record.external_chat_provider && record.encrypted_external_chat_id ? {
+    provider: record.external_chat_provider,
+    id: await decryptOptional(record.encrypted_external_chat_id, taskKey),
+    title: await decryptOptional(record.encrypted_external_chat_title, taskKey)
+  } : null;
+  return {
+    taskId: record.task_id,
+    shortId: record.short_id || deriveShortId(record),
+    slug: await decryptObjectSlug(record.encrypted_slug, taskKey),
+    title: await decryptOptional(record.encrypted_title, taskKey) || "(untitled task)",
+    description: await decryptOptional(record.encrypted_description, taskKey),
+    labels,
+    tags: labels,
+    latestInstruction: await decryptOptional(record.encrypted_latest_instruction, taskKey),
+    status: record.status,
+    assigneeType: record.assignee_type,
+    assigneeIdentity: record.assignee_identity ?? null,
+    assigneeHash: record.assignee_hash ?? null,
+    primaryChatId: record.primary_chat_id ?? null,
+    externalChat,
+    linkedProjectIds: linkedProjectIds.length > 0 ? linkedProjectIds : record.linked_project_ids ?? [],
+    planId: record.plan_id ?? null,
+    dueAt: record.due_at ?? null,
+    priority: record.priority ?? 0,
+    priorityLevel: taskPriorityLevel(record.priority),
+    position: record.position ?? 0,
+    queueState: record.queue_state ?? "none",
+    blockedReasonCode: record.blocked_reason_code ?? null,
+    blockedReason: await decryptOptional(record.encrypted_blocked_reason, taskKey),
+    aiExecutionState: record.ai_execution_state ?? null,
+    version: record.version,
+    encrypted: record
+  };
+}
+function workflowProjectionToTask(record) {
+  const blockedReason = record.blocked_reason_code ?? record.blocked_reason ?? null;
+  return {
+    taskId: record.task_id,
+    source: "workflow_run",
+    projectionKind: record.projection_kind ?? null,
+    workflowId: record.workflow_id ?? null,
+    workflowRunId: record.workflow_run_id ?? null,
+    triggerId: record.trigger_id ?? null,
+    canCancel: Boolean(record.can_cancel),
+    canDelete: Boolean(record.can_delete),
+    shortId: record.short_id || workflowProjectionShortId(record),
+    slug: "",
+    title: record.title || "Workflow run",
+    description: record.blocked_message ?? "",
+    labels: [],
+    tags: [],
+    latestInstruction: "",
+    status: record.status,
+    assigneeType: "user",
+    assigneeIdentity: null,
+    assigneeHash: null,
+    primaryChatId: null,
+    externalChat: null,
+    linkedProjectIds: [],
+    planId: null,
+    dueAt: record.due_at ?? null,
+    priority: record.priority ?? 0,
+    priorityLevel: taskPriorityLevel(record.priority),
+    position: record.position ?? 0,
+    queueState: String(record.run_status ?? "workflow"),
+    blockedReasonCode: blockedReason,
+    blockedReason: record.blocked_message ?? "",
+    aiExecutionState: null,
+    readOnly: true,
+    version: typeof record.version === "number" ? record.version : 1,
+    encrypted: record
+  };
+}
+async function buildBlockUserTaskInput(task, masterKey, input) {
+  const reasonCode = normalizeBlockedReasonCode(input.reasonCode);
+  const encryptedBlockedReason = input.reasonText === void 0 ? void 0 : await encryptWithAesGcmCombined(input.reasonText, await taskKeyFromRecord(task.encrypted, masterKey));
+  return {
+    version: task.version,
+    blocked_reason_code: reasonCode,
+    ...encryptedBlockedReason ? { encrypted_blocked_reason: encryptedBlockedReason } : {}
+  };
+}
+function workflowProjectionShortId(record) {
+  const stableId = record.workflow_run_id || record.task_id;
+  return `WF-${createHash2("sha256").update(stableId).digest("hex").slice(0, 6).toUpperCase()}`;
+}
+async function decryptUserTasks(records, masterKey) {
+  const output = [];
+  for (const record of records) output.push(await decryptUserTask(record, masterKey));
+  return output;
+}
+async function decryptUserTasksForCli(records, masterKey, warn) {
+  const output = [];
+  for (const record of records) {
+    try {
+      output.push(await decryptUserTask(record, masterKey));
+    } catch {
+      const identifier = record.short_id || record.task_id || "unknown";
+      warn(`Warning: skipped undecryptable task ${identifier} (${record.task_id || "unknown"}).`);
+    }
+  }
+  return output;
+}
+function findTask(tasks, id) {
+  const taskIdMatch = tasks.find((candidate) => candidate.taskId === id);
+  if (taskIdMatch) return taskIdMatch;
+  const slugMatches = tasks.filter((candidate) => objectSlugMatches(candidate.slug, id));
+  if (slugMatches.length > 1) throw new Error(`Task slug '${id}' is ambiguous in the current task list. Use the full task ID.`);
+  if (slugMatches.length === 1) return slugMatches[0];
+  const shortIdMatches = tasks.filter((candidate) => candidate.shortId === id);
+  if (shortIdMatches.length > 1) throw new Error(`Task '${id}' is ambiguous in the current task list. Use the full task ID.`);
+  const task = shortIdMatches[0];
+  if (!task) throw new Error(`Task '${id}' was not found in the current task list.`);
+  return task;
+}
+function renderTaskList(tasks) {
+  if (tasks.length === 0) return "No tasks found.";
+  const lines = ["Tasks", "Handle              Status       Priority  Labels              Title"];
+  for (const task of tasks) {
+    lines.push(`${pad(taskHandle(task), 19)} ${pad(task.status, 12)} ${pad(task.priorityLevel, 9)} ${pad(task.labels.join(","), 19)} ${task.title}`);
+  }
+  return lines.join("\n");
+}
+function renderTaskDetail(task) {
+  const lines = [
+    `Task ${taskHandle(task)}`,
+    `Title: ${task.title}`,
+    ...task.slug ? [`Slug: ${task.slug}`] : [],
+    `Status: ${task.status}`,
+    `Priority: ${task.priorityLevel}`,
+    `Assignee: ${assigneeLabel(task)}`,
+    `Queue: ${task.queueState}`,
+    `Task ID: ${task.taskId}`
+  ];
+  if (task.description) lines.push(`Description: ${task.description}`);
+  if (task.labels.length > 0) lines.push(`Labels: ${task.labels.join(", ")}`);
+  if (task.primaryChatId) lines.push(`Chat: ${task.primaryChatId}`);
+  if (task.externalChat) lines.push(`External chat: ${task.externalChat.provider}:${task.externalChat.id}${task.externalChat.title ? ` (${task.externalChat.title})` : ""}`);
+  if (task.linkedProjectIds.length > 0) lines.push(`Projects: ${task.linkedProjectIds.join(", ")}`);
+  if (task.planId) lines.push(`Plan: ${task.planId}`);
+  if (task.blockedReasonCode) lines.push(`Blocked reason: ${task.blockedReasonCode}`);
+  if (task.blockedReason) lines.push(`Blocked explanation: ${task.blockedReason}`);
+  if (task.aiExecutionState) lines.push(`AI state: ${task.aiExecutionState}`);
+  return lines.join("\n");
+}
+function renderTaskActivityList(entries) {
+  if (entries.length === 0) return "No Activity yet.";
+  const lines = ["Activity"];
+  for (const entry of entries) {
+    const actor = entry.actorType === "user" ? entry.actorDisplayName ?? "User" : taskIdentityDisplayName(entry.actorIdentity) ?? (entry.actorType === "system" ? "System" : "External AI");
+    const source = entry.sourceSurface === "cli" ? " via OpenMates CLI" : entry.sourceSurface === "sdk_npm" || entry.sourceSurface === "sdk_pip" ? " via OpenMates SDK" : "";
+    if (entry.kind === "tombstone") {
+      const deleter = entry.deletedByDisplayName ?? actor;
+      lines.push(`[${formatActivityTime(entry.deletedAt ?? entry.createdAt)}] Comment by ${actor} deleted by ${deleter}`);
+    } else if (entry.kind === "comment") {
+      lines.push(`[${formatActivityTime(entry.createdAt)}] ${actor}${source}`);
+      lines.push(entry.message ?? "");
+    } else {
+      const transition = entry.eventType === "status" && entry.nextStatus ? `changed status${entry.previousStatus ? ` from ${entry.previousStatus}` : ""} to ${entry.nextStatus}` : entry.eventType.replaceAll("_", " ");
+      lines.push(`[${formatActivityTime(entry.createdAt)}] ${actor} ${transition}`);
+    }
+  }
+  return lines.join("\n");
+}
+function taskIdentityDisplayName(identity) {
+  if (identity === "openmates") return "OpenMates";
+  if (identity === "codex") return "Codex";
+  return null;
+}
+function renderTaskBoard(tasks, width = process.stdout.columns || 100) {
+  const columns = TASK_STATUSES.map((status) => ({ status, tasks: tasks.filter((task) => task.status === status).sort(compareTasks) }));
+  if (width < 96) {
+    const lines2 = ["OpenMates Tasks Board"];
+    for (const column of columns) {
+      lines2.push("", `${columnTitle(column.status)} (${column.tasks.length})`, "-".repeat(24));
+      lines2.push(...boardColumnLines(column.tasks, 8));
+    }
+    return lines2.join("\n");
+  }
+  const perColumn = 6;
+  const columnWidth = 22;
+  const lines = ["OpenMates Tasks Board", ""];
+  lines.push(columns.map((column) => pad(`${columnTitle(column.status)} (${column.tasks.length})`, columnWidth)).join("  "));
+  lines.push(columns.map(() => "-".repeat(columnWidth)).join("  "));
+  const renderedColumns = columns.map((column) => boardColumnLines(column.tasks, perColumn).map((line) => truncate(line, columnWidth)));
+  const maxRows = Math.max(...renderedColumns.map((column) => column.length));
+  for (let row = 0; row < maxRows; row += 1) {
+    lines.push(renderedColumns.map((column) => pad(column[row] ?? "", columnWidth)).join("  "));
+  }
+  return lines.join("\n");
+}
+function boardColumnLines(tasks, limit) {
+  if (tasks.length === 0) return ["No tasks here."];
+  const visible = tasks.slice(0, limit).flatMap((task) => [
+    `[${taskHandle(task)}] ${task.title}`,
+    ` ${assigneeLabel(task)} ${task.queueState === "none" ? "" : task.queueState}`.trimEnd()
+  ]);
+  if (tasks.length > limit) visible.push(`... ${tasks.length - limit} more`);
+  return visible;
+}
+function taskHandle(task) {
+  return task.slug || task.shortId;
+}
+function compareTasks(a, b) {
+  return a.position - b.position || a.title.localeCompare(b.title);
+}
+function columnTitle(status) {
+  if (status === "in_progress") return "In progress";
+  return status.slice(0, 1).toUpperCase() + status.slice(1).replace("_", " ");
+}
+function assigneeLabel(task) {
+  return taskIdentityDisplayName(task.assigneeIdentity) ?? (task.assigneeType === "unassigned" ? "unassigned" : task.assigneeHash ?? "user");
+}
+async function taskKeyFromRecord(record, masterKey) {
+  if (!record.encrypted_task_key) throw new Error(`Task ${record.task_id} is missing encrypted task key.`);
+  const taskKey = await decryptBytesWithAesGcm(record.encrypted_task_key, masterKey);
+  if (!taskKey) throw new Error(`Failed to decrypt task key for ${record.task_id}.`);
+  return taskKey;
+}
+async function decryptOptional(value, key) {
+  if (!value) return "";
+  return await decryptWithAesGcmCombined(value, key) ?? "";
+}
+function parseStringArray(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function deriveShortId(record) {
+  const prefix = record.short_id_prefix || DEFAULT_STANDALONE_PREFIX;
+  const source = record.task_id || `${record.created_at ?? ""}-${record.position ?? ""}`;
+  const digest = createHash2("sha256").update(source).digest("hex").slice(0, 4).toUpperCase();
+  return `${prefix}-${parseInt(digest, 16) % 1e4}`;
+}
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function formatActivityTime(value) {
+  return new Date(value * 1e3).toISOString();
+}
+function randomUUIDCompat() {
+  return randomUUID();
+}
+function pad(value, length) {
+  return truncate(value, length).padEnd(length);
+}
+function truncate(value, length) {
+  return value.length <= length ? value : `${value.slice(0, Math.max(0, length - 3))}...`;
+}
+
+export {
+  base64ToBytes,
+  bytesToBase64,
+  bytesToBase64Url,
+  deriveTeamInviteKey,
+  deriveChatCompletionRecoveryKeypair,
+  openChatCompletionRecoveryEnvelope,
+  openRecoveryOutputEnvelope,
+  hashEmail,
+  hashKey,
+  derivePasswordKeysV2,
+  passwordProofV2,
+  unwrapPasswordMasterKey,
+  createPasswordMigrationMaterialV2,
+  createSignupCryptoMaterial,
+  createRecoveryKeyMaterial,
+  splitApiKeyCredential,
+  createApiKeyCryptoMaterial,
+  unwrapApiKeyMasterKey,
+  decryptWithAesGcmCombined,
+  deriveEmailEncryptionKeyB64,
+  decryptBytesWithAesGcm,
+  deriveEmbedKeyFromChatKey,
+  encryptBytesWithAesGcm,
+  encryptWithAesGcmCombined,
+  hashItemKey,
+  normalizeObjectSlug,
+  buildEncryptedObjectSlugMetadata,
+  decryptObjectSlug,
+  objectSlugMatches,
+  TASK_STATUSES,
+  taskLookupScopes,
+  taskEditLookupScope,
+  workflowProjectionDeleteGuidance,
+  parseExternalChatRef,
+  externalChatLookupHash,
+  normalizeBlockedReasonCode,
+  normalizeTaskStatus,
+  parseAssignee,
+  splitCsvFlag,
+  parseDueAt,
+  normalizeLabels,
+  labelHashes,
+  normalizeTaskPriority,
+  taskPriorityLevel,
+  buildCreateUserTaskInput,
+  buildUpdateUserTaskInput,
+  buildCreateTaskActivityInput,
+  decryptTaskActivityEntry,
+  decryptTaskActivityEntries,
+  decryptUserTask,
+  buildBlockUserTaskInput,
+  decryptUserTasks,
+  decryptUserTasksForCli,
+  findTask,
+  renderTaskList,
+  renderTaskDetail,
+  renderTaskActivityList,
+  taskIdentityDisplayName,
+  renderTaskBoard,
+  taskKeyFromRecord
+};