@unisonlabs/sixminute-admin 0.1.1246 → 0.1.1247-next

package/dist/sixminute-admin.mjs

@@ -21,11 +21,7 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 // tools/admin/src/build-info.ts
-var BUILT = { version: "0.1.1246", commit: "7f74de0c794bae81e8d332483c119d0ffcb5f5e0", surface: "bb42e8a273612558" };
-
-// tools/admin/src/run.ts
-import { rmSync as rmSync3 } from "node:fs";
-import { join as join2, resolve } from "node:path";
+var BUILT = { version: "0.1.1247-next", commit: "e6792ee2dfbf1cc15229a931746b3ac9695b62b4", surface: "e4b83a8db444655b" };
 
 // node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
@@ -4221,14 +4217,7 @@ var MatterPartySchema = exports_external.object({
   reference: RawWord,
   external_refs: exports_external.array(exports_external.string().min(1)).optional()
 });
-var SyncSourceSchema = exports_external.enum([
-  "manual",
-  "clio",
-  "legalsense",
-  "basenet",
-  "urios",
-  "import"
-]);
+var SyncSourceSchema = exports_external.enum(["manual", "legalsense", "urios", "import"]);
 var ClientSchema = exports_external.object({
   id: ClientIdSchema,
   name: exports_external.string().min(1),
@@ -4343,64 +4332,6 @@ function readMatterRecord(raw) {
   };
 }
 
-// packages/contracts/src/calendar.ts
-var CalendarProviderSchema = exports_external.enum(["microsoft", "google"]);
-var CalendarAccountKindSchema = exports_external.enum(["work", "personal"]);
-var CalendarConnectionStatusSchema = exports_external.enum(["connected", "awaiting_admin", "needs_reconnect"]);
-var CalendarConnectionSchema = exports_external.object({
-  provider: CalendarProviderSchema,
-  account_kind: CalendarAccountKindSchema,
-  account_email: exports_external.string(),
-  status: CalendarConnectionStatusSchema,
-  admin_consent_url: exports_external.string().nullable(),
-  last_synced_at: TimestampSchema.nullable()
-});
-var CalendarConnectRequestSchema = exports_external.object({
-  provider: CalendarProviderSchema,
-  state: exports_external.string().min(16),
-  code_challenge: exports_external.string().min(16)
-});
-var CalendarConnectAnswerSchema = exports_external.object({ authorize_url: exports_external.string().url() });
-var CalendarConnectFinishSchema = exports_external.union([
-  exports_external.object({ state: exports_external.string().min(16), code: exports_external.string().min(1), code_verifier: exports_external.string().min(43).max(128) }).strict(),
-  exports_external.object({
-    state: exports_external.string().min(16),
-    error: exports_external.string().min(1).max(200),
-    error_description: exports_external.string().max(2000).optional(),
-    error_subcode: exports_external.string().max(200).optional()
-  }).strict()
-]);
-var CalendarResponseSchema = exports_external.enum(["organiser", "accepted", "tentative", "declined", "none"]);
-var CalendarGuestSchema = exports_external.object({
-  name: exports_external.string(),
-  email: exports_external.string().nullable(),
-  response: CalendarResponseSchema,
-  organiser: exports_external.boolean(),
-  me: exports_external.boolean()
-});
-var CalendarWhereSchema = exports_external.object({
-  kind: exports_external.enum(["call", "address", "none"]),
-  text: exports_external.string().nullable()
-});
-var CalendarEventSchema = exports_external.object({
-  id: exports_external.string().min(1),
-  title: exports_external.string(),
-  from: TimestampSchema,
-  to: TimestampSchema,
-  all_day: exports_external.boolean(),
-  status: exports_external.enum(["confirmed", "cancelled"]),
-  my_response: CalendarResponseSchema,
-  where: CalendarWhereSchema,
-  guests: exports_external.array(CalendarGuestSchema),
-  provider: CalendarProviderSchema,
-  web_link: exports_external.string().nullable(),
-  not_attended: exports_external.boolean(),
-  can_mark: exports_external.boolean()
-});
-var CalendarDaySchema = exports_external.object({
-  events: exports_external.array(CalendarEventSchema)
-});
-
 // packages/contracts/src/compat.ts
 var ActivityTypeKeySchema = exports_external.string().regex(/^[A-Za-z0-9_-]{1,40}$/, "an activity type key is 1 to 40 letters, digits, underscores or hyphens, such as A103 or draft-revise");
 var ActivityTypeSourceSchema = exports_external.enum(["published", "firm"]);
@@ -4603,8 +4534,8 @@ function partOnDay(part, day, zone) {
 }
 
 // packages/contracts/src/connector.ts
-var ConnectorKindSchema = exports_external.enum(["urios", "legalsense", "partner", "fake"]);
-var InitiativeSchema = exports_external.enum(["push", "poll"]);
+var ConnectorKindSchema = exports_external.enum(["urios", "legalsense", "fake"]);
+var InitiativeSchema = exports_external.enum(["push"]);
 var IdentityModeSchema = exports_external.enum(["mapping", "sign_in"]);
 var FieldDeclarationSchema = exports_external.object({
   key: AttributeKeySchema.refine((key) => !key.includes("__"), {
@@ -4621,7 +4552,7 @@ var CapabilitiesSchema = exports_external.object({
   change_feed: exports_external.enum(["modified_since", "full_list"]),
   narrative_max_chars: exports_external.number().int().positive().nullable(),
   note_max_chars: exports_external.number().int().positive().nullable().default(null),
-  insolvency_groups: exports_external.boolean(),
+  insolvency_groups: exports_external.literal(false),
   matter_visibility: exports_external.enum(["firm", "member"]).default("firm"),
   reviewer: exports_external.enum(["self", "configurable"]).default("configurable"),
   fields: exports_external.array(FieldDeclarationSchema).superRefine((fields, ctx) => {
@@ -4701,7 +4632,6 @@ var PmsMatterSchema = exports_external.object({
   main_category: exports_external.string().nullable().optional(),
   phase: exports_external.string().nullable().optional(),
   folders: exports_external.array(exports_external.string()).optional(),
-  insolvency: exports_external.boolean().default(false),
   time_entry_blocked: exports_external.boolean().default(false)
 });
 var PmsTimekeeperSchema = exports_external.object({
@@ -4757,7 +4687,6 @@ var PmsListsSchema = exports_external.object({
   }).optional()
 });
 var MatterPmsRulesSchema = exports_external.object({
-  insolvency: exports_external.boolean().default(false),
   time_entry_blocked: exports_external.boolean().default(false)
 });
 var OutboundEntrySchema = exports_external.object({
@@ -4771,8 +4700,7 @@ var OutboundEntrySchema = exports_external.object({
   minutes: exports_external.number().int().nonnegative(),
   narrative: NarrativeSchema,
   internal_note: exports_external.string().nullable().default(null),
-  fields: exports_external.record(exports_external.string(), exports_external.object({ value: exports_external.string().nullable(), external_ref: exports_external.string().nullable() })),
-  recofa_category: exports_external.string().nullable().default(null)
+  fields: exports_external.record(exports_external.string(), exports_external.object({ value: exports_external.string().nullable(), external_ref: exports_external.string().nullable() }))
 });
 var PmsEntryStateSchema = exports_external.object({
   external_id: exports_external.string().min(1),
@@ -4938,6 +4866,907 @@ var SyncProgressSchema = exports_external.object({
   failed: exports_external.boolean()
 });
 
+// packages/contracts/src/analytics/safe.ts
+var mark = (schema, kind) => schema.describe(`safe:${kind}`);
+var TELEMETRY_SECONDS_MAX = 86400;
+var TELEMETRY_DAY_OFFSET_MAX = 3660;
+var TELEMETRY_ENTRY_ID_MAX = 64;
+var count = () => mark(exports_external.number().int().nonnegative(), "count");
+var daySeconds = () => mark(exports_external.number().int().nonnegative().max(TELEMETRY_SECONDS_MAX), "day-seconds");
+var duration = () => mark(exports_external.number().int().nonnegative(), "duration");
+var signed = (min, max) => mark(exports_external.number().int().min(min).max(max), "signed");
+var dayOffset = () => signed(-TELEMETRY_DAY_OFFSET_MAX, TELEMETRY_DAY_OFFSET_MAX);
+var minutesDelta = () => mark(exports_external.number().int().min(-1440).max(1440).nullable(), "minutes-delta");
+var usd = () => mark(exports_external.number().nonnegative().finite(), "usd");
+var bool = () => exports_external.boolean();
+var oneOf = (values) => exports_external.enum(values);
+var day = () => mark(LocalDaySchema, "day");
+var version = () => mark(exports_external.string().regex(/^\d{1,9}\.\d{1,9}\.\d{1,9}$/), "version");
+var pageBuild = () => mark(exports_external.string().regex(/^\d{14}-[0-9A-Za-z]{1,40}$/, "expected YYYYMMDDHHMMSS-<commit>"), "page-build");
+var modelId = () => mark(exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,79}$/), "model-id");
+var word = () => mark(exports_external.string().regex(/^[A-Za-z0-9_.-]{1,48}$/), "word");
+var uuid = () => mark(exports_external.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i), "uuid");
+var sessionId = () => mark(exports_external.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, "expected a UUIDv7"), "session-id");
+var ids = {
+  entry: () => mark(EntryIdSchema.max(TELEMETRY_ENTRY_ID_MAX), "id"),
+  run: () => mark(RunIdSchema, "id"),
+  firm: () => mark(TenantIdSchema, "id"),
+  member: () => mark(MemberIdSchema, "id"),
+  device: () => mark(DeviceIdSchema, "id")
+};
+
+// packages/contracts/src/analytics/catalogue.ts
+var RawArchiveReasonSchema = oneOf(["person", "expired", "signed_out", "tenant_changed", "not_allowed", "refused", "disk_low"]);
+var TelemetryScreenSchema = oneOf(["day", "timeline", "entry", "settings", "sign_in", "onboarding", "permissions"]);
+var TelemetryCommandSchema = oneOf([
+  "new-entry",
+  "release-all",
+  "settings",
+  "exit",
+  "undo",
+  "redo",
+  "cut",
+  "copy",
+  "paste",
+  "select-all",
+  "today",
+  "previous-day",
+  "next-day",
+  "previous-entry",
+  "next-entry",
+  "actions",
+  "capture",
+  "privacy",
+  "about",
+  "folder",
+  "release",
+  "matter",
+  "attribute",
+  "merge",
+  "delete",
+  "open"
+]);
+var GenerateFailureSchema = oneOf(["model", "deadline", "overlap", "other"]);
+var AppErrorKindSchema = oneOf(["boundary", "uncaught", "unhandled_rejection"]);
+var AppErrorClassSchema = oneOf(["Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError", "ChunkLoadError", "AbortError", "other"]);
+var PageBuildSchema = pageBuild();
+var RELEASE_BLOCKERS = [
+  "narrative_empty",
+  "narrative_too_short",
+  "matter",
+  "internal_note_too_long",
+  "connector_not_connected",
+  "connector_sign_in",
+  "connector_matter",
+  "connector_timekeeper",
+  "connector_narrative",
+  "connector_matter_blocked",
+  "connector_matter_not_found",
+  "connector_matter_closed",
+  "connector_person_not_found",
+  "connector_person_inactive",
+  "connector_not_accepted",
+  "connector_reviewer",
+  "attribute",
+  "other"
+];
+var SyncFailureSchema = oneOf(["tls", "login", "schema", "rights", "connect", "timeout", "nobody_signed_in", "dispatch", "error"]);
+var SourceHealthSchema = oneOf(["healthy", "failing", "needs_reconnect"]);
+var JobKindSchema = oneOf([
+  "decide",
+  "generate",
+  "propose",
+  "calendar_judge",
+  "calendar_sync",
+  "practice_sync",
+  "day_accounts",
+  "scrub_plaintext",
+  "purge_expired",
+  "research_purge",
+  "sweep"
+]);
+var SettingSchema = oneOf([
+  "unit_minutes",
+  "narrative_language",
+  "narrative_max_chars",
+  "narrative_guidance",
+  "always_on",
+  "exclusions",
+  "name",
+  "avatar",
+  "entry_size",
+  "time_zone",
+  "launch_at_login",
+  "theme"
+]);
+var DeviceSettingSchema = oneOf(["unit_minutes", "narrative_language", "narrative_max_chars", "always_on", "launch_at_login", "theme", "exclusions", "entry_size"]);
+var Role = oneOf(["timekeeper", "billing", "admin"]);
+var Origin = oneOf(["engine", "hand"]);
+var DEVICE_COUNTER_NAMES = [
+  "samples_received",
+  "observations_written",
+  "snapshots_written",
+  "samples_idle",
+  "samples_excluded",
+  "samples_empty",
+  "samples_out_of_order",
+  "samples_late",
+  "marks_late",
+  "samples_dropped",
+  "browser_breaker_trips",
+  "clock_steps",
+  "capture_seconds",
+  "active_seconds",
+  "idle_seconds",
+  "locked_seconds",
+  "excluded_seconds"
+];
+function counterShape() {
+  const shape = {};
+  for (const name of DEVICE_COUNTER_NAMES)
+    shape[name] = name.endsWith("_seconds") ? daySeconds() : count();
+  return shape;
+}
+var DELIVERY = {
+  via: oneOf(["release", "read_back"]),
+  entry_id: ids.entry(),
+  kind: ConnectorKindSchema,
+  reason: DeliveryReasonSchema.nullable(),
+  pms_status: word().nullable(),
+  minutes: count(),
+  seconds_since_released: duration(),
+  changed_minutes: bool(),
+  changed_day: bool(),
+  changed_matter: bool(),
+  changed_narrative: bool(),
+  minutes_delta: minutesDelta(),
+  direct: exports_external.literal(true)
+};
+var GENERATE = {
+  trigger: oneOf(["press", "backstop"]),
+  run_id: ids.run(),
+  day_offset: dayOffset()
+};
+function spec(s) {
+  return { ...s, properties: exports_external.object(s.properties).strict(), wire: s.wire };
+}
+var CATALOGUE = {
+  userSignedIn: spec({
+    name: "user signed in",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "POST /v1/me/provision answered a person in a firm",
+    question: "Who uses Sixminute, and how did they start?",
+    properties: { action: oneOf(["ready", "refresh"]), role: Role, first_sign_in: bool(), via: oneOf(["token", "invitation"]) }
+  }),
+  signInFailed: spec({
+    name: "sign in failed",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a sign-in ended in a refusal a person can act on",
+    question: "Where does signing in break?",
+    properties: { reason: oneOf(["no_firm", "choose_firm", "code_invalid"]) }
+  }),
+  tenantProvisioned: spec({
+    name: "tenant provisioned",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "the first sign-in of a firm created its tenant row",
+    question: "How many firms start?",
+    properties: { via: oneOf(["token", "invitation"]) }
+  }),
+  memberInvited: spec({
+    name: "member invited",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "an admin invited a colleague",
+    question: "Do firms bring their colleagues?",
+    properties: { role: Role }
+  }),
+  memberJoined: spec({
+    name: "member joined",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a membership row was created",
+    question: "How fast does a firm fill?",
+    properties: { role: Role, via: oneOf(["token", "invitation"]) }
+  }),
+  memberChanged: spec({
+    name: "member changed",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "an admin moved a role or the active flag, or withdrew an invitation",
+    question: "How do firms manage their people?",
+    properties: { change: oneOf(["role", "reactivated", "deactivated", "invitation_revoked"]) }
+  }),
+  deviceRevoked: spec({
+    name: "device revoked",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a person revoked a device that was not revoked",
+    question: "How often are desktops replaced?",
+    properties: {}
+  }),
+  applicationUpdated: spec({
+    name: "Application updated",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a device called with another version than the one it last called with",
+    question: "How fast does a release reach every desktop?",
+    properties: { from_version: version(), to_version: version() }
+  }),
+  clientOutdated: spec({
+    name: "client outdated",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "the floor refused a desktop's registration",
+    question: "Which old desktops are still in the field?",
+    properties: { version: version() }
+  }),
+  installerDownloaded: spec({
+    name: "installer downloaded",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "the download route served an installer a person pressed for",
+    question: "How many installs start from the site?",
+    properties: { os: oneOf(["macos", "windows"]), arch: oneOf(["arm64", "x64", "aarch64", "x86_64", "universal"]), version: version(), via: oneOf(["latest", "direct"]) }
+  }),
+  settingChanged: spec({
+    name: "setting changed",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a firm's or a person's setting row changed, or a desktop relayed its own",
+    question: "Which settings matter to people?",
+    properties: { setting: SettingSchema, scope: oneOf(["firm", "profile", "device"]) },
+    wire: { name: "setting.changed", properties: exports_external.object({ setting: DeviceSettingSchema, scope: oneOf(["device"]) }) }
+  }),
+  entryDrafted: spec({
+    name: "entry drafted",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "an entry was inserted: a person's by hand, or the engine's by a Generate",
+    question: "How much is drafted, and of what shape?",
+    properties: {
+      entry_id: ids.entry(),
+      origin: Origin,
+      minutes: count(),
+      has_matter: bool(),
+      attribute_count: count(),
+      narrative_chars: count(),
+      day_offset: dayOffset(),
+      run_id: ids.run()
+    }
+  }),
+  entryEdited: spec({
+    name: "entry edited",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a person's edit changed a draft",
+    question: "How much work is reviewing?",
+    properties: {
+      entry_id: ids.entry(),
+      origin: Origin,
+      status: oneOf(["draft", "released"]),
+      is_first_edit: bool(),
+      changed_narrative: bool(),
+      changed_matter: bool(),
+      changed_time: bool(),
+      changed_attributes: bool(),
+      changed_note: bool(),
+      minutes_delta: signed(-1440, 1440),
+      matter_change: oneOf(["set", "changed", "cleared"]).nullable(),
+      attributes_changed_count: count(),
+      seconds_since_drafted: duration()
+    }
+  }),
+  entryReleased: spec({
+    name: "entry released",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a person released a draft",
+    question: "How good are the drafts people release?",
+    properties: {
+      entry_id: ids.entry(),
+      origin: Origin,
+      is_unchanged: bool(),
+      changed_matter: bool(),
+      changed_narrative: bool(),
+      changed_time: bool(),
+      changed_attributes: bool(),
+      changed_note: bool(),
+      matter_outcome: oneOf(["kept", "filled", "replaced", "cleared"]),
+      narrative_change: oneOf(["none", "light", "heavy", "rewritten"]),
+      minutes: count(),
+      recorded_minutes: count(),
+      override: bool(),
+      judged_minutes: count().nullable(),
+      minutes_delta: minutesDelta(),
+      attributes_changed_count: count(),
+      lineage: oneOf(["original", "split", "merged"]),
+      seconds_since_drafted: duration(),
+      days_after_work_day: dayOffset(),
+      is_delivered: bool(),
+      connector_kind: ConnectorKindSchema.nullable()
+    }
+  }),
+  releaseBlocked: spec({
+    name: "release blocked",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a release answered a refusal, once per kind of blocker",
+    question: "What stops people releasing?",
+    properties: { entry_id: ids.entry(), blocker: oneOf(RELEASE_BLOCKERS) }
+  }),
+  entrySplit: spec({
+    name: "entry split",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a person split a draft",
+    question: "How much of an entry do people take off?",
+    properties: {
+      entry_id: ids.entry(),
+      new_entry_id: ids.entry(),
+      origin: Origin,
+      was_edited: bool(),
+      first_minutes: count(),
+      second_minutes: count()
+    }
+  }),
+  entryMerged: spec({
+    name: "entry merged",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a person joined drafts",
+    question: "How big are the pieces people join?",
+    properties: {
+      entry_id: ids.entry(),
+      entries: count(),
+      minutes: count(),
+      first_minutes: count(),
+      second_minutes: count(),
+      had_same_matter: bool(),
+      was_edited: bool()
+    }
+  }),
+  entryDeleted: spec({
+    name: "entry deleted",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a person deleted one of their drafts",
+    question: "Which drafts do people throw away?",
+    properties: {
+      entry_id: ids.entry(),
+      origin: Origin,
+      has_matter: bool(),
+      was_edited: bool(),
+      minutes: count(),
+      seconds_since_drafted: duration()
+    }
+  }),
+  deliveryReleased: spec({
+    name: "delivery released",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a delivery reached `released`: written by the release, or moved back by a read-back",
+    question: "How many entries reach the practice system?",
+    properties: DELIVERY
+  }),
+  deliveryAccepted: spec({
+    name: "delivery accepted",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a read-back moved a delivery to `accepted`",
+    question: "What share of releases does the firm accept?",
+    properties: DELIVERY
+  }),
+  deliveryRejected: spec({
+    name: "delivery rejected",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a read-back moved a delivery to `rejected`",
+    question: "What share of releases does the firm reject?",
+    properties: DELIVERY
+  }),
+  deliveryEdited: spec({
+    name: "delivery edited",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a read-back found a line edited, or edited further",
+    question: "What does the firm change on a line?",
+    properties: DELIVERY
+  }),
+  deliveryBilled: spec({
+    name: "delivery billed",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "the first read-back that says the line is billed",
+    question: "How long until released time is billed?",
+    properties: DELIVERY
+  }),
+  practiceConnectionChanged: spec({
+    name: "practice connection changed",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a firm's link to its practice system, or a member's own account at it, changed",
+    question: "How do firms set up and keep their practice system?",
+    properties: {
+      kind: ConnectorKindSchema,
+      change: oneOf(["connected", "team_confirmed", "settings_saved", "disconnected", "needs_reconnect", "synced_now", "signed_in", "signed_out", "session_failed"])
+    }
+  }),
+  practiceSynced: spec({
+    name: "practice synced",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a practice sync run ended having written a row or failed (a quiet run counts in `jobs day`)",
+    question: "Is the practice system's link healthy, and what does a sync cost?",
+    properties: {
+      kind: ConnectorKindSchema,
+      duration_ms: duration(),
+      rows_read: count(),
+      rows_written: count(),
+      pages: count(),
+      whole: bool(),
+      failure: SyncFailureSchema.nullable(),
+      members: count(),
+      members_failed: count(),
+      pressed: bool()
+    }
+  }),
+  calendarSynced: spec({
+    name: "calendar synced",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a person's calendar sync changed an event or failed (a quiet run counts in `jobs day`)",
+    question: "Are calendars read, and do they change?",
+    properties: { provider: oneOf(["microsoft", "google"]), outcome: oneOf(["synced", "failed"]), events_read: count(), events_written: count() }
+  }),
+  sourceHealthChanged: spec({
+    name: "source health changed",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a practice system or a calendar moved between healthy, failing and needs reconnect",
+    question: "Which links are broken, and since when?",
+    properties: { kind: oneOf(["practice", "calendar"]), from: SourceHealthSchema, to: SourceHealthSchema }
+  }),
+  listChanged: spec({
+    name: "list changed",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a matter or a client was created, edited or imported",
+    question: "How do firms keep their lists?",
+    properties: { list: oneOf(["matters", "clients"]), change: oneOf(["created", "edited", "imported"]), count: count() }
+  }),
+  generateStarted: spec({
+    name: "generate started",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a Generate run started its first attempt",
+    question: "Do people press Generate, and over how much?",
+    properties: { trigger: GENERATE.trigger, intervals: count(), recordings: count(), run_id: GENERATE.run_id, day_offset: GENERATE.day_offset },
+    wire: { name: "generate.started" }
+  }),
+  generateFinished: spec({
+    name: "generate finished",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a Generate run ended done",
+    question: "Does Generate work, and what does it cost?",
+    properties: {
+      trigger: GENERATE.trigger,
+      entries: count(),
+      blocks_joined: count(),
+      seconds: count(),
+      calls: count(),
+      run_id: GENERATE.run_id,
+      day_offset: GENERATE.day_offset,
+      entries_clipped: count(),
+      attempts: count()
+    },
+    wire: { name: "generate.finished" }
+  }),
+  generateFailed: spec({
+    name: "generate failed",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a Generate run failed for good",
+    question: "Why does Generate fail?",
+    properties: {
+      trigger: GENERATE.trigger,
+      step: oneOf(["decide", "join", "narrative", "write"]),
+      run_id: GENERATE.run_id,
+      day_offset: GENERATE.day_offset,
+      failure: GenerateFailureSchema,
+      attempts: count()
+    },
+    wire: { name: "generate.failed" }
+  }),
+  entryProposed: spec({
+    name: "entry proposed",
+    owner: "cloud",
+    expect: "weekly",
+    trigger: "a propose job answered",
+    question: "Do the merge, split and drag proposals help?",
+    properties: {
+      ranges: count(),
+      intervals: count(),
+      how: oneOf(["chosen", "most", "tie", "none"]),
+      tie_called: bool(),
+      attribute_calls: count(),
+      kept: oneOf(["no_text", "not_signed_in", "refused", "offline"]),
+      profile_ms: duration(),
+      read_ms: duration(),
+      matter_ms: duration(),
+      attributes_ms: duration(),
+      narrative_ms: duration(),
+      total_ms: duration(),
+      run_id: ids.run()
+    },
+    wire: { name: "entry.proposed" }
+  }),
+  aiGeneration: spec({
+    name: "$ai_generation",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "a `job_calls` row of a model call was written (a cache hit is no call)",
+    question: "What do model calls cost, and do they fail?",
+    properties: {
+      $ai_model: modelId(),
+      $ai_provider: word(),
+      $ai_span_name: word(),
+      $ai_input_tokens: count(),
+      $ai_output_tokens: count(),
+      $ai_cache_read_input_tokens: count(),
+      $ai_cache_reporting_exclusive: bool(),
+      $ai_total_cost_usd: usd(),
+      $ai_cost_passthrough: bool(),
+      $ai_latency: usd(),
+      $ai_is_error: bool(),
+      $ai_http_status: count(),
+      $ai_trace_id: ids.run().or(uuid()).describe("safe:trace"),
+      is_priced: bool(),
+      run_kind: oneOf(["interval", "generate", "regenerate", "propose", "calendar_judge"])
+    }
+  }),
+  modelCapHit: spec({
+    name: "model cap hit",
+    owner: "cloud",
+    expect: "rare",
+    trigger: "a member's daily cap refused a call or held a run",
+    question: "Do the caps bite?",
+    properties: {
+      purpose: word(),
+      day: day(),
+      calls: count(),
+      cost_usd: usd(),
+      prompt_tokens: count(),
+      completion_tokens: count(),
+      run_kind: oneOf(["interval", "generate", "regenerate", "propose", "calendar_judge"])
+    }
+  }),
+  jobsDay: spec({
+    name: "jobs day",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "the first job of a subject to end on a UTC day counts that subject's runs of the day before, per kind",
+    question: "How much background work runs, and how much of it fails?",
+    properties: { kind: JobKindSchema, day: day(), runs: count(), failed: count() }
+  }),
+  dayAccounted: spec({
+    name: "day accounted",
+    owner: "cloud",
+    expect: "daily",
+    trigger: "the `day_accounts` job accounted a person's day two days after it ended",
+    question: "Where did each person's day go?",
+    properties: {
+      day: day(),
+      unobserved_seconds: daySeconds(),
+      away_seconds: daySeconds(),
+      work_undrafted_seconds: daySeconds(),
+      drafted_seconds: daySeconds(),
+      released_seconds: daySeconds(),
+      day_seconds: duration(),
+      devices: count(),
+      capturing: bool(),
+      late_contexts: count()
+    }
+  }),
+  deviceCounters: spec({
+    name: "device counters",
+    owner: "host",
+    expect: "daily",
+    trigger: "a desktop posted its day's counters to POST /v1/telemetry",
+    question: "Is capture healthy on each machine?",
+    properties: { day: day(), ...counterShape() }
+  }),
+  captureStarted: spec({
+    name: "capture started",
+    owner: "host",
+    expect: "daily",
+    trigger: "a desktop turned capture on",
+    question: "How do people start capturing?",
+    properties: { trigger: oneOf(["button", "tray", "always_on", "launch", "sign_in"]), is_always_on: bool(), swallow_short_pauses: bool() },
+    wire: { name: "capture.started" }
+  }),
+  captureStopped: spec({
+    name: "capture stopped",
+    owner: "host",
+    expect: "daily",
+    trigger: "a desktop turned capture off",
+    question: "How long do people capture?",
+    properties: { trigger: oneOf(["button", "tray", "quit", "update", "sign_out"]), seconds: count(), entries: count(), windows_failed: count() },
+    wire: { name: "capture.stopped" }
+  }),
+  userSignedOut: spec({
+    name: "user signed out",
+    owner: "host",
+    expect: "rare",
+    trigger: "a desktop signed out",
+    question: "Why do people sign out?",
+    properties: { trigger: oneOf(["menu", "tray", "session_expired"]) },
+    wire: { name: "user.signed_out" }
+  }),
+  permissionChanged: spec({
+    name: "permission changed",
+    owner: "host",
+    expect: "rare",
+    trigger: "a desktop's system permission changed",
+    question: "Do people grant what capture needs?",
+    properties: { permission: oneOf(["accessibility", "automation"]), is_granted: bool() },
+    wire: { name: "permission.changed" }
+  }),
+  updateFailed: spec({
+    name: "update failed",
+    owner: "host",
+    expect: "rare",
+    trigger: "a desktop's update failed",
+    question: "Where do updates break?",
+    properties: { stage: oneOf(["check", "download", "apply"]) },
+    wire: { name: "update.failed" }
+  }),
+  rawArchiveTurnedOn: spec({
+    name: "raw archive turned on",
+    owner: "host",
+    expect: "rare",
+    trigger: "a person switched the raw archive on",
+    question: "Who keeps a raw archive?",
+    properties: { reason: oneOf(["person"]) },
+    wire: { name: "raw_archive.turned_on", beside: ["reason"] }
+  }),
+  rawArchiveTurnedOff: spec({
+    name: "raw archive turned off",
+    owner: "host",
+    expect: "rare",
+    trigger: "the raw archive was switched off",
+    question: "Why does a raw archive stop?",
+    properties: { reason: RawArchiveReasonSchema },
+    wire: { name: "raw_archive.turned_off", beside: ["reason"] }
+  }),
+  applicationOpened: spec({
+    name: "Application opened",
+    owner: "page",
+    expect: "daily",
+    trigger: "the window opened",
+    question: "How often do people open Sixminute?",
+    properties: { trigger: oneOf(["launch", "login_item", "after_update", "tray"]), is_first_open: bool() },
+    wire: { name: "application.opened" }
+  }),
+  applicationBecameActive: spec({
+    name: "Application became active",
+    owner: "page",
+    expect: "daily",
+    trigger: "the window came to the front",
+    question: "How do people come back to the window?",
+    properties: { trigger: oneOf(["launch", "tray", "dock", "notification", "shortcut"]) },
+    wire: { name: "application.became_active" }
+  }),
+  applicationBackgrounded: spec({
+    name: "Application backgrounded",
+    owner: "page",
+    expect: "daily",
+    trigger: "the window left the front",
+    question: "How long is the window in front?",
+    properties: { foreground_seconds: daySeconds() },
+    wire: { name: "application.backgrounded" }
+  }),
+  appUsage: spec({
+    name: "app usage",
+    owner: "page",
+    expect: "daily",
+    trigger: "a day's time in front of the window",
+    question: "How much time do people spend in Sixminute?",
+    properties: { day: day(), foreground_seconds: daySeconds(), sessions: count() },
+    wire: { name: "app.usage" }
+  }),
+  screenViewed: spec({
+    name: "$screen",
+    owner: "page",
+    expect: "daily",
+    trigger: "a screen was shown",
+    question: "Which screens do people use?",
+    properties: {
+      $screen_name: TelemetryScreenSchema,
+      settings_page: oneOf([
+        "profile",
+        "calendar",
+        "preferences",
+        "appearance",
+        "capture",
+        "privacy",
+        "general",
+        "members",
+        "timekeeping",
+        "narratives",
+        "practice-system",
+        "matters",
+        "member"
+      ]),
+      from_screen: TelemetryScreenSchema,
+      day_offset: dayOffset()
+    },
+    wire: { name: "screen.viewed", rename: { screen: "$screen_name" } }
+  }),
+  commandUsed: spec({
+    name: "command used",
+    owner: "page",
+    expect: "daily",
+    trigger: "a command ran from a menu, the palette, a shortcut or a button",
+    question: "Which commands do people use, and how?",
+    properties: { command: TelemetryCommandSchema, via: oneOf(["menu", "palette", "shortcut", "row_menu", "tray", "button"]) },
+    wire: { name: "command.used" }
+  }),
+  entryOpened: spec({
+    name: "entry opened",
+    owner: "page",
+    expect: "daily",
+    trigger: "an entry's page opened",
+    question: "Which entries do people look into?",
+    properties: { entry_id: ids.entry(), from_screen: TelemetryScreenSchema, status: oneOf(["draft", "released"]) },
+    wire: { name: "entry.opened" }
+  }),
+  releaseClicked: spec({
+    name: "release clicked",
+    owner: "page",
+    expect: "daily",
+    trigger: "a person pressed release",
+    question: "How do people release?",
+    properties: { entries: count(), via: oneOf(["row", "release_all", "palette", "entry_page", "selection", "shortcut", "menu"]) },
+    wire: { name: "release.clicked" }
+  }),
+  generateClicked: spec({
+    name: "generate clicked",
+    owner: "page",
+    expect: "daily",
+    trigger: "a person pressed Generate",
+    question: "Where do people press Generate?",
+    properties: { layout: oneOf(["timeline", "list"]) },
+    wire: { name: "generate.clicked" }
+  }),
+  onboardingStepViewed: spec({
+    name: "onboarding step viewed",
+    owner: "page",
+    expect: "weekly",
+    trigger: "an onboarding step was shown",
+    question: "Where does onboarding lose people?",
+    properties: { step: oneOf(["capture", "entries", "permissions", "release"]) },
+    wire: { name: "onboarding.step_viewed" }
+  }),
+  onboardingCompleted: spec({
+    name: "onboarding completed",
+    owner: "page",
+    expect: "weekly",
+    trigger: "onboarding ended",
+    question: "How long does onboarding take?",
+    properties: { seconds: duration() },
+    wire: { name: "onboarding.completed" }
+  }),
+  appError: spec({
+    name: "app error",
+    owner: "page",
+    expect: "rare",
+    trigger: "the page caught an error",
+    question: "Where does the page break?",
+    properties: { kind: AppErrorKindSchema, error_class: AppErrorClassSchema, $screen_name: TelemetryScreenSchema, page_build: PageBuildSchema },
+    wire: { name: "app.error", rename: { screen: "$screen_name" } }
+  })
+};
+var EVENT_KEYS = Object.keys(CATALOGUE);
+var WIRE_KEYS = new Map(EVENT_KEYS.flatMap((key) => {
+  const wire = CATALOGUE[key].wire;
+  return wire === undefined ? [] : [[wire.name, key]];
+}));
+var TELEMETRY_WIRE_NAMES = [...WIRE_KEYS.keys()];
+function keyOfWire(name) {
+  return WIRE_KEYS.get(name);
+}
+function wireSchemaOf(name) {
+  const wire = CATALOGUE[keyOfWire(name)].wire;
+  if (wire.properties !== undefined)
+    return wire.properties;
+  const back = new Map(Object.entries(wire.rename ?? {}).map(([wireKey, eventKey]) => [eventKey, wireKey]));
+  const shape = {};
+  for (const [key, schema] of Object.entries(CATALOGUE[keyOfWire(name)].properties.shape)) {
+    if (!(wire.beside ?? []).includes(key))
+      shape[back.get(key) ?? key] = schema;
+  }
+  return exports_external.object(shape);
+}
+// packages/contracts/src/analytics/common.ts
+var EventSourceSchema = oneOf(["api", "pipeline", "job", "daemon", "app"]);
+var OsSchema = oneOf(["macos", "windows", "ios", "android", "web"]);
+var COMMON_PROPERTIES = {
+  source: EventSourceSchema,
+  is_internal: bool(),
+  app_version: version(),
+  os: OsSchema,
+  device_id: ids.device(),
+  firm_id: ids.firm(),
+  $session_id: sessionId()
+};
+// packages/contracts/src/calendar.ts
+var CalendarProviderSchema = exports_external.enum(["microsoft", "google"]);
+var CalendarAccountKindSchema = exports_external.enum(["work", "personal"]);
+var CalendarConnectionStatusSchema = exports_external.enum(["connected", "awaiting_admin", "needs_reconnect"]);
+var CalendarConnectionSchema = exports_external.object({
+  provider: CalendarProviderSchema,
+  account_kind: CalendarAccountKindSchema,
+  account_email: exports_external.string(),
+  status: CalendarConnectionStatusSchema,
+  admin_consent_url: exports_external.string().nullable(),
+  last_synced_at: TimestampSchema.nullable()
+});
+var CalendarConnectRequestSchema = exports_external.object({
+  provider: CalendarProviderSchema,
+  state: exports_external.string().min(16),
+  code_challenge: exports_external.string().min(16)
+});
+var CalendarConnectAnswerSchema = exports_external.object({ authorize_url: exports_external.string().url(), state_token: exports_external.string().min(1).optional() });
+var CalendarConnectFinishSchema = exports_external.union([
+  exports_external.object({
+    state: exports_external.string().min(16),
+    state_token: exports_external.string().min(1).max(4096).optional(),
+    code: exports_external.string().min(1),
+    code_verifier: exports_external.string().min(43).max(128)
+  }).strict(),
+  exports_external.object({
+    state: exports_external.string().min(16),
+    state_token: exports_external.string().min(1).max(4096).optional(),
+    error: exports_external.string().min(1).max(200),
+    error_description: exports_external.string().max(2000).optional(),
+    error_subcode: exports_external.string().max(200).optional()
+  }).strict()
+]);
+var CalendarResponseSchema = exports_external.enum(["organiser", "accepted", "tentative", "declined", "none"]);
+var CalendarGuestSchema = exports_external.object({
+  name: exports_external.string(),
+  email: exports_external.string().nullable(),
+  response: CalendarResponseSchema,
+  organiser: exports_external.boolean(),
+  me: exports_external.boolean()
+});
+var CalendarWhereSchema = exports_external.object({
+  kind: exports_external.enum(["call", "address", "none"]),
+  text: exports_external.string().nullable()
+});
+var CalendarEventSchema = exports_external.object({
+  id: exports_external.string().min(1),
+  title: exports_external.string(),
+  from: TimestampSchema,
+  to: TimestampSchema,
+  all_day: exports_external.boolean(),
+  status: exports_external.enum(["confirmed", "cancelled"]),
+  my_response: CalendarResponseSchema,
+  where: CalendarWhereSchema,
+  guests: exports_external.array(CalendarGuestSchema),
+  provider: CalendarProviderSchema,
+  web_link: exports_external.string().nullable(),
+  not_attended: exports_external.boolean(),
+  can_mark: exports_external.boolean()
+});
+var CalendarDaySchema = exports_external.object({
+  events: exports_external.array(CalendarEventSchema)
+});
+
 // packages/contracts/src/evidence.ts
 var HostSchema = exports_external.string().transform((h) => h.trim().toLowerCase()).pipe(exports_external.string().max(253).regex(/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/, "expected a url host: lower-case labels, no scheme, no port and no path"));
 var WitnessSchema = exports_external.object({
@@ -5036,11 +5865,18 @@ var IntervalTextSchema = exports_external.object({
 // packages/contracts/src/api.ts
 var ProblemSchema = exports_external.object({
   type: exports_external.string().min(1),
+  code: exports_external.string().min(1).optional(),
   title: exports_external.string().min(1),
   status: exports_external.number().int().min(400).max(599),
   detail: exports_external.string().optional(),
   instance: exports_external.string().optional(),
-  errors: exports_external.array(exports_external.object({ path: exports_external.string(), message: exports_external.string(), reason: exports_external.string().optional() })).optional()
+  errors: exports_external.array(exports_external.object({
+    path: exports_external.string(),
+    message: exports_external.string(),
+    reason: exports_external.string().optional(),
+    rule: exports_external.string().min(1).optional(),
+    params: exports_external.record(exports_external.union([exports_external.string(), exports_external.number()])).optional()
+  })).optional()
 });
 var CursorSchema = exports_external.string().min(1);
 var PullQuerySchema = exports_external.object({
@@ -5108,10 +5944,9 @@ var EntrySizeSchema = exports_external.enum(["fewer", "balanced", "more"]);
 var MePatchSchema = exports_external.object({
   name: exports_external.string().trim().min(1).max(200).optional(),
   narrative_language: NarrativeLanguageSchema.nullable().optional(),
-  entry_size: EntrySizeSchema.nullable().optional()
-}).refine((patch) => patch.name !== undefined || patch.narrative_language !== undefined || patch.entry_size !== undefined, {
-  message: "name, narrative_language or entry_size is required"
-});
+  entry_size: EntrySizeSchema.nullable().optional(),
+  time_zone: exports_external.string().min(1).max(64).optional()
+}).refine((patch) => patch.name !== undefined || patch.narrative_language !== undefined || patch.entry_size !== undefined || patch.time_zone !== undefined, { message: "name, narrative_language, entry_size or time_zone is required" });
 var MemberSchema = exports_external.object({
   id: MemberIdSchema,
   user_id: UserIdSchema,
@@ -5168,14 +6003,19 @@ var MeSchema = exports_external.object({
     connector: MeConnectorSchema.nullable()
   }),
   member: MemberSchema.extend({
-    system_link: MeSystemLinkSchema.nullable().default(null)
+    system_link: MeSystemLinkSchema.nullable().default(null),
+    time_zone: exports_external.string().nullable().optional(),
+    time_zone_next: exports_external.string().nullable().optional(),
+    time_zone_next_from: LocalDaySchema.nullable().optional()
   }),
   permissions: exports_external.array(exports_external.string()).default([]),
   judgment_pipeline: JudgmentPipelineSchema.default("standard"),
   legalsense_connector: exports_external.boolean().default(false),
   calendar_offered: exports_external.boolean().optional(),
   swallow_short_pauses: exports_external.boolean().optional(),
-  pipeline_shadow: exports_external.boolean().optional()
+  pipeline_shadow: exports_external.boolean().optional(),
+  narrative_limit: exports_external.object({ limit: exports_external.number().int().positive(), by: exports_external.enum(["firm", "house", "system", "max"]) }).optional(),
+  practice: exports_external.record(exports_external.unknown()).nullable().optional()
 });
 var ProvisionResultSchema = MeSchema.extend({
   action: exports_external.enum(["ready", "refresh"]).default("ready")
@@ -5297,10 +6137,24 @@ var EntryRowSchema = exports_external.object({
   entry: EntrySchema,
   delivery: DeliverySchema.nullable().optional()
 });
+var DayBlockerSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  rule: exports_external.string().min(1),
+  params: exports_external.record(exports_external.union([exports_external.string(), exports_external.number()])).optional()
+});
+var DayEntryRowSchema = EntryRowSchema.extend({
+  editable: exports_external.boolean().optional(),
+  blockers: exports_external.array(DayBlockerSchema).optional(),
+  options: exports_external.record(exports_external.array(OptionSchema)).optional()
+});
 var DayReadSchema = exports_external.object({
   day: LocalDaySchema,
   unit_seconds: exports_external.number().int().positive(),
-  entries: exports_external.array(EntryRowSchema),
+  zone: exports_external.string().optional(),
+  t_start: TimestampSchema.optional(),
+  t_end: TimestampSchema.optional(),
+  provisional: exports_external.boolean().optional(),
+  entries: exports_external.array(DayEntryRowSchema),
   intervals: exports_external.array(DayIntervalSchema),
   entry_intervals: exports_external.array(DayIntervalSchema).default([]),
   calendar: CalendarDaySchema.optional()
@@ -5600,185 +6454,8 @@ var CompletionWireResponseSchema = exports_external.object({
     priced: exports_external.boolean()
   })
 });
-var RawArchiveReasonSchema = exports_external.enum([
-  "person",
-  "expired",
-  "signed_out",
-  "tenant_changed",
-  "not_allowed",
-  "refused",
-  "disk_low"
-]);
 var RAW_ARCHIVE_EVENT_NAMES = ["raw_archive.turned_on", "raw_archive.turned_off"];
-var TelemetryScreenSchema = exports_external.enum(["day", "timeline", "entry", "settings", "sign_in", "onboarding", "permissions"]);
-var TelemetryCommandSchema = exports_external.enum([
-  "new-entry",
-  "release-all",
-  "settings",
-  "exit",
-  "undo",
-  "redo",
-  "cut",
-  "copy",
-  "paste",
-  "select-all",
-  "today",
-  "previous-day",
-  "next-day",
-  "previous-entry",
-  "next-entry",
-  "actions",
-  "capture",
-  "privacy",
-  "about",
-  "folder",
-  "release",
-  "matter",
-  "attribute",
-  "merge",
-  "delete",
-  "open"
-]);
-var Whole = exports_external.number().int().nonnegative();
-var TELEMETRY_SECONDS_MAX = 86400;
-var ForegroundSeconds = Whole.max(TELEMETRY_SECONDS_MAX);
-var TELEMETRY_DAY_OFFSET_MAX = 3660;
-var TELEMETRY_ENTRY_ID_MAX = 64;
-var GenerateFailureSchema = exports_external.enum(["model", "deadline", "overlap", "other"]);
-var AppErrorKindSchema = exports_external.enum(["boundary", "uncaught", "unhandled_rejection"]);
-var AppErrorClassSchema = exports_external.enum([
-  "Error",
-  "TypeError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "ChunkLoadError",
-  "AbortError",
-  "other"
-]);
-var PageBuildSchema = exports_external.string().regex(/^\d{14}-[0-9A-Za-z]{1,40}$/, "expected YYYYMMDDHHMMSS-<commit>");
-var TELEMETRY_EVENT_PROPERTIES = {
-  "capture.started": exports_external.object({
-    trigger: exports_external.enum(["button", "tray", "always_on", "launch", "sign_in"]),
-    is_always_on: exports_external.boolean(),
-    swallow_short_pauses: exports_external.boolean().optional()
-  }),
-  "capture.stopped": exports_external.object({
-    trigger: exports_external.enum(["button", "tray", "quit", "update", "sign_out"]),
-    seconds: Whole,
-    entries: Whole,
-    windows_failed: Whole
-  }),
-  "user.signed_out": exports_external.object({ trigger: exports_external.enum(["menu", "tray", "session_expired"]) }),
-  "permission.changed": exports_external.object({ permission: exports_external.enum(["accessibility", "automation"]), is_granted: exports_external.boolean() }),
-  "update.failed": exports_external.object({ stage: exports_external.enum(["check", "download", "apply"]) }),
-  "setting.changed": exports_external.object({
-    setting: exports_external.enum([
-      "unit_minutes",
-      "narrative_language",
-      "narrative_max_chars",
-      "always_on",
-      "launch_at_login",
-      "theme",
-      "exclusions",
-      "entry_size"
-    ]),
-    scope: exports_external.enum(["device"])
-  }),
-  "raw_archive.turned_on": exports_external.object({}),
-  "raw_archive.turned_off": exports_external.object({}),
-  "generate.started": exports_external.object({
-    trigger: exports_external.enum(["press", "backstop"]),
-    intervals: Whole,
-    recordings: Whole,
-    run_id: RunIdSchema,
-    day_offset: exports_external.number().int().min(-TELEMETRY_DAY_OFFSET_MAX).max(TELEMETRY_DAY_OFFSET_MAX)
-  }),
-  "generate.finished": exports_external.object({
-    trigger: exports_external.enum(["press", "backstop"]),
-    entries: Whole,
-    blocks_joined: Whole,
-    seconds: Whole,
-    calls: Whole,
-    run_id: RunIdSchema,
-    day_offset: exports_external.number().int().min(-TELEMETRY_DAY_OFFSET_MAX).max(TELEMETRY_DAY_OFFSET_MAX),
-    entries_clipped: Whole,
-    attempts: Whole
-  }),
-  "generate.failed": exports_external.object({
-    trigger: exports_external.enum(["press", "backstop"]),
-    step: exports_external.enum(["decide", "join", "narrative", "write"]),
-    run_id: RunIdSchema,
-    day_offset: exports_external.number().int().min(-TELEMETRY_DAY_OFFSET_MAX).max(TELEMETRY_DAY_OFFSET_MAX),
-    failure: GenerateFailureSchema,
-    attempts: Whole
-  }),
-  "entry.proposed": exports_external.object({
-    ranges: Whole,
-    intervals: Whole,
-    how: exports_external.enum(["chosen", "most", "tie", "none"]),
-    tie_called: exports_external.boolean(),
-    attribute_calls: Whole,
-    kept: exports_external.enum(["no_text", "not_signed_in", "refused", "offline"]),
-    profile_ms: Whole,
-    read_ms: Whole,
-    matter_ms: Whole,
-    attributes_ms: Whole,
-    narrative_ms: Whole,
-    total_ms: Whole,
-    run_id: RunIdSchema
-  }),
-  "application.opened": exports_external.object({
-    trigger: exports_external.enum(["launch", "login_item", "after_update", "tray"]),
-    is_first_open: exports_external.boolean()
-  }),
-  "application.became_active": exports_external.object({ trigger: exports_external.enum(["launch", "tray", "dock", "notification", "shortcut"]) }),
-  "application.backgrounded": exports_external.object({ foreground_seconds: ForegroundSeconds }),
-  "app.usage": exports_external.object({ day: LocalDaySchema, foreground_seconds: ForegroundSeconds, sessions: Whole }),
-  "screen.viewed": exports_external.object({
-    screen: TelemetryScreenSchema,
-    settings_page: exports_external.enum([
-      "profile",
-      "calendar",
-      "preferences",
-      "appearance",
-      "capture",
-      "privacy",
-      "general",
-      "members",
-      "timekeeping",
-      "narratives",
-      "practice-system",
-      "matters",
-      "member"
-    ]),
-    from_screen: TelemetryScreenSchema,
-    day_offset: exports_external.number().int().min(-TELEMETRY_DAY_OFFSET_MAX).max(TELEMETRY_DAY_OFFSET_MAX)
-  }),
-  "command.used": exports_external.object({
-    command: TelemetryCommandSchema,
-    via: exports_external.enum(["menu", "palette", "shortcut", "row_menu", "tray", "button"])
-  }),
-  "entry.opened": exports_external.object({
-    entry_id: EntryIdSchema.max(TELEMETRY_ENTRY_ID_MAX),
-    from_screen: TelemetryScreenSchema,
-    status: exports_external.enum(["draft", "released"])
-  }),
-  "release.clicked": exports_external.object({
-    entries: Whole,
-    via: exports_external.enum(["row", "release_all", "palette", "entry_page", "selection", "shortcut", "menu"])
-  }),
-  "generate.clicked": exports_external.object({ layout: exports_external.enum(["timeline", "list"]) }),
-  "onboarding.step_viewed": exports_external.object({ step: exports_external.enum(["capture", "entries", "permissions", "release"]) }),
-  "onboarding.completed": exports_external.object({ seconds: Whole }),
-  "app.error": exports_external.object({
-    kind: AppErrorKindSchema,
-    error_class: AppErrorClassSchema,
-    screen: TelemetryScreenSchema,
-    page_build: PageBuildSchema
-  })
-};
-var TelemetryEventNameSchema = exports_external.enum(Object.keys(TELEMETRY_EVENT_PROPERTIES));
+var TelemetryEventNameSchema = exports_external.enum(TELEMETRY_WIRE_NAMES);
 var TelemetryPropertyValueSchema = exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()]);
 var TelemetrySessionIdSchema = exports_external.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, "expected a UUIDv7");
 var TelemetryEventSchema = exports_external.object({
@@ -5799,7 +6476,7 @@ var TelemetryEventSchema = exports_external.object({
     refuse("raw_archive.turned_on carries the reason person, and only that");
   }
   if (event.properties !== undefined) {
-    const allowed = TELEMETRY_EVENT_PROPERTIES[event.name].partial().strict().safeParse(event.properties);
+    const allowed = wireSchemaOf(event.name).partial().strict().safeParse(event.properties);
     if (!allowed.success) {
       for (const issue of allowed.error.issues) {
         ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["properties", ...issue.path], message: issue.message });
@@ -5852,111 +6529,6 @@ var FirmInvitationsSchema = exports_external.object({ invitations: exports_exter
 var InvitationRevokedSchema = exports_external.object({
   invitation: exports_external.object({ id: exports_external.string(), email: exports_external.string() })
 });
-// packages/contracts/src/admin-research.ts
-var ResearchExportParamsSchema = exports_external.object({ tenant: TenantIdSchema });
-var ResearchExportRequestSchema = exports_external.object({
-  from: LocalDaySchema,
-  to: LocalDaySchema
-}).refine((range) => !Number.isNaN(Date.parse(`${range.from}T00:00:00.000Z`)), {
-  message: "from is not a real day",
-  path: ["from"]
-}).refine((range) => !Number.isNaN(Date.parse(`${range.to}T00:00:00.000Z`)), {
-  message: "to is not a real day",
-  path: ["to"]
-}).refine((range) => range.from < range.to, {
-  message: "from must be before to; the range is half-open and an empty one exports nothing",
-  path: ["to"]
-});
-var Base64Schema = exports_external.string().regex(/^[A-Za-z0-9+/]*={0,2}$/, "expected base64");
-var SealedResearchCardSchema = exports_external.object({
-  id: exports_external.string(),
-  tenant_id: exports_external.string(),
-  member_id: exports_external.string(),
-  device_id: exports_external.string().nullable(),
-  purpose: exports_external.string(),
-  model: exports_external.string(),
-  created_at: exports_external.string(),
-  key_version: exports_external.number().int().positive(),
-  sealed_key: Base64Schema,
-  card_ct: Base64Schema,
-  answer_ct: Base64Schema
-});
-var JudgedPairEntrySchema = exports_external.object({
-  day: exports_external.string(),
-  time_zone: exports_external.string(),
-  timekeeper_id: exports_external.string(),
-  t_start: exports_external.string(),
-  t_end: exports_external.string(),
-  parts: exports_external.array(exports_external.object({ t_start: exports_external.string(), t_end: exports_external.string() })).nullable().default(null),
-  override_seconds: exports_external.number().int().nullable().default(null),
-  narrative: exports_external.string(),
-  matter_id: exports_external.string().nullable(),
-  attributes: exports_external.unknown(),
-  internal_note: exports_external.string().nullable()
-});
-var JudgedPairSchema = exports_external.object({
-  entry_id: exports_external.string(),
-  tenant_id: exports_external.string(),
-  member_id: exports_external.string(),
-  day: exports_external.string(),
-  status: exports_external.string(),
-  edited_at: exports_external.string().nullable(),
-  as_judged: exports_external.unknown(),
-  as_released_or_current: JudgedPairEntrySchema
-});
-var ExportHeadSchema = exports_external.object({
-  export_id: exports_external.string(),
-  tenant_id: exports_external.string(),
-  tenant_name: exports_external.string(),
-  from: exports_external.string(),
-  to: exports_external.string(),
-  operator: exports_external.string()
-});
-var ResearchExportConfidentialSchema = ExportHeadSchema.extend({
-  tier: exports_external.literal("confidential"),
-  rows: exports_external.literal(0)
-});
-var ResearchExportSealedSchema = ExportHeadSchema.extend({
-  tier: exports_external.literal("standard"),
-  rows: exports_external.number().int().nonnegative(),
-  cards: exports_external.number().int().nonnegative(),
-  pairs: exports_external.number().int().nonnegative(),
-  research_key_name: exports_external.string(),
-  sealed_cards: exports_external.array(SealedResearchCardSchema),
-  judged_pairs: exports_external.array(JudgedPairSchema)
-});
-var ResearchExportResultSchema = exports_external.discriminatedUnion("tier", [
-  ResearchExportConfidentialSchema,
-  ResearchExportSealedSchema
-]);
-var ResearchContextExportSchema = exports_external.object({
-  export_id: exports_external.string(),
-  tenant_id: exports_external.string(),
-  tenant_name: exports_external.string(),
-  from: exports_external.string(),
-  to: exports_external.string(),
-  operator: exports_external.string(),
-  contexts: exports_external.array(exports_external.object({
-    member_id: exports_external.string(),
-    device_id: exports_external.string().optional(),
-    recording_id: exports_external.string(),
-    seq: exports_external.number().int(),
-    t_start: exports_external.string(),
-    t_end: exports_external.string(),
-    context: exports_external.unknown()
-  })),
-  steps: exports_external.array(exports_external.object({
-    run_id: exports_external.string(),
-    kind: exports_external.string(),
-    member_id: exports_external.string(),
-    subject_from: exports_external.string(),
-    name: exports_external.string(),
-    prompt_fingerprint: exports_external.string().nullable(),
-    usage: exports_external.unknown(),
-    output: exports_external.unknown(),
-    created_at: exports_external.string()
-  }))
-});
 // packages/contracts/src/admin-tenants.ts
 var AdminTenantParamsSchema = exports_external.object({ tenant: TenantIdSchema });
 var AdminSecurityTierSchema = exports_external.enum(["standard", "confidential"]);
@@ -5997,10 +6569,6 @@ var AdminRawArchiveSetSchema = exports_external.object({ allowed: exports_extern
 var AdminTenantFlagsSchema = exports_external.object({
   tenant: exports_external.object({ id: TenantIdSchema, name: exports_external.string(), internal: exports_external.boolean(), raw_archive: exports_external.boolean() })
 });
-var AdminResearchExportSetSchema = exports_external.object({ research_export: exports_external.boolean() });
-var AdminResearchExportFlagSchema = exports_external.object({
-  tenant: exports_external.object({ id: TenantIdSchema, name: exports_external.string(), research_export: exports_external.boolean() })
-});
 var AdminDemoSetSchema = exports_external.object({ enabled: exports_external.boolean() });
 var AdminDemoFlagSchema = exports_external.object({
   tenant: exports_external.object({ id: TenantIdSchema, name: exports_external.string(), demo: exports_external.boolean() })
@@ -6039,6 +6607,7 @@ var AdminEntriesPurgeResultSchema = exports_external.object({
   user: UserIdSchema,
   dry_run: exports_external.boolean(),
   rows: exports_external.object({ demo: exports_external.array(AdminPurgeRowSchema), unmatched: exports_external.array(AdminPurgeRowSchema) }),
+  kept: exports_external.object({ demo: exports_external.array(AdminPurgeRowSchema) }).default({ demo: [] }),
   deleted: exports_external.object({ demo: exports_external.number().int(), unmatched: exports_external.number().int(), total: exports_external.number().int() }).nullable()
 });
 var AdminContextRetentionSetSchema = exports_external.object({ days: exports_external.number().int().min(1).max(365) });
@@ -6202,6 +6771,115 @@ var ClientOutdatedProblemSchema = ProblemSchema.extend({
   status: exports_external.literal(400),
   minimum: exports_external.string().regex(/^\d+\.\d+\.\d+$/)
 });
+// packages/contracts/src/compat/retirements.ts
+var PR4 = { pr: "pr4" };
+var MIRRORS = "services/api/migrations/0054_mirrors.sql";
+var COMPAT_PATHS = [
+  { name: "the app.scope arm for transactions without a scope", file: "services/api/migrations/0053_scopes.sql", needle: "app_scope() is null", retiredBy: PR4 },
+  { name: "the content-free as_judged marker", file: "services/api/migrations/0056_entry_guards.sql", needle: "as_judged = '{}'", retiredBy: PR4 },
+  { name: "the calendar connect-state fallback to the old table", file: "services/api/src/features/calendar/store.ts", needle: "calendar_connect_states", retiredBy: PR4 },
+  { name: "the worker's alias of PR 1's task path", file: "services/api/src/platform/jobs/service.ts", needle: "/internal/pipeline/run", retiredBy: PR4 },
+  { name: "the 0.5 telemetry relay", file: "services/api/src/features/evidence/telemetry.ts", needle: 'path: "/v1/telemetry"', retiredBy: PR4 },
+  { name: "the mirror triggers of the merged tables", file: MIRRORS, needle: "create trigger", retiredBy: PR4 },
+  ...[
+    "connector_timekeepers_mirror",
+    "connector_sessions_mirror",
+    "connector_links_mirror",
+    "connector_pushes_mirror",
+    "connector_deliveries_mirror",
+    "deliveries_mirror",
+    "calendar_event_marks_mirror",
+    "calendar_events_mirror_insert",
+    "calendar_events_mirror_update"
+  ].map((trigger) => ({ name: `the mirror trigger ${trigger}`, file: MIRRORS, needle: `create trigger ${trigger}`, retiredBy: PR4 }))
+];
+var markers = (marker, files) => files.map((file) => ({ file, marker }));
+var COMPAT_MARKERS = [
+  ...markers("#180", [
+    "boundaries.ts",
+    "packages/client/test/t31-problems.test.ts",
+    "packages/contracts/src/api.ts",
+    "packages/contracts/src/compat.ts",
+    "packages/contracts/src/config.ts",
+    "packages/contracts/src/entry.ts",
+    "packages/contracts/src/evidence.ts",
+    "packages/contracts/src/index.ts",
+    "packages/contracts/src/run.ts",
+    "packages/contracts/src/vocabulary.ts",
+    "packages/contracts/test/config.test.ts",
+    "packages/contracts/test/desktop-lines.ts",
+    "packages/contracts/test/entry.test.ts",
+    "packages/contracts/test/t36-contracts.test.ts",
+    "packages/contracts/test/vocabulary.test.ts",
+    "services/api/Dockerfile",
+    "services/api/openapi.json",
+    "services/api/src/app.ts",
+    "services/api/src/features/cells/routes.ts",
+    "services/api/src/features/generate/proxy.ts",
+    "services/api/src/features/lists/vocabulary-store.ts",
+    "services/api/src/features/lists/vocabulary.ts",
+    "services/api/src/features/people/me.ts",
+    "services/api/src/features/update/config.ts",
+    "services/api/src/features/update/slice.ts",
+    "services/api/src/platform/http/config-version.ts",
+    "services/api/src/platform/http/problems.ts",
+    "services/api/src/platform/http/router.ts",
+    "services/api/src/platform/models/bundle.ts",
+    "services/api/src/platform/models/compat/activity-types.json",
+    "services/api/src/platform/models/compat/activity-types.ts",
+    "services/api/src/platform/models/compat/activity.md",
+    "services/api/src/platform/models/compat/narrative.md",
+    "services/api/src/platform/models/jev.ts",
+    "services/api/src/platform/models/usage.ts",
+    "services/api/test/admin-acting.test.ts",
+    "services/api/test/compat-180.test.ts",
+    "services/api/test/jev-route.test.ts",
+    "services/api/test/t15-bundle.test.ts",
+    "services/api/test/t15-lists.test.ts",
+    "services/api/test/t34-vocabulary.test.ts",
+    "services/api/test/t40-firm.test.ts",
+    "services/api/test/t42-intervals.test.ts",
+    "services/api/test/t53-bundle.test.ts"
+  ]),
+  ...markers("narrative-languages", ["services/api/src/app.ts", "services/api/src/features/update/legacy-languages.ts"]),
+  ...markers("pr4", [
+    "boundaries.ts",
+    ".github/scripts/page-minimum.test.ts",
+    ".github/scripts/page-minimum.ts",
+    "apps/web/version.ts",
+    "packages/client/src/copy/index.ts",
+    "packages/client/src/data/failures-compat.ts",
+    "packages/client/src/data/failures.ts",
+    "packages/client/src/data/index.ts",
+    "packages/client/src/data/mutations.ts",
+    "packages/client/src/screens/time/grid.ts",
+    "packages/client/src/screens/time/intervals.ts",
+    "packages/client/src/screens/time/span.tsx",
+    "packages/client/src/screens/time/timeline-blocks.tsx",
+    "packages/client/test/t132-codes.test.ts",
+    "packages/contracts/src/admin-tenants.ts",
+    "packages/contracts/src/analytics/catalogue.ts",
+    "packages/contracts/src/api.ts",
+    "packages/contracts/src/connector.ts",
+    "services/api/migrations/0054_mirrors.sql",
+    "services/api/src/features/calendar/routes.ts",
+    "services/api/src/features/calendar/store.ts",
+    "services/api/src/features/entries/lifecycle.ts",
+    "services/api/src/features/entries/store.ts",
+    "services/api/src/features/lists/store.ts",
+    "services/api/src/features/evidence/retention.ts",
+    "services/api/src/features/evidence/telemetry.ts",
+    "services/api/src/features/operator/tenants.ts",
+    "services/api/src/platform/jobs/jobs.ts",
+    "services/api/src/platform/jobs/ledger.ts",
+    "services/api/src/platform/jobs/service.ts",
+    "services/api/test/t134-scopes.test.ts",
+    "services/api/test/t142-jobs.test.ts",
+    "services/api/test/t90-calendar-connect.test.ts",
+    "tools/release/src/assemble-page.ts"
+  ]),
+  ...markers("0.6.0", ["packages/client/src/data/page-update.ts"])
+];
 // packages/contracts/src/config.ts
 var ConfigVersionSchema = exports_external.string().regex(/^[0-9a-f]{12}$/, "expected a 12-character lower-case hex fingerprint");
 var ConfigModelsSchema = exports_external.object({
@@ -6319,7 +6997,14 @@ var DemoObservationSchema = exports_external.object({
 }).strict();
 var DemoDecisionSchema = exports_external.object({ summary: exports_external.string().min(1), activity: exports_external.string().min(1).nullable(), matter: KeySchema.nullable() }).strict();
 var DemoIntervalSchema = exports_external.object({ from: ClockSchema, to: ClockSchema, observations: exports_external.array(DemoObservationSchema).default([]), decision: DemoDecisionSchema.optional() }).strict();
-var DemoEntrySchema = exports_external.object({ from: ClockSchema, to: ClockSchema, matter: KeySchema.nullable(), narrative: exports_external.string().min(1), codes: exports_external.record(exports_external.string().min(1)).default({}) }).strict();
+var DemoEntrySchema = exports_external.object({
+  from: ClockSchema,
+  to: ClockSchema,
+  matter: KeySchema.nullable(),
+  narrative: exports_external.string(),
+  codes: exports_external.record(exports_external.string().min(1)).default({}),
+  released: exports_external.boolean().optional()
+}).strict();
 var DemoRecordingSchema = exports_external.object({ start: ClockSchema, stop: ClockSchema, intervals: exports_external.array(DemoIntervalSchema).min(1) }).strict();
 var minutes = (clock) => Number(clock.slice(0, 2)) * 60 + Number(clock.slice(3));
 function problemsOf(s) {
@@ -6382,6 +7067,14 @@ function problemsOf(s) {
     for (let k = first;k <= last; k++)
       covered.has(k) ? out.push([at, "entries do not overlap"]) : covered.add(k);
   });
+  s.entries.forEach((e, i) => {
+    if (e.released !== true)
+      return;
+    if (e.matter === null)
+      out.push([["entries", i, "released"], "a released entry has a matter"]);
+    if (e.narrative.trim() === "")
+      out.push([["entries", i, "released"], "a released entry has a narrative"]);
+  });
   const clock = (m) => `${String(Math.floor(m / 60)).padStart(2, "0")}:${String(m % 60).padStart(2, "0")}`;
   if (s.entries.length > 0)
     all.forEach((one, k) => one.work !== null && !covered.has(k) && out.push([["entries"], `the work at ${clock(one.from)} is in no entry`]));
@@ -6391,6 +7084,7 @@ var DemoScenarioSchema = exports_external.object({
   format: exports_external.literal(1),
   name: KeySchema,
   description: exports_external.string().default(""),
+  weekday: exports_external.number().int().min(1).max(5).optional(),
   time_zone: exports_external.string().min(1),
   unit_minutes: exports_external.number().int().min(1).max(60),
   clients: exports_external.array(exports_external.object({ key: KeySchema, name: exports_external.string().min(1) }).strict()),
@@ -6407,22 +7101,55 @@ function replayGap(s) {
     return "every interval needs its decision";
   return s.entries.length === 0 ? "a replay needs the scenario's entries" : null;
 }
+var DEMO_MAX_DAYS = 31;
 var AdminDemoSeedSchema = exports_external.object({
-  scenario: DemoScenarioSchema,
+  scenario: DemoScenarioSchema.optional(),
+  scenarios: exports_external.array(DemoScenarioSchema).min(1).max(7).optional(),
   day: LocalDaySchema.optional(),
+  anchor: LocalDaySchema.optional(),
+  days: exports_external.number().int().min(1).max(DEMO_MAX_DAYS).optional(),
+  members: exports_external.array(exports_external.string().email()).max(20).default([]),
   replay: exports_external.boolean().default(false),
   generate: exports_external.boolean().default(false)
+}).superRefine((body, ctx) => {
+  if (body.scenario === undefined === (body.scenarios === undefined)) {
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["scenario"], message: "give scenario or scenarios, one of the two" });
+  }
+  const range = body.anchor !== undefined || body.days !== undefined || body.scenarios !== undefined;
+  if (range && body.day !== undefined)
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["day"], message: "day seeds one day; anchor and days seed a range: give one form" });
+  if (range && body.generate)
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["generate"], message: "a range writes its days' entries itself: generate is false" });
+  if (range && !body.replay)
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["replay"], message: "a range of days is written from the scenarios' decisions and entries: replay is true" });
+  const weekdays = (body.scenarios ?? []).map((one) => one.weekday);
+  if (weekdays.length > 1 && weekdays.some((one) => one === undefined)) {
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["scenarios"], message: "with more than one scenario, each names its weekday" });
+  }
+  if (new Set(weekdays).size !== weekdays.length)
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["scenarios"], message: "a weekday is named twice" });
 });
 var AdminDemoDaySchema = exports_external.object({ day: LocalDaySchema, generate: exports_external.boolean().default(false) });
 var counts = { member_id: MemberIdSchema, day: LocalDaySchema };
-var AdminDemoSeedResultSchema = exports_external.object({
-  ...counts,
+var SeededDaySchema = exports_external.object({
+  day: LocalDaySchema,
   mode: exports_external.enum(["live", "replay"]),
   recordings: exports_external.number().int(),
   contexts: exports_external.object({ stored: exports_external.number().int(), repeated: exports_external.number().int() }),
   created: exports_external.object({ clients: exports_external.number().int(), matters: exports_external.number().int() }),
   generate_run: exports_external.string().nullable()
 });
+var AdminDemoRangeDaySchema = SeededDaySchema.extend({
+  scenario: KeySchema,
+  replaced: exports_external.boolean(),
+  entries: exports_external.object({ written: exports_external.number().int(), released: exports_external.number().int().optional(), released_owed: exports_external.number().int() })
+});
+var AdminDemoInvitedSchema = exports_external.object({ email: exports_external.string(), outcome: exports_external.enum(["invited", "member", "invited_before"]) });
+var AdminDemoSeedResultSchema = SeededDaySchema.extend({
+  member_id: MemberIdSchema,
+  range: exports_external.array(AdminDemoRangeDaySchema).optional(),
+  members: exports_external.array(AdminDemoInvitedSchema).optional()
+});
 var AdminDemoResetResultSchema = exports_external.object({
   ...counts,
   runs_deleted: exports_external.number().int(),
@@ -6717,16 +7444,16 @@ var LocalEventSchema = exports_external.discriminatedUnion("type", [
 var LocalHostEventSchema = exports_external.discriminatedUnion("name", [
   exports_external.object({
     name: exports_external.literal("permission.changed"),
-    properties: TELEMETRY_EVENT_PROPERTIES["permission.changed"].strict()
+    properties: wireSchemaOf("permission.changed").strict()
   }).strict(),
   exports_external.object({
     name: exports_external.literal("update.failed"),
-    properties: TELEMETRY_EVENT_PROPERTIES["update.failed"].strict()
+    properties: wireSchemaOf("update.failed").strict()
   }).strict(),
   exports_external.object({
     name: exports_external.literal("setting.changed"),
     properties: exports_external.object({
-      setting: TELEMETRY_EVENT_PROPERTIES["setting.changed"].shape.setting.extract(["launch_at_login", "theme"]),
+      setting: wireSchemaOf("setting.changed").shape.setting.extract(["launch_at_login", "theme"]),
       scope: exports_external.literal("device")
     }).strict()
   }).strict()
@@ -6914,6 +7641,40 @@ var ContextSignalsV1Schema = exports_external.object({
   sent_at: TimestampSchema,
   observations: exports_external.array(exports_external.object({ id: ObservationIdSchema, signals: SignalsSchema })).min(1)
 });
+// packages/contracts/src/release.ts
+var VersionSchema = exports_external.string().regex(/^\d+\.\d+\.\d+$/, "a release is MAJOR.MINOR.N");
+var HostKeySchema = exports_external.union([exports_external.literal("unkeyed"), exports_external.string().regex(/^h:[0-9a-f]{8}$/)]);
+var DAY_MS = 24 * 60 * 60000;
+var ReleaseSchema = exports_external.object({
+  version: VersionSchema,
+  commit: exports_external.string().regex(/^[0-9a-f]{40}$/),
+  key: HostKeySchema,
+  promoted_at: exports_external.string().datetime(),
+  superseded_at: exports_external.string().datetime().nullable(),
+  state: exports_external.enum(["current", "superseded", "withdrawn"]),
+  urgent: exports_external.boolean(),
+  desktop: VersionSchema.nullable()
+});
+var ReleaseIndexSchema = exports_external.object({
+  releases: exports_external.array(ReleaseSchema)
+});
+var UpdateReleaseQuerySchema = exports_external.object({
+  key: HostKeySchema,
+  version: VersionSchema.optional(),
+  device: exports_external.string().min(1).max(200).optional()
+});
+var UpdateStateSchema = exports_external.enum(["current", "available", "required"]);
+var ReleaseSummarySchema = exports_external.object({
+  version: VersionSchema,
+  key: HostKeySchema,
+  promoted_at: exports_external.string().datetime(),
+  desktop: VersionSchema.nullable()
+});
+var UpdateReleaseResponseSchema = exports_external.object({
+  current: ReleaseSummarySchema.nullable(),
+  state: UpdateStateSchema,
+  expired: exports_external.boolean()
+});
 // packages/contracts/src/run.ts
 var VerdictSchema = exports_external.enum(["matter", "unmatched", "absent"]);
 var WORK_VERDICTS = ["matter", "unmatched"];
@@ -6951,132 +7712,6 @@ var RunSchema = exports_external.object({
   message: "an absent run is never an entry, so it carries no proposed attributes and no judged text",
   path: ["attributes"]
 });
-// packages/contracts/src/tools.ts
-var TimeRangeSchema = exports_external.object({
-  from: TimestampSchema.optional(),
-  to: TimestampSchema.optional()
-});
-var ZoomSchema = exports_external.enum(["day", "entry", "observation"]);
-var TimelineInputSchema = exports_external.object({
-  range: TimeRangeSchema,
-  zoom: ZoomSchema
-});
-var TimelineTotalsSchema = exports_external.object({
-  entries: exports_external.number().int().min(0),
-  observations: exports_external.number().int().min(0),
-  elapsed_minutes: exports_external.number().int().min(0),
-  away_minutes: exports_external.number().int().min(0),
-  span_seconds: exports_external.number().int().min(0)
-});
-var AwayGapSchema = exports_external.object({
-  from: TimestampSchema,
-  to: TimestampSchema,
-  minutes: exports_external.number().int().min(0),
-  reason: exports_external.enum(["no-signal", "lock", "sleep"]),
-  note: exports_external.string().nullable().default(null)
-});
-var EntryRefSchema = exports_external.object({
-  id: EntryIdSchema,
-  narrative: exports_external.string(),
-  t_start: TimestampSchema,
-  t_end: TimestampSchema,
-  elapsed_minutes: exports_external.number().int().min(0),
-  idle_ratio: exports_external.number().min(0).max(1),
-  matter_id: MatterIdSchema.nullable(),
-  assignment: AssignmentSchema.nullable(),
-  status: EntryStatusSchema,
-  observation_count: exports_external.number().int().min(0),
-  recording_id: RecordingIdSchema.nullable(),
-  owner: EntryOwnerSchema
-});
-var ObservationRefSchema = exports_external.object({
-  id: ObservationIdSchema,
-  t_start: TimestampSchema,
-  t_end: TimestampSchema,
-  app: exports_external.string(),
-  window_title: exports_external.string(),
-  url: exports_external.string().nullable(),
-  entry_id: EntryIdSchema.nullable()
-});
-var EvidenceRunSchema = exports_external.object({
-  kind: exports_external.enum(["run", "idle"]),
-  t_start: TimestampSchema,
-  t_end: TimestampSchema,
-  minutes: exports_external.number().int().min(0),
-  app: exports_external.string(),
-  title: exports_external.string(),
-  observation_ids: exports_external.array(ObservationIdSchema)
-});
-var TimelineDaySchema = exports_external.object({
-  id: DayIdSchema,
-  date: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  entries: exports_external.array(EntryRefSchema),
-  away: exports_external.array(AwayGapSchema),
-  totals: TimelineTotalsSchema
-});
-var TimelineResultSchema = exports_external.discriminatedUnion("zoom", [
-  exports_external.object({
-    zoom: exports_external.literal("day"),
-    range: TimeRangeSchema,
-    days: exports_external.array(TimelineDaySchema),
-    totals: TimelineTotalsSchema
-  }),
-  exports_external.object({
-    zoom: exports_external.literal("entry"),
-    range: TimeRangeSchema,
-    entries: exports_external.array(EntryRefSchema),
-    totals: TimelineTotalsSchema
-  }),
-  exports_external.object({
-    zoom: exports_external.literal("observation"),
-    range: TimeRangeSchema,
-    observations: exports_external.array(ObservationRefSchema),
-    totals: TimelineTotalsSchema
-  })
-]);
-var ReadInputSchema = exports_external.object({
-  id: exports_external.string().min(1)
-});
-var ReadObservationSchema = exports_external.object({
-  type: exports_external.literal("observation"),
-  id: ObservationIdSchema,
-  t_start: TimestampSchema,
-  t_end: TimestampSchema,
-  app: exports_external.string(),
-  window_title: exports_external.string(),
-  url: exports_external.string().nullable(),
-  signals: SignalsSchema,
-  snapshot_ids: exports_external.array(SnapshotIdSchema),
-  entry_id: EntryIdSchema.nullable(),
-  text: exports_external.string()
-});
-var ReadEntrySchema = exports_external.object({
-  type: exports_external.literal("entry"),
-  id: EntryIdSchema,
-  narrative: exports_external.string(),
-  t_start: TimestampSchema,
-  t_end: TimestampSchema,
-  elapsed_minutes: exports_external.number().int().min(0),
-  idle_ratio: exports_external.number().min(0).max(1),
-  matter_id: MatterIdSchema.nullable(),
-  assignment: AssignmentSchema.nullable(),
-  status: EntryStatusSchema,
-  observations: exports_external.array(ObservationRefSchema),
-  evidence: exports_external.array(EvidenceRunSchema)
-});
-var ReadDaySchema = exports_external.object({
-  type: exports_external.literal("day"),
-  id: DayIdSchema,
-  date: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  entries: exports_external.array(EntryRefSchema),
-  away: exports_external.array(AwayGapSchema),
-  totals: TimelineTotalsSchema
-});
-var ReadResultSchema = exports_external.discriminatedUnion("type", [
-  ReadObservationSchema,
-  ReadEntrySchema,
-  ReadDaySchema
-]);
 // packages/contracts/src/trace.ts
 var TraceMessageSchema = exports_external.object({
   role: exports_external.string().min(1),
@@ -7145,50 +7780,13 @@ import { join } from "node:path";
 
 // tools/admin/src/files.ts
 import { randomUUID } from "node:crypto";
-import { chmodSync, closeSync, mkdirSync, openSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { chmodSync, closeSync, mkdirSync, openSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 function makePrivateDirectory(path) {
   mkdirSync(path, { recursive: true, mode: 448 });
   const mode = statSync(path).mode & 511;
   if ((mode & 63) !== 0)
     chmodSync(path, 448);
 }
-function claimExportDirectory(path) {
-  const cannot = (err) => new AdminUsageError(`--out ${path} cannot be created: ${err.message}`);
-  try {
-    mkdirSync(dirname(path), { recursive: true, mode: 448 });
-  } catch (err) {
-    throw cannot(err);
-  }
-  try {
-    mkdirSync(path, { mode: 448 });
-    return { created: true };
-  } catch (err) {
-    if (err.code !== "EEXIST")
-      throw cannot(err);
-  }
-  const stat = statSync(path);
-  if (!stat.isDirectory())
-    throw new AdminUsageError(`--out ${path} is not a directory; name a new folder, and the export creates it 0700.`);
-  if (process.platform === "win32")
-    return { created: false };
-  const mode = stat.mode & 511;
-  if ((mode & 63) !== 0) {
-    throw new AdminUsageError(`--out ${path} can be read by other accounts on this machine (mode ${mode.toString(8)}); ` + "name a new folder, which the export creates 0700, or run chmod 700 on this one yourself.");
-  }
-  const uid = process.getuid?.();
-  if (uid !== undefined && stat.uid !== uid) {
-    throw new AdminUsageError(`--out ${path} belongs to another account on this machine; name a folder of your own.`);
-  }
-  return { created: false };
-}
-function releaseExportDirectory(path, claimed) {
-  if (!claimed.created)
-    return;
-  try {
-    rmdirSync(path);
-  } catch {}
-}
 function writePrivateFile(path, body) {
   const temporary = `${path}.${randomUUID()}.part`;
   const handle = openSync(temporary, "wx", 384);
@@ -7204,11 +7802,6 @@ function writePrivateFile(path, body) {
     rmSync(temporary, { force: true });
   }
 }
-function jsonLines(rows) {
-  return rows.map((row) => JSON.stringify(row)).join(`
-`) + (rows.length === 0 ? "" : `
-`);
-}
 
 // tools/admin/src/session.ts
 var WORKOS_API = "https://api.workos.com";
@@ -7465,24 +8058,6 @@ function purgeSection(label, rows) {
     return [`${label}: none`];
   return [`${label}: ${rows.length}`, ...rows.map(purgeLine)];
 }
-function exportLines(exports, error) {
-  if (exports === null) {
-    return [
-      `past exports  could not be read: ${error}`,
-      "The tier is set and the cards are deleted; only this list is missing. Run the command again to see it."
-    ];
-  }
-  if (exports.length === 0)
-    return ["past exports  none: no export of this firm was ever made."];
-  const day = (iso) => iso.slice(0, 10);
-  return [
-    `past exports  ${exports.length}`,
-    ...exports.map((row) => `              ${row.created_at}  ${row.operator}  ${day(row.from_at)} to ${day(row.to_at)}  ` + `${row.rows} row${row.rows === 1 ? "" : "s"}`),
-    "",
-    "Each of those exports wrote this firm's cards and narratives, decrypted, onto the operator's own machine:",
-    "this command deletes the rows in the cloud and can delete no file on a laptop, so find those files and delete them by hand."
-  ];
-}
 function table(headers, rows) {
   const widths = headers.map((head, i) => Math.max(head.length, ...rows.map((row) => row[i].length)));
   const line = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
@@ -7600,100 +8175,9 @@ function parseMatterSets(pairs) {
   return out;
 }
 
-// tools/admin/src/unseal.ts
-import { spawnSync } from "node:child_process";
-import { createDecipheriv } from "node:crypto";
-var KMS_ENDPOINT = "https://cloudkms.googleapis.com/v1";
-var FORMAT_VERSION = 1;
-var NONCE_BYTES = 12;
-var TAG_BYTES = 16;
-var HEADER_BYTES = 1 + NONCE_BYTES;
-
-class UnsealError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UnsealError";
-  }
-}
-function keyVersionName(researchKeyName, version) {
-  return `${researchKeyName.replace(/\/cryptoKeyVersions\/\d+$/, "")}/cryptoKeyVersions/${version}`;
-}
-async function asymmetricDecrypt(versionName, sealedKey, accessToken, fetchImpl) {
-  const response = await fetchImpl(`${KMS_ENDPOINT}/${versionName}:asymmetricDecrypt`, {
-    method: "POST",
-    headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" },
-    body: JSON.stringify({ ciphertext: sealedKey.toString("base64") })
-  });
-  if (!response.ok) {
-    throw new UnsealError(`Cloud KMS answered ${response.status} to asymmetricDecrypt on ${versionName}. ` + "A 403 means this identity may not unseal research cards; two named people hold that role and " + "nobody else, the runtime service account included.");
-  }
-  const body = await response.json();
-  if (typeof body.plaintext !== "string")
-    throw new UnsealError("Cloud KMS answered asymmetricDecrypt without a plaintext.");
-  return Buffer.from(body.plaintext, "base64");
-}
-function openColumn(rowKey, column) {
-  if (rowKey.length !== 32)
-    throw new UnsealError(`a row key is 32 bytes, got ${rowKey.length}`);
-  if (column.length < HEADER_BYTES + TAG_BYTES)
-    throw new UnsealError("ciphertext is too short to be a sealed column");
-  if (column[0] !== FORMAT_VERSION)
-    throw new UnsealError(`ciphertext format ${column[0]} is not one this tool reads`);
-  const decipher = createDecipheriv("aes-256-gcm", rowKey, column.subarray(1, HEADER_BYTES), { authTagLength: TAG_BYTES });
-  decipher.setAAD(column.subarray(0, 1));
-  decipher.setAuthTag(column.subarray(column.length - TAG_BYTES));
-  try {
-    return Buffer.concat([decipher.update(column.subarray(HEADER_BYTES, column.length - TAG_BYTES)), decipher.final()]);
-  } catch {
-    throw new UnsealError("ciphertext did not authenticate under this key");
-  }
-}
-async function openCards(rows, researchKeyName, accessToken, fetchImpl = fetch) {
-  const opened = [];
-  for (const row of rows) {
-    const versionName = keyVersionName(researchKeyName, row.key_version);
-    let rowKey = null;
-    try {
-      rowKey = await asymmetricDecrypt(versionName, Buffer.from(row.sealed_key, "base64"), accessToken, fetchImpl);
-      const card = JSON.parse(openColumn(rowKey, Buffer.from(row.card_ct, "base64")).toString("utf8"));
-      const answer = openColumn(rowKey, Buffer.from(row.answer_ct, "base64")).toString("utf8");
-      opened.push({
-        id: row.id,
-        tenant_id: row.tenant_id,
-        member_id: row.member_id,
-        device_id: row.device_id,
-        purpose: row.purpose,
-        model: row.model,
-        created_at: row.created_at,
-        key_version: row.key_version,
-        card,
-        answer
-      });
-    } catch (err) {
-      throw new UnsealError(`card ${row.id} did not unseal under ${versionName}: ${err instanceof Error ? err.message : String(err)}`);
-    } finally {
-      rowKey?.fill(0);
-    }
-  }
-  return opened;
-}
-function googleAccessToken(env, platform) {
-  const given = env["GOOGLE_OAUTH_ACCESS_TOKEN"]?.trim();
-  if (given !== undefined && given !== "")
-    return given;
-  const run2 = spawnSync("gcloud", ["auth", "print-access-token"], {
-    encoding: "utf8",
-    shell: platform === "win32",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const token = typeof run2.stdout === "string" ? run2.stdout.trim() : "";
-  if (run2.error === undefined && run2.status === 0 && token !== "")
-    return token;
-  throw new UnsealError("no Google access token: set GOOGLE_OAUTH_ACCESS_TOKEN, or install the gcloud CLI and run " + "`gcloud auth login` as yourself. The unseal runs as YOU, never as a service account.");
-}
-
 // tools/admin/src/demo.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 function readScenario(path) {
   let raw;
   try {
@@ -7709,21 +8193,88 @@ ${parsed.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message
   }
   return parsed.data;
 }
+var isDirectory = (path) => {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+function readScenarios(path) {
+  const files = isDirectory(path) ? readdirSync(path).filter((name) => name.endsWith(".json")).sort().map((name) => join2(path, name)) : [path];
+  if (files.length === 0)
+    throw new AdminUsageError(`${path} holds no scenario file`);
+  return files.map((file) => ({ path: file, scenario: readScenario(file) }));
+}
 function validateScenario(argv) {
   const [path, ...rest] = argv;
   if (path === undefined || path.startsWith("--") || rest.some((arg) => arg !== "--json"))
-    throw new AdminUsageError("demo validate takes one scenario file, and --json");
-  const s = readScenario(path);
-  const facts = {
+    throw new AdminUsageError("demo validate takes one scenario file or directory, and --json");
+  const all = readScenarios(path).map(({ scenario: s }) => ({
     name: s.name,
+    weekday: s.weekday ?? null,
     recordings: s.recordings.length,
     intervals: s.recordings.reduce((n, r) => n + r.intervals.length, 0),
     entries: s.entries.length,
+    released: s.entries.filter((e) => e.released === true).length,
     replay: replayGap(s) ?? "yes"
-  };
+  }));
   if (rest.includes("--json"))
-    return { code: 0, lines: [JSON.stringify({ valid: true, ...facts }, null, 2)] };
-  return { code: 0, lines: [`valid         ${facts.name}`, `recordings    ${facts.recordings}, ${facts.intervals} intervals, ${facts.entries} entries`, `replay        ${facts.replay}`] };
+    return { code: 0, lines: [JSON.stringify(all.length === 1 ? { valid: true, ...all[0] } : { valid: true, scenarios: all }, null, 2)] };
+  return {
+    code: 0,
+    lines: all.flatMap((facts) => [
+      `valid         ${facts.name}${facts.weekday === null ? "" : `  weekday ${facts.weekday}`}`,
+      `recordings    ${facts.recordings}, ${facts.intervals} intervals, ${facts.entries} entries${facts.released === 0 ? "" : `, ${facts.released} released`}`,
+      `replay        ${facts.replay}`
+    ])
+  };
+}
+function membersOf(run2) {
+  const value = run2.flags.values.get("members");
+  if (value === undefined)
+    return [];
+  const emails = value.split(",").map((one) => one.trim()).filter((one) => one !== "");
+  const bad = emails.find((one) => !/^[^@\s]+@[^@\s]+$/.test(one));
+  if (bad !== undefined)
+    throw new AdminUsageError(`--members is a comma-separated list of addresses, got ${JSON.stringify(bad)}`);
+  return emails;
+}
+function daysOf(run2) {
+  const value = run2.flags.values.get("days");
+  if (value === undefined)
+    return;
+  const days = Number(value);
+  if (!Number.isInteger(days) || days < 1 || days > DEMO_MAX_DAYS)
+    throw new AdminUsageError(`--days is a whole number from 1 to ${DEMO_MAX_DAYS}, got ${JSON.stringify(value)}`);
+  return days;
+}
+function seedBody(run2) {
+  const path = required(run2.flags, "scenario", "the scenario file to seed, or a directory of week files with --anchor or --days");
+  const members = membersOf(run2);
+  const days = daysOf(run2);
+  const anchor = run2.flags.values.has("anchor") ? dayOf2(run2.flags, "anchor", "the last day of the range") : undefined;
+  const range = days !== undefined || anchor !== undefined;
+  if (!range) {
+    if (isDirectory(path))
+      throw new AdminUsageError("a directory of scenarios seeds a range: give --days or --anchor, or name one file");
+    const scenario = readScenario(path);
+    const day2 = run2.flags.values.has("day") ? dayOf2(run2.flags, "day", "the day to seed on") : undefined;
+    return { body: { scenario, ...day2 === undefined ? {} : { day: day2 }, replay: switched(run2.flags, "replay"), generate: switched(run2.flags, "generate"), members }, names: scenario.name };
+  }
+  if (run2.flags.values.has("day"))
+    throw new AdminUsageError("--day seeds one day; --anchor and --days seed a range: give one form");
+  if (switched(run2.flags, "generate"))
+    throw new AdminUsageError("a range writes its days' entries itself: drop --generate");
+  const read = readScenarios(path).map((one) => one.scenario);
+  const week = read.filter((one) => one.weekday !== undefined);
+  const scenarios = isDirectory(path) ? week : read;
+  if (scenarios.length === 0)
+    throw new AdminUsageError(`${path} holds no scenario that names its weekday`);
+  return {
+    body: { scenarios, ...anchor === undefined ? {} : { anchor }, ...days === undefined ? {} : { days }, replay: true, members },
+    names: scenarios.map((one) => one.name).join(", ")
+  };
 }
 async function runDemo(run2, subcommand) {
   if (run2.environment.name === "production")
@@ -7744,24 +8295,31 @@ async function runDemo(run2, subcommand) {
     ]);
   }
   if (subcommand === "seed") {
-    const scenario = readScenario(required(run2.flags, "scenario", "the scenario file to seed"));
-    const day = run2.flags.values.has("day") ? dayOf2(run2.flags, "day", "the day to seed on") : undefined;
-    const body = { scenario, ...day === undefined ? {} : { day }, replay: switched(run2.flags, "replay"), generate: switched(run2.flags, "generate") };
+    const { body, names } = seedBody(run2);
     const done = AdminDemoSeedResultSchema.parse(expectOk(await call(run2.api, "POST", path("/demo/seed"), body)));
+    const invited = (done.members ?? []).map((one) => `member        ${one.email}  ${one.outcome === "invited" ? "invited" : one.outcome === "member" ? "already a member, skipped" : "already invited, skipped"}`);
+    if (done.range !== undefined) {
+      return render(run2, done, [
+        `seeded        ${done.range.length} working days into ${done.member_id}`,
+        ...done.range.map((one) => `${one.day}    ${one.scenario}: ${one.entries.written} drafts written, ${one.contexts.stored} contexts stored` + `${one.replaced ? ", replaced an older seed" : ""}${one.entries.released_owed === 0 ? "" : `, ${one.entries.released_owed} to release`}`),
+        ...invited
+      ]);
+    }
     return render(run2, done, [
-      `seeded        ${scenario.name} on ${done.day}, ${done.mode}, into ${done.member_id}`,
+      `seeded        ${names} on ${done.day}, ${done.mode}, into ${done.member_id}`,
       `contexts      ${done.contexts.stored} stored, ${done.contexts.repeated} already there, over ${done.recordings} recordings`,
       `created       ${done.created.clients} clients, ${done.created.matters} matters`,
-      done.generate_run === null ? "Generate the day from the app, or run demo reset --generate." : `generate      ${done.generate_run}`
+      done.generate_run === null ? "Generate the day from the app, or run demo reset --generate." : `generate      ${done.generate_run}`,
+      ...invited
     ]);
   }
   if (subcommand === "reset" || subcommand === "remove") {
-    const day = dayOf2(run2.flags, "day", `the seeded day to ${subcommand}`);
+    const day2 = dayOf2(run2.flags, "day", `the seeded day to ${subcommand}`);
     if (subcommand === "remove") {
-      const done2 = AdminDemoRemoveResultSchema.parse(expectOk(await call(run2.api, "POST", path("/demo/remove"), { day })));
+      const done2 = AdminDemoRemoveResultSchema.parse(expectOk(await call(run2.api, "POST", path("/demo/remove"), { day: day2 })));
       return render(run2, done2, [`removed       ${done2.day}: ${done2.recordings_deleted} recordings, ${done2.entries_deleted} entries`]);
     }
-    const done = AdminDemoResetResultSchema.parse(expectOk(await call(run2.api, "POST", path("/demo/reset"), { day, generate: switched(run2.flags, "generate") })));
+    const done = AdminDemoResetResultSchema.parse(expectOk(await call(run2.api, "POST", path("/demo/reset"), { day: day2, generate: switched(run2.flags, "generate") })));
     return render(run2, done, [
       `reset         ${done.day}: ${done.runs_deleted} Generate runs, ${done.drafts_deleted} drafts deleted, ${done.released_kept} released kept`,
       ...done.generate_run === null ? [] : [`generate      ${done.generate_run}`]
@@ -7770,9 +8328,141 @@ async function runDemo(run2, subcommand) {
   throw new AdminUsageError(`unknown command: demo ${subcommand ?? ""}`.trim());
 }
 
+// tools/admin/src/telemetry.ts
+var POSTHOG_API = "https://eu.posthog.com";
+var ALERT_PREFIX = "sixminute alert:";
+function wantedAlerts() {
+  return EVENT_KEYS.filter((key) => CATALOGUE[key].owner === "cloud" && CATALOGUE[key].expect === "daily").map((key) => ({
+    event: CATALOGUE[key].name,
+    name: `${ALERT_PREFIX} ${CATALOGUE[key].name}`,
+    lower: 1
+  }));
+}
+
+class PosthogError extends Error {
+}
+function client(io, project) {
+  const call2 = async (method, path, body) => {
+    const response = await io.fetchImpl(`${POSTHOG_API}/api/projects/${encodeURIComponent(project)}${path}`, {
+      method,
+      headers: { Authorization: `Bearer ${io.posthogKey}`, "Content-Type": "application/json", Accept: "application/json" },
+      ...body === undefined ? {} : { body: JSON.stringify(body) }
+    });
+    const text = await response.text();
+    if (!response.ok)
+      throw new PosthogError(`PostHog answered ${response.status} to ${method} ${path}`);
+    return text === "" ? null : JSON.parse(text);
+  };
+  return {
+    call: call2,
+    async list(path) {
+      const page = await call2("GET", path);
+      return page?.results ?? [];
+    }
+  };
+}
+var insightOf = (wanted) => ({
+  name: wanted.name,
+  description: `Counts ${wanted.event} a day for its alert (sixminute-admin telemetry alerts).`,
+  query: {
+    kind: "InsightVizNode",
+    source: { kind: "TrendsQuery", series: [{ kind: "EventsNode", event: wanted.event, math: "total" }], interval: "day", dateRange: { date_from: "-14d" }, filterTestAccounts: true }
+  }
+});
+var alertOf = (wanted, insight) => ({
+  name: wanted.name,
+  insight,
+  condition: { type: "absolute_value" },
+  threshold: { configuration: { type: "absolute", bounds: { lower: wanted.lower } } },
+  config: { type: "TrendsAlertConfig", series_index: 0 },
+  calculation_interval: "daily",
+  skip_weekend: true,
+  enabled: true
+});
+var insightIdOf = (alert) => typeof alert.insight === "number" ? alert.insight : alert.insight.id;
+async function telemetryAlerts(io, project, yes) {
+  const posthog = client(io, project);
+  const insights = (await posthog.list(`/insights/?search=${encodeURIComponent(ALERT_PREFIX)}&limit=500`)).filter((one) => one.name?.startsWith(ALERT_PREFIX));
+  const alerts = (await posthog.list("/alerts/?limit=500")).filter((one) => one.name.startsWith(ALERT_PREFIX));
+  const plan = [];
+  for (const wanted of wantedAlerts()) {
+    const insight = insights.find((one) => one.name === wanted.name);
+    const alert = alerts.find((one) => one.name === wanted.name);
+    if (insight === undefined) {
+      plan.push({
+        change: `create  ${wanted.event}: an insight and its alert below ${wanted.lower} a weekday`,
+        write: async () => {
+          const made = await posthog.call("POST", "/insights/", insightOf(wanted));
+          await posthog.call("POST", "/alerts/", alertOf(wanted, made.id));
+        }
+      });
+    } else if (alert === undefined) {
+      plan.push({ change: `create  ${wanted.event}: its alert below ${wanted.lower} a weekday`, write: async () => void await posthog.call("POST", "/alerts/", alertOf(wanted, insight.id)) });
+    } else if (alert.threshold?.configuration?.bounds?.lower !== wanted.lower || insightIdOf(alert) !== insight.id) {
+      plan.push({
+        change: `update  ${wanted.event}: the alert's floor to ${wanted.lower} a weekday`,
+        write: async () => void await posthog.call("PATCH", `/alerts/${encodeURIComponent(alert.id)}/`, alertOf(wanted, insight.id))
+      });
+    }
+  }
+  if (yes)
+    for (const step of plan)
+      await step.write();
+  return { changes: plan.map((step) => step.change), written: yes && plan.length > 0 };
+}
+async function telemetryCheck(io, project, days) {
+  const posthog = client(io, project);
+  const answer = await posthog.call("POST", "/query/", {
+    query: { kind: "HogQLQuery", query: `select event, count() from events where timestamp > now() - interval ${days} day group by event` }
+  });
+  const received = new Set((answer?.results ?? []).map(([event]) => event));
+  const names = new Set(EVENT_KEYS.map((key) => CATALOGUE[key].name));
+  const own = (event) => event.startsWith("$") && !names.has(event);
+  return {
+    missing: [...names].filter((name) => !received.has(name)).sort(),
+    unknown: [...received].filter((event) => !names.has(event) && !own(event)).sort()
+  };
+}
+async function runTelemetry(subcommand, values, switches, json, io) {
+  const project = values.get("project")?.trim();
+  if (subcommand !== "alerts" && subcommand !== "check")
+    return { code: 2, lines: ["usage: sixminute-admin telemetry alerts|check --project <id> [--yes] [--days 7] [--json]"] };
+  if (project === undefined || project === "")
+    return { code: 2, lines: ["--project is required: the PostHog project the alerts live in"] };
+  if (io.posthogKey === null || io.posthogKey === "")
+    return { code: 2, lines: ["SIXMINUTE_POSTHOG_KEY is not set: a PostHog user API key with insight and alert write access"] };
+  try {
+    if (subcommand === "alerts") {
+      const { changes, written } = await telemetryAlerts(io, project, switches.has("yes"));
+      if (json)
+        return { code: 0, lines: [JSON.stringify({ project, changes, written }, null, 2)] };
+      if (changes.length === 0)
+        return { code: 0, lines: [`project ${project}: every daily cloud event has its alert; nothing to change`] };
+      return { code: 0, lines: [`project ${project}:`, ...changes.map((line) => `  ${line}`), written ? "written." : "nothing written: run again with --yes to write these."] };
+    }
+    const days = Number(values.get("days") ?? "7");
+    if (!Number.isInteger(days) || days < 1 || days > 90)
+      return { code: 2, lines: ["--days is a whole number of days from 1 to 90"] };
+    const { missing, unknown } = await telemetryCheck(io, project, days);
+    if (json)
+      return { code: 0, lines: [JSON.stringify({ project, days, missing, unknown }, null, 2)] };
+    return {
+      code: missing.length === 0 && unknown.length === 0 ? 0 : 1,
+      lines: [
+        `project ${project}, the last ${days} days:`,
+        `  not received (${missing.length}): ${missing.join(", ") || "none"}`,
+        `  not in the catalogue (${unknown.length}): ${unknown.join(", ") || "none"}`
+      ]
+    };
+  } catch (err) {
+    if (err instanceof PosthogError)
+      return { code: 2, lines: [err.message] };
+    throw err;
+  }
+}
+
 // tools/admin/src/run.ts
 var ROLE_SLUGS = FIRM_ROLE_SLUGS;
-var CONFIDENTIAL_EXIT_CODE = 3;
 var REFUSED_EXIT_CODE = 2;
 var ADMIN_USAGE = `sixminute-admin, the operator's firm tool (D-73)
 
@@ -7820,20 +8510,13 @@ is required; without one every command answers 403.
 
   sixminute-admin tier set --env <env> --tenant tenant_... --tier <standard|confidential> [--json]
         Sets the firm's security tier, which no route lets a customer change.
-        "confidential" stores no research card for that firm and keeps its
-        judged copies out of every export.
-        DESTRUCTIVE: setting "confidential" also DELETES every research card
-        already stored for that firm AND the judged text of every interval
-        it still holds, and prints how many of each. Those rows are
+        DESTRUCTIVE: setting "confidential" also DELETES the cards the firm
+        still holds from the retired export, and prints how many. They are
         gone for good, there is no backup and nothing can bring them back.
-        Nothing else is deleted: the audit rows of past exports stay, and so
-        do the firm's own entries, their narratives and their judged copies.
-        Setting "standard" deletes nothing. If either purge fails after the
+        The firm's entries, their narratives and their judged copies stay.
+        Setting "standard" deletes nothing. If the deletion fails after the
         tier has changed the command says so and exits non-zero; run it
-        again, which purges again.
-        It then LISTS this firm's past research exports, which are decrypted
-        copies on operator machines that no command can delete: find those
-        files and delete them by hand.
+        again, which deletes again.
 
   sixminute-admin tenant internal set --env <env> --tenant tenant_... --internal <true|false> [--json]
         Marks a tenant as Unison's own, or not. Only an internal tenant can be
@@ -7846,36 +8529,14 @@ is required; without one every command answers 403.
         Read it before a contract migration or before raising the floor
         (docs/plans/six-minute/release-cycle/runbook.md).
 
-  sixminute-admin raw-archive allow --env <env> --tenant tenant_... [--json]
-  sixminute-admin raw-archive revoke --env <env> --tenant tenant_... [--json]
+  sixminute-admin raw-archive allow --env staging --tenant tenant_... [--json]
+  sixminute-admin raw-archive revoke --env staging --tenant tenant_... [--json]
         Lets a person on the tenant switch on the raw capture archive on their
         own device (a development copy of a whole day, kept on that device
         and never uploaded), or withdraws it; a device that had it on switches
         itself off at its next policy read. allow refuses a tenant that is not
-        internal and exits 2, and the database refuses it again.
-
-  sixminute-admin research-export allow --env <env> --tenant tenant_... [--json]
-  sixminute-admin research-export revoke --env <env> --tenant tenant_... [--json]
-        Records the firm's WRITTEN instruction to keep research data for it, or
-        withdraws it (policy research_export, false until set). Run allow only
-        on that written instruction. Without it no research card is stored for
-        the firm, from the next completion; revoking deletes no card already
-        stored, which the 30-day purge removes.
-
-  sixminute-admin research export --env <env> --tenant tenant_... --from YYYY-MM-DD --to YYYY-MM-DD --out <dir> [--json]
-        Unseals one firm's research cards over a day range onto this machine
-        and writes two jsonl files in --out: a new folder is created 0700, and
-        an existing one is refused unless it is yours and 0700. The cards,
-        and one line per entry the engine judged in that range with the entry
-        as it now stands beside the frozen copy. The audit row naming the
-        operator, the firm and the range is written BEFORE anything is
-        unsealed, in the same transaction as the tier check and holding the
-        firm's row, so this command and "tier set confidential" cannot
-        interleave. Half-open at the top: --to is not included. A confidential
-        firm exports nothing, no file is written and the command exits
-        non-zero.
-        The unseal runs as you, with your own Google sign-in (gcloud auth
-        login); only the people granted the research key can open a card.
+        internal and exits 2, and the database refuses it again. Staging (or
+        local) only: both refuse production, which has no raw archive.
 
   sixminute-admin retention set --env <env> --tenant tenant_... --days <1-365> [--json]
         Sets how many days the cloud keeps the firm's interval contexts after
@@ -7896,11 +8557,15 @@ is required; without one every command answers 403.
         drafts under its own key, and gives intervals stored before the context
         store an age, a bounded pass at a time until nothing is left.
 
-  sixminute-admin research contexts --env <env> --tenant tenant_... --from YYYY-MM-DD --to YYYY-MM-DD --out <dir> [--json]
-        A firm's research data (R10): its interval contexts and the step ledger
-        over a day range, written as two jsonl files in --out (a new folder
-        0700, as research export). Refused unless the firm instructed it in
-        writing (research-export allow); the audit row is written first.
+  sixminute-admin scrub plaintext --env <env> --tenant tenant_... [--json]
+        Starts the plaintext scrub of the firm's old rows, one job per active
+        member, and prints how many it started: each job clears the plaintext
+        twin of a sealed value (an entry's judged copy, an old interval's
+        summary and label) only where the sealed value opens to the same
+        content, so nothing is lost. Run backfill sealed first. Refused, exit
+        2, while a release older than the API's may still be served, because
+        an older revision still reads the plaintext. Safe to run again: a
+        member's job already started today is not started twice.
 
   sixminute-admin entries purge --env <env> --tenant tenant_... --author member_... (--demo | --unmatched | both) [--dry-run] [--yes] [--json]
         Removes entry rows from one firm. A person may only soft-delete
@@ -7908,7 +8573,8 @@ is required; without one every command answers 403.
         from the table: this is the operator's hand, and it
         runs under D-162's licence, which lasts only while the owner is the
         product's one user.
-        --demo      the rows tools/demo-seed minted (id starts entry_demo-).
+        --demo      the rows the retired demo seeder minted (id starts entry_demo-).
+                    A released one is never deleted: it is listed as kept.
         --unmatched engine-written rows charged to no matter: not the demo
                     prefix, a judged copy (as_judged set, so never a
                     hand-made entry), and matter_id null. That is the residue the
@@ -7929,12 +8595,22 @@ is required; without one every command answers 403.
         The flag, the caps in force, and your own seeded days, live or replay.
   sixminute-admin demo validate tools/demo-scenarios/example-small.json [--json]
         Checks a scenario file offline: its shape, its times and every reference.
-  sixminute-admin demo seed --env staging --tenant tenant_... --scenario <file> [--day YYYY-MM-DD] [--replay] [--generate] [--json]
+  sixminute-admin demo seed --env staging --tenant tenant_... --scenario <file> [--day YYYY-MM-DD] [--replay] [--generate] [--members a@x,b@y] [--json]
         Seeds the scenario into YOUR OWN account of the firm (accept an
         invitation with the same address first), on its own Scenario device.
         Without --day, the most recent day it lies wholly in the past on, with
         nothing captured. --replay makes the day's Generate answer from the
         scenario with no model; --generate starts that Generate.
+  sixminute-admin demo seed --env staging --tenant tenant_... --scenario <dir|file> [--anchor YYYY-MM-DD] [--days N] [--members a@x,b@y] [--json]
+        Seeds a range of working days instead: the last --days working days
+        (5 unless named, at most 31) up to and including --anchor (today
+        unless named), Saturdays and Sundays skipped. Each day takes the
+        scenario of the directory whose weekday is its own, or the one file
+        named. A range always replays and writes its days' entries itself, so
+        --day and --generate are refused with it; seeding a day again
+        replaces it.
+        --members invites those addresses to the firm as administrators;
+        one already a member or already invited is skipped.
   sixminute-admin demo reset --env staging --tenant tenant_... --day YYYY-MM-DD [--generate] [--json]
         Drops the seeded day's Generate runs and drafts, so Generate runs
         again over the same activity. Released entries stay.
@@ -8224,6 +8900,10 @@ async function runAdmin(argv, deps) {
   }
   if (group === "demo" && subcommand === "validate")
     return validateScenario(rest);
+  if (group === "telemetry") {
+    const parsed = parseFlags(rest, 2);
+    return runTelemetry(subcommand, parsed.values, parsed.flags, parsed.json, { fetchImpl: deps.fetchImpl, posthogKey: deps.posthogKey ?? null });
+  }
   const oneWord = ["login", "logout", "whoami", "doctor", "versions", "audit"].includes(group);
   const vocabulary2 = group === "attribute" || group === "matter" && subcommand === "sets";
   const threeDeep = group === "tenant" && subcommand === "internal";
@@ -8299,16 +8979,12 @@ async function runAdmin(argv, deps) {
     return runTierSet(run2);
   if (group === "raw-archive")
     return runRawArchive(run2, subcommand);
-  if (group === "research-export")
-    return runResearchExportFlag(run2, subcommand);
-  if (group === "research" && subcommand === "export")
-    return runResearchExport(run2);
-  if (group === "research" && subcommand === "contexts")
-    return runResearchContexts(run2);
   if (group === "retention" && subcommand === "set")
     return runRetentionSet(run2);
   if (group === "backfill" && subcommand === "sealed")
     return runBackfillSealed(run2);
+  if (group === "scrub" && subcommand === "plaintext")
+    return runScrubPlaintext(run2);
   if (group === "pipeline" && subcommand === "shadow-report")
     return runShadowReport(run2);
   if (group === "entries" && subcommand === "purge")
@@ -8431,35 +9107,16 @@ async function runTierSet(run2) {
   const done = AdminTierResultSchema.parse(expectOk(await call(run2.api, "PUT", tenantPath(tenantId, "/tier"), { tier })));
   const tenant = { id: done.tenant.id, name: done.tenant.name, security_tier: done.security_tier };
   if (done.security_tier !== "confidential") {
-    return render(run2, { tenant }, [
-      `tenant        ${tenant.id}  ${tenant.name}`,
-      `security_tier ${tenant.security_tier}`,
-      "",
-      "Research cards are stored for this firm for 30 days, sealed under the research key, only while it has",
-      "instructed it in writing (research-export allow)."
-    ]);
+    return render(run2, { tenant }, [`tenant        ${tenant.id}  ${tenant.name}`, `security_tier ${tenant.security_tier}`]);
   }
   const deleted = done.cards_deleted ?? 0;
-  const judgedText = done.judged_text_purged ?? 0;
-  return render(run2, {
-    tenant,
-    research_cards_deleted: deleted,
-    judged_text_purged: judgedText,
-    ...done.past_exports === null ? { research_exports_error: done.past_exports_error } : { research_exports: done.past_exports }
-  }, [
+  return render(run2, { tenant, research_cards_deleted: deleted }, [
     `tenant        ${tenant.id}  ${tenant.name}`,
     `security_tier ${tenant.security_tier}`,
     `cards deleted ${deleted}`,
-    `judged text   ${judgedText}`,
-    "",
-    `The ${deleted} research cards this firm had already stored are deleted, and so is the judged text of`,
-    `${judgedText} of its intervals. That cannot be undone: the cards were sealed to a key nothing keeps a copy of,`,
-    "the text is the only copy of what a narrative was written from, and there is no backup of either.",
-    "The entries, their narratives and hours, the judged copies and the intervals' evidence are untouched.",
-    "No research card and no judged text is stored for this firm from the next completion, and its",
-    "judged copies stay out of every export.",
     "",
-    ...exportLines(done.past_exports, done.past_exports_error)
+    `The ${deleted} cards this firm still held are deleted. That cannot be undone: there is no backup.`,
+    "The entries, their narratives and hours, the judged copies and the intervals' evidence are untouched."
   ]);
 }
 async function runTenantInternalSet(run2) {
@@ -8478,6 +9135,9 @@ async function runRawArchive(run2, subcommand) {
   if (subcommand !== "allow" && subcommand !== "revoke") {
     throw new AdminUsageError(`unknown command: raw-archive ${subcommand ?? ""}`.trim());
   }
+  if (run2.environment.name === "production") {
+    throw new AdminUsageError("raw-archive runs on staging (or local) only: production has no raw archive");
+  }
   const allow = subcommand === "allow";
   const tenantId = required(run2.flags, "tenant", "which tenant the raw archive is being set for");
   const { tenant } = AdminTenantFlagsSchema.parse(expectOk(await call(run2.api, "PUT", tenantPath(tenantId, "/raw-archive"), { allowed: allow })));
@@ -8488,23 +9148,9 @@ async function runRawArchive(run2, subcommand) {
     allow ? "A person on this tenant can now switch on the raw capture archive on their own device, in Capture settings." : "Every device on this tenant switches its raw archive off at its next policy read."
   ]);
 }
-async function runResearchExportFlag(run2, subcommand) {
-  if (subcommand !== "allow" && subcommand !== "revoke") {
-    throw new AdminUsageError(`unknown command: research-export ${subcommand ?? ""}`.trim());
-  }
-  const allow = subcommand === "allow";
-  const tenantId = required(run2.flags, "tenant", "which firm's written instruction is being recorded");
-  const { tenant } = AdminResearchExportFlagSchema.parse(expectOk(await call(run2.api, "PUT", tenantPath(tenantId, "/research-export"), { research_export: allow })));
-  return render(run2, { tenant }, [
-    `tenant          ${tenant.id}  ${tenant.name}`,
-    `research_export ${tenant.research_export}`,
-    "",
-    allow ? "Research cards are stored for this firm from its next completion, for 30 days, sealed under the research key." : "No research card is stored for this firm from its next completion. Cards already stored stay until the 30-day purge."
-  ]);
-}
 async function runShadowReport(run2) {
-  const day = required(run2.flags, "day", "which local day, YYYY-MM-DD");
-  const found = ShadowReportSchema.parse(expectOk(await call(run2.api, "GET", `/v1/admin/pipeline/shadow-report?day=${encodeURIComponent(day)}`)));
+  const day2 = required(run2.flags, "day", "which local day, YYYY-MM-DD");
+  const found = ShadowReportSchema.parse(expectOk(await call(run2.api, "GET", `/v1/admin/pipeline/shadow-report?day=${encodeURIComponent(day2)}`)));
   const pct = (part, whole) => whole === 0 ? "-" : `${Math.round(100 * part / whole)}%`;
   return render(run2, found, [
     `day  ${found.day}`,
@@ -8541,33 +9187,13 @@ async function runBackfillSealed(run2) {
     `aged          ${total.intervals_aged} interval(s)`
   ]);
 }
-async function runResearchContexts(run2) {
-  const { flags } = run2;
-  const tenantId = required(flags, "tenant", "an export is one firm's contexts and steps");
-  const from = dayOf2(flags, "from", "the first day of the range");
-  const to = dayOf2(flags, "to", "the day the range stops before; --to is not included");
-  if (from >= to)
-    throw new AdminUsageError("--from must be before --to; the range is half-open and an empty one exports nothing.");
-  const out = resolve(required(flags, "out", "where to write the files; an export lives on this machine and nowhere else"));
-  const claimed = claimExportDirectory(out);
-  let done;
-  try {
-    done = ResearchContextExportSchema.parse(expectOk(await call(run2.api, "POST", tenantPath(tenantId, "/research-exports/contexts"), { from, to })));
-  } catch (err) {
-    releaseExportDirectory(out, claimed);
-    throw err;
-  }
-  const contextsPath = join2(out, `contexts-${tenantId}-${from}-${to}.jsonl`);
-  const stepsPath = join2(out, `steps-${tenantId}-${from}-${to}.jsonl`);
-  writePrivateFile(contextsPath, jsonLines(done.contexts));
-  writePrivateFile(stepsPath, jsonLines(done.steps));
-  return render(run2, { tenant_id: tenantId, from: done.from, to: done.to, contexts: done.contexts.length, steps: done.steps.length, files: [contextsPath, stepsPath], operator: done.operator }, [
-    `tenant        ${tenantId}  ${done.tenant_name}`,
-    `range         ${from} to ${to} (--to not included)`,
-    `contexts      ${done.contexts.length}`,
-    `steps         ${done.steps.length}`,
-    `files         ${contextsPath}`,
-    `              ${stepsPath}`
+var ScrubStartedSchema = exports_external.object({ tenant: exports_external.string(), started: exports_external.number().int().nonnegative() });
+async function runScrubPlaintext(run2) {
+  const tenantId = required(run2.flags, "tenant", "whose old rows to scrub");
+  const done = ScrubStartedSchema.parse(expectOk(await call(run2.api, "POST", tenantPath(tenantId, "/scrub-plaintext"))));
+  return render(run2, done, [
+    `tenant        ${done.tenant}`,
+    `started       ${done.started} scrub job(s), one per active member`
   ]);
 }
 async function runVersions(run2) {
@@ -8584,7 +9210,7 @@ async function runEntriesPurge(run2) {
   const demo2 = switched(flags, "demo");
   const unmatched = switched(flags, "unmatched");
   if (!demo2 && !unmatched) {
-    throw new AdminUsageError("name what to remove: --demo (the rows tools/demo-seed minted) or --unmatched " + "(engine-written rows charged to no matter), or both. This command never guesses a selector.");
+    throw new AdminUsageError("name what to remove: --demo (the rows the retired demo seeder minted) or --unmatched " + "(engine-written rows charged to no matter), or both. This command never guesses a selector.");
   }
   const author = optional(flags, "author");
   if (author === undefined) {
@@ -8602,10 +9228,11 @@ async function runEntriesPurge(run2) {
     ...demo2 ? purgeSection("demo entries (entry_demo-)", done.rows.demo) : [],
     ...demo2 && unmatched ? [""] : [],
     ...unmatched ? purgeSection("unmatched captured entries (no matter, engine-written)", done.rows.unmatched) : [],
+    ...done.kept.demo.length > 0 ? ["", ...purgeSection("kept, released demo entries (a released row is never deleted)", done.kept.demo)] : [],
     ""
   ];
   if (dryRun) {
-    return render(run2, { tenant: tenantId, author, user: done.user, dry_run: true, would_delete: total, rows: done.rows }, [...listing, `--dry-run: ${total} row(s) would be deleted. Nothing was written.`]);
+    return render(run2, { tenant: tenantId, author, user: done.user, dry_run: true, would_delete: total, rows: done.rows, kept: done.kept }, [...listing, `--dry-run: ${total} row(s) would be deleted. Nothing was written.`]);
   }
   if (!yes) {
     return {
@@ -8618,84 +9245,10 @@ async function runEntriesPurge(run2) {
     };
   }
   const deleted = done.deleted ?? { demo: 0, unmatched: 0, total: 0 };
-  return render(run2, { tenant: tenantId, author, user: done.user, deleted }, [
+  return render(run2, { tenant: tenantId, author, user: done.user, deleted, kept: done.kept }, [
     ...listing,
     `deleted       ${deleted.total} row(s): ${deleted.demo} demo, ${deleted.unmatched} unmatched captured.`,
-    "That cannot be undone. Re-seed the demo week with tools/demo-seed if the demo rows were wanted."
-  ]);
-}
-async function runResearchExport(run2) {
-  const { flags, deps } = run2;
-  const tenantId = required(flags, "tenant", "an export is one firm's cards and judged entries");
-  const from = dayOf2(flags, "from", "the first day of the range");
-  const to = dayOf2(flags, "to", "the day the range stops before; --to is not included");
-  if (from >= to)
-    throw new AdminUsageError("--from must be before --to; the range is half-open and an empty one exports nothing.");
-  const out = resolve(required(flags, "out", "where to write the files; an export lives on this machine and nowhere else"));
-  let googleToken;
-  try {
-    googleToken = deps.googleAccessToken();
-  } catch (err) {
-    throw new AdminUsageError(err instanceof Error ? err.message : String(err));
-  }
-  const claimed = claimExportDirectory(out);
-  let done;
-  try {
-    done = ResearchExportResultSchema.parse(expectOk(await call(run2.api, "POST", tenantPath(tenantId, "/research-exports"), { from, to })));
-  } catch (err) {
-    releaseExportDirectory(out, claimed);
-    throw err;
-  }
-  const range = `range         ${from} to ${to} (--to not included)`;
-  if (done.tier === "confidential") {
-    releaseExportDirectory(out, claimed);
-    return render(run2, { tenant_id: tenantId, from: done.from, to: done.to, rows: 0, files: [], operator: done.operator, security_tier: "confidential" }, [
-      `tenant        ${tenantId}  ${done.tenant_name}`,
-      "security_tier confidential",
-      range,
-      "",
-      "Nothing was exported and no file was written. This firm stores no research card, and its judged",
-      "copies are kept out of every export: that is what its agreement says, and it is not a range to widen.",
-      `The attempt is in the audit trail, naming ${done.operator}.`
-    ], CONFIDENTIAL_EXIT_CODE);
-  }
-  const cardsPath = join2(out, `research-${tenantId}-${from}-${to}.jsonl`);
-  const pairsPath = join2(out, `judged-${tenantId}-${from}-${to}.jsonl`);
-  const written = [];
-  try {
-    const cards = await openCards(done.sealed_cards, done.research_key_name, googleToken, deps.fetchImpl);
-    writePrivateFile(cardsPath, jsonLines(cards));
-    written.push(cardsPath);
-    writePrivateFile(pairsPath, jsonLines(done.judged_pairs));
-    written.push(pairsPath);
-  } catch (err) {
-    for (const path of written)
-      rmSync3(path, { force: true });
-    releaseExportDirectory(out, claimed);
-    if (err instanceof Error && err.name === "UnsealError")
-      throw new AdminUsageError(err.message);
-    throw err;
-  }
-  return render(run2, {
-    tenant_id: tenantId,
-    from: done.from,
-    to: done.to,
-    rows: done.rows,
-    cards: done.cards,
-    pairs: done.pairs,
-    files: [cardsPath, pairsPath],
-    operator: done.operator
-  }, [
-    `tenant        ${tenantId}  ${done.tenant_name}`,
-    range,
-    `cards         ${done.cards}`,
-    `judged pairs  ${done.pairs}`,
-    `files         ${cardsPath}`,
-    `              ${pairsPath}`,
-    `audit row     written before the unseal, naming ${done.operator}`,
-    "",
-    "The files hold screen material of a firm's day and the narratives it billed. They live on this",
-    "machine, they are not pseudonymous to anyone who knows the firm, and the audit row says you read them."
+    "That cannot be undone. Seed the demo again with demo seed if the demo rows were wanted."
   ]);
 }
 async function runAudit(run2) {
@@ -8818,7 +9371,7 @@ async function runVocabulary(run2, group, subcommand, action, positionals) {
     const merged = { ...await readMatterSets(firm, matterId), ...wanted };
     await firm("PATCH", `/matters/${enc(matterId)}`, { attribute_sets: merged });
     return done({ matter: matterId, attribute_sets: merged }, [
-      `matter         ${matterId}  ` + Object.entries(merged).map(([key, ids2]) => `${key}=${ids2 === null ? "inherit" : ids2.length === 0 ? "none" : ids2.join(",")}`).join("  ")
+      `matter         ${matterId}  ` + Object.entries(merged).map(([key, ids3]) => `${key}=${ids3 === null ? "inherit" : ids3.length === 0 ? "none" : ids3.join(",")}`).join("  ")
     ]);
   }
   throw new AdminUsageError(`unknown command: ${group} ${subcommand ?? ""}`.trim());
@@ -8880,10 +9433,10 @@ async function runClient(run2, subcommand) {
     const answer = await call(run2.api, "POST", tenantPath(tenant, "/clients"), body);
     if (answer.status !== 201)
       return refused(run2, answer, [actingHead(tenant, answer)]);
-    const client = ClientSchema.parse(answer.body);
-    return render(run2, { client }, [
+    const client2 = ClientSchema.parse(answer.body);
+    return render(run2, { client: client2 }, [
       actingHead(tenant, answer),
-      `client        ${client.id}  ${client.name}${client.external_ref === null ? "" : `  ref ${client.external_ref}`}`
+      `client        ${client2.id}  ${client2.name}${client2.external_ref === null ? "" : `  ref ${client2.external_ref}`}`
     ]);
   }
   if (subcommand === "list") {
@@ -8910,8 +9463,8 @@ async function runClient(run2, subcommand) {
     const answer = await call(run2.api, "PATCH", tenantPath(tenant, `/clients/${enc(id)}`), body);
     if (answer.status !== 200)
       return refused(run2, answer, [actingHead(tenant, answer)]);
-    const client = ClientSchema.parse(answer.body);
-    return render(run2, { client }, [actingHead(tenant, answer), clientLine(client)]);
+    const client2 = ClientSchema.parse(answer.body);
+    return render(run2, { client: client2 }, [actingHead(tenant, answer), clientLine(client2)]);
   }
   throw new AdminUsageError(`unknown command: client ${subcommand ?? ""}`.trim());
 }
@@ -8945,11 +9498,11 @@ async function runMatter(run2, subcommand) {
     ]);
   }
   if (subcommand === "list") {
-    const client = optional(flags, "client");
-    if (client !== undefined)
-      checkBody(MatterSchema.pick({ client_id: true }), { client_id: client });
+    const client2 = optional(flags, "client");
+    if (client2 !== undefined)
+      checkBody(MatterSchema.pick({ client_id: true }), { client_id: client2 });
     const { rows, head } = await pullAll(run2, tenant, "/matters", MatterSchema);
-    const ofClient = client === undefined ? rows : rows.filter((m) => m.client_id === client);
+    const ofClient = client2 === undefined ? rows : rows.filter((m) => m.client_id === client2);
     const matters = switched(flags, "all") ? ofClient : ofClient.filter((m) => m.active);
     return render(run2, { matters }, [
       head,
@@ -8998,7 +9551,7 @@ async function runMattersImport(run2) {
     return refused(run2, answer, [actingHead(tenant, answer)]);
   const report = ImportReportSchema.parse(answer.body);
   const line = (n) => `${n.created} created, ${n.updated} updated, ${n.unchanged} unchanged`;
-  const matters = parsed.clients.reduce((n, client) => n + client.matters.length, 0);
+  const matters = parsed.clients.reduce((n, client2) => n + client2.matters.length, 0);
   return render(run2, { file, report }, [
     actingHead(tenant, answer),
     `file          ${file}  ${parsed.clients.length} client(s), ${matters} matter(s)`,
@@ -9225,12 +9778,6 @@ ${ADMIN_USAGE}`);
 
 // tools/admin/src/surface.ts
 import { createHash } from "node:crypto";
-var MACHINE_ADMIN_PATHS = [
-  "/v1/admin/research/purge",
-  "/v1/admin/connectors/sync",
-  "/v1/admin/context/purge",
-  "/v1/admin/calendar/sync"
-];
 function canonicalJson(value) {
   if (Array.isArray(value))
     return `[${value.map((item) => item === undefined ? "null" : canonicalJson(item)).join(",")}]`;
@@ -9245,7 +9792,7 @@ function adminSurfaceOf(document) {
   const paths = document.paths ?? {};
   const kept = {};
   for (const path of Object.keys(paths)) {
-    if (path.startsWith("/v1/admin/") && !MACHINE_ADMIN_PATHS.includes(path))
+    if (path.startsWith("/v1/admin/"))
       kept[path] = paths[path];
   }
   return createHash("sha256").update(canonicalJson(kept)).digest("hex").slice(0, 16);
@@ -9281,9 +9828,9 @@ var result = await runAdmin(process.argv.slice(2), {
 `),
   openBrowser,
   localApiUrl: process.env["SIX_MINUTE_API_URL"] ?? null,
+  posthogKey: process.env["SIXMINUTE_POSTHOG_KEY"] ?? null,
   build: BUILT ?? sourceBuild(),
-  readStdin: passwordReader(process.stdin, readAllStdin),
-  googleAccessToken: () => googleAccessToken(process.env, process.platform)
+  readStdin: passwordReader(process.stdin, readAllStdin)
 }).catch((err) => {
   if (err instanceof AdminUsageError) {
     process.stderr.write(`sixminute-admin: ${err.message}