@threadbase-sh/streamer 1.37.0 → 1.38.0

package/dist/index.js

@@ -436,6 +436,58 @@ function getLogger(component) {
 }
 var logger = build(baseLogger);
 
+// src/feature-flags.ts
+var FEATURE_FLAGS = [
+  {
+    id: "codexSystemPrompt",
+    description: "Send the built system prompt to fresh Codex sessions. Off by default: Codex has no --system-prompt flag, so the prompt goes in the positional [PROMPT] argument, which Codex treats as the user's opening turn rather than a system-level instruction.",
+    default: false,
+    env: "THREADBASE_FEATURE_CODEX_SYSTEM_PROMPT"
+  }
+];
+function findFeatureFlag(id) {
+  return FEATURE_FLAGS.find((f) => f.id === id);
+}
+function parseBooleanEnv(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return false;
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
+}
+function validateFeatureFlagValues(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out = {};
+  const dropped = [];
+  for (const [id, value] of Object.entries(raw)) {
+    if (!findFeatureFlag(id) || typeof value !== "boolean") {
+      dropped.push(id);
+      continue;
+    }
+    out[id] = value;
+  }
+  if (dropped.length > 0) {
+    getLogger("feature-flags").warn(
+      `Ignoring unknown or non-boolean feature flags: ${dropped.join(", ")}`,
+      {
+        event: "config.feature_flags_dropped",
+        dropped
+      }
+    );
+  }
+  return out;
+}
+function resolveFeatureFlags(opts) {
+  const env = opts?.env ?? process.env;
+  const out = {};
+  for (const def of FEATURE_FLAGS) {
+    out[def.id] = parseBooleanEnv(env[def.env]) ?? opts?.cli?.[def.id] ?? opts?.yaml?.[def.id] ?? def.default;
+  }
+  return out;
+}
+function nonDefaultFeatureFlags(values) {
+  return FEATURE_FLAGS.filter((f) => values[f.id] !== f.default).map((f) => f.id);
+}
+
 // src/auth.ts
 function configDir() {
   return process.env.THREADBASE_CONFIG_DIR ?? join2(homedir(), ".threadbase");
@@ -588,6 +640,21 @@ function setClaudeExtraArgs(text) {
   }
   setConfigValue("claude_extra_args", trimmed && trimmed.length > 0 ? trimmed : void 0);
 }
+function loadFeatureFlags() {
+  try {
+    const content = readFileSync(configFile(), "utf-8");
+    const match = content.match(/^feature_flags:\s*(.+)$/m);
+    if (!match?.[1]) return {};
+    return validateFeatureFlagValues(JSON.parse(match[1].trim()));
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      getLogger("auth").warn(`Ignoring unreadable feature_flags in server.yaml: ${String(err)}`, {
+        event: "config.feature_flags_parse_failed"
+      });
+    }
+    return {};
+  }
+}
 function validatePublicUrl(raw) {
   let parsed;
   try {
@@ -2953,7 +3020,7 @@ import {
 } from "fs";
 import { realpath as realpath2 } from "fs/promises";
 import { createServer } from "http";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir9, hostname as hostname2 } from "os";
 import { basename as basename5, dirname as dirname9, join as join18 } from "path";
 import { createInterface } from "readline";
 
@@ -3635,6 +3702,7 @@ function readRawBody3(req) {
 var createConfigRoutes = (deps) => {
   const app = new Hono4();
   app.get("/claude-flags", (c) => c.json(deps.claudeFlagsConfig()));
+  app.get("/feature-flags", (c) => c.json(deps.featureFlagsConfig()));
   app.put("/claude-flags", async (c) => {
     if (deps.localNoAuth) {
       return c.json({ error: "claude flag changes are disabled while localNoAuth is active" }, 403);
@@ -3940,7 +4008,264 @@ function loadUpdateConfig(opts = {}) {
   return UpdateConfigSchema.parse(parsed);
 }
 
+// src/db/repositories/push.repository.ts
+var FAILURE_STREAK_LIMIT = 5;
+var PUSH_TOKEN_KINDS = ["expo", "liveactivity_start", "liveactivity_update"];
+var DEFAULT_PUSH_TOKEN_KIND = "expo";
+function isPushTokenKind(value) {
+  return typeof value === "string" && PUSH_TOKEN_KINDS.includes(value);
+}
+function tokenState(row, now = Date.now()) {
+  if (row.revoked_at != null) return "revoked";
+  if (row.expires_at != null && row.expires_at <= now) return "expired";
+  if (row.failure_streak >= FAILURE_STREAK_LIMIT) return "dead";
+  if (row.failure_streak > 0) return "failing";
+  if (row.last_success_at == null) return "never-delivered";
+  return "healthy";
+}
+function toHealth(row, now = Date.now()) {
+  return {
+    platform: row.platform,
+    deviceId: row.device_id,
+    registeredAt: row.registered_at,
+    lastSuccessAt: row.last_success_at,
+    lastFailureAt: row.last_failure_at,
+    lastFailureCode: row.last_failure_code,
+    failureStreak: row.failure_streak,
+    revokedAt: row.revoked_at,
+    state: tokenState(row, now),
+    kind: row.kind,
+    activityId: row.activity_id,
+    sessionId: row.session_id,
+    expiresAt: row.expires_at
+  };
+}
+var PushRepository = class {
+  upsertStmt;
+  getStmt;
+  listActiveStmt;
+  listAllStmt;
+  successStmt;
+  failureStmt;
+  revokeStmt;
+  claimEventStmt;
+  markDeliveredStmt;
+  listByKindSessionStmt;
+  listByKindStmt;
+  listRenewableStmt;
+  claimRenewalStmt;
+  expireStmt;
+  expireSessionActivitiesStmt;
+  constructor(db) {
+    this.upsertStmt = db.prepare(`
+      INSERT INTO push_tokens (
+        token, platform, device_id, registered_at,
+        kind, activity_id, session_id, expires_at, stale_date, started_at
+      )
+      VALUES (
+        @token, @platform, @device_id, @registered_at,
+        @kind, @activity_id, @session_id, @expires_at, @stale_date, @started_at
+      )
+      ON CONFLICT(token) DO UPDATE SET
+        platform = excluded.platform,
+        device_id = COALESCE(excluded.device_id, push_tokens.device_id),
+        registered_at = excluded.registered_at,
+        kind = excluded.kind,
+        activity_id = COALESCE(excluded.activity_id, push_tokens.activity_id),
+        session_id = COALESCE(excluded.session_id, push_tokens.session_id),
+        expires_at = excluded.expires_at,
+        stale_date = excluded.stale_date,
+        -- Preserve the ORIGINAL start across a re-registration. iOS renders its
+        -- own ticking timer from started_at, so overwriting it with a fresh
+        -- value visibly resets the user's elapsed time to zero.
+        started_at = COALESCE(push_tokens.started_at, excluded.started_at),
+        -- A fresh registration clears prior failure state and any revocation:
+        -- the client is telling us this token is live again. renewed_at clears
+        -- too \u2014 this is a new activity generation, so it is renewable again.
+        failure_streak = 0,
+        last_failure_at = NULL,
+        last_failure_code = NULL,
+        revoked_at = NULL,
+        renewed_at = NULL
+    `);
+    this.getStmt = db.prepare("SELECT * FROM push_tokens WHERE token = ?");
+    this.listActiveStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+         AND kind = 'expo'
+       ORDER BY registered_at ASC
+    `);
+    this.listAllStmt = db.prepare("SELECT * FROM push_tokens ORDER BY registered_at ASC");
+    this.successStmt = db.prepare(`
+      UPDATE push_tokens
+         SET last_success_at = @at, failure_streak = 0,
+             last_failure_code = NULL
+       WHERE token = @token
+    `);
+    this.failureStmt = db.prepare(`
+      UPDATE push_tokens
+         SET last_failure_at = @at, last_failure_code = @code,
+             failure_streak = failure_streak + 1
+       WHERE token = @token
+    `);
+    this.revokeStmt = db.prepare("UPDATE push_tokens SET revoked_at = ? WHERE token = ?");
+    this.listByKindSessionStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE kind = @kind AND session_id = @session_id
+         AND revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+         AND (expires_at IS NULL OR expires_at > @now)
+       ORDER BY registered_at ASC
+    `);
+    this.listByKindStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE kind = @kind
+         AND revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+         AND (expires_at IS NULL OR expires_at > @now)
+       ORDER BY registered_at ASC
+    `);
+    this.listRenewableStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE kind = 'liveactivity_update'
+         AND stale_date IS NOT NULL AND renewed_at IS NULL
+         AND revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+       ORDER BY stale_date ASC
+    `);
+    this.claimRenewalStmt = db.prepare(`
+      UPDATE push_tokens SET renewed_at = @at
+       WHERE token = @token AND renewed_at IS NULL
+    `);
+    this.expireStmt = db.prepare("UPDATE push_tokens SET expires_at = ? WHERE token = ?");
+    this.expireSessionActivitiesStmt = db.prepare(`
+      UPDATE push_tokens SET expires_at = @at
+       WHERE session_id = @session_id AND kind = 'liveactivity_update'
+         AND (expires_at IS NULL OR expires_at > @at)
+    `);
+    this.claimEventStmt = db.prepare(`
+      INSERT OR IGNORE INTO push_events (event_id, session_id, created_at)
+      VALUES (@event_id, @session_id, @created_at)
+    `);
+    this.markDeliveredStmt = db.prepare(
+      "UPDATE push_events SET delivered_at = ? WHERE event_id = ?"
+    );
+  }
+  /**
+   * Register or refresh a token.
+   *
+   * `kind` defaults to Expo so a released client posting `{ token, platform }`
+   * keeps working — tb-mobile cannot be force-updated, and every client
+   * predating Live Activities is registering an Expo relay token.
+   *
+   * Several rows per device is normal and intended: a device runs one activity
+   * per live session, each with its own update token. The token itself is the
+   * primary key, so distinct activities never collide.
+   */
+  register(args) {
+    this.upsertStmt.run({
+      token: args.token,
+      platform: args.platform,
+      device_id: args.deviceId ?? null,
+      registered_at: args.now ?? Date.now(),
+      kind: args.kind ?? DEFAULT_PUSH_TOKEN_KIND,
+      activity_id: args.activityId ?? null,
+      session_id: args.sessionId ?? null,
+      expires_at: args.expiresAt ?? null,
+      stale_date: args.staleDate ?? null,
+      started_at: args.startedAt ?? null
+    });
+  }
+  get(token) {
+    return this.getStmt.get(token) ?? null;
+  }
+  /**
+   * Expo tokens eligible for delivery — not revoked, not past the failure limit.
+   *
+   * Deliberately Expo-only. ActivityKit tokens go over direct APNs with a
+   * different topic and are rejected by Expo's relay, so the ordinary
+   * notification fan-out must not see them.
+   */
+  listDeliverable() {
+    return this.listActiveStmt.all();
+  }
+  /** Live-activity tokens for one session, eligible for delivery. */
+  listForSession(kind, sessionId, now = Date.now()) {
+    return this.listByKindSessionStmt.all({
+      kind,
+      session_id: sessionId,
+      now
+    });
+  }
+  /**
+   * Every deliverable token of one kind.
+   *
+   * Used for push-to-start, which is app-wide rather than session-scoped: the
+   * activity does not exist yet, so there is no per-activity token to look up.
+   */
+  listByKind(kind, now = Date.now()) {
+    return this.listByKindStmt.all({ kind, now });
+  }
+  /** Unrenewed activities with a renewal deadline, soonest first. */
+  listRenewable() {
+    return this.listRenewableStmt.all();
+  }
+  /**
+   * Claim a row for renewal.
+   *
+   * Returns true exactly once per row. A restart re-arms timers from the
+   * persisted deadline, so the same renewal can be attempted twice; the loser
+   * gets false and must not send. Doing this as a conditional UPDATE rather
+   * than read-then-write avoids the race where both attempts observe
+   * "not yet renewed".
+   */
+  claimRenewal(token, now = Date.now()) {
+    return this.claimRenewalStmt.run({ token, at: now }).changes > 0;
+  }
+  /** Mark one token expired, so it stops being a delivery target. */
+  expire(token, now = Date.now()) {
+    this.expireStmt.run(now, token);
+  }
+  /**
+   * Expire every live activity for a session.
+   *
+   * Called when the session ends. Without this, a per-activity token outlives
+   * its session and a later renewal sweep would resurrect an activity for a
+   * session that is already gone.
+   */
+  expireSessionActivities(sessionId, now = Date.now()) {
+    this.expireSessionActivitiesStmt.run({ session_id: sessionId, at: now });
+  }
+  /** Every token, including dead and revoked ones, for the health report. */
+  listHealth(now = Date.now()) {
+    return this.listAllStmt.all().map((r) => toHealth(r, now));
+  }
+  recordSuccess(token, now = Date.now()) {
+    this.successStmt.run({ token, at: now });
+  }
+  recordFailure(token, code, now = Date.now()) {
+    this.failureStmt.run({ token, at: now, code });
+  }
+  revoke(token, now = Date.now()) {
+    return this.revokeStmt.run(now, token).changes > 0;
+  }
+  /**
+   * Claim an event id for delivery.
+   *
+   * Returns true exactly once per event id. A retry, a reconnect
+   * reconciliation, or two triggers firing for the same underlying event all
+   * get false and must not notify — the user should never be told twice about
+   * one thing.
+   */
+  claimEvent(eventId, sessionId, now = Date.now()) {
+    return this.claimEventStmt.run({ event_id: eventId, session_id: sessionId, created_at: now }).changes > 0;
+  }
+  markDelivered(eventId, now = Date.now()) {
+    this.markDeliveredStmt.run(now, eventId);
+  }
+};
+
 // src/api/routes/misc.routes.ts
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function readJsonBody(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
@@ -3987,7 +4312,11 @@ var createMiscRoutes = (deps) => {
       // Capability flag: this server serves /api/config/claude-flags. Additive —
       // older clients ignore it, and clients talking to an older server see it
       // absent and hide the UI rather than 404ing.
-      claudeFlags: true
+      claudeFlags: true,
+      // Same contract: this server serves GET /api/config/feature-flags. Lives
+      // here rather than behind /api/config (admin-only) so a read-only client
+      // still learns the server supports flags even if it can't read values.
+      featureFlags: true
     });
   });
   app.get("/api/profiles", (c) => c.json([]));
@@ -4014,6 +4343,22 @@ var createMiscRoutes = (deps) => {
     if (platform3 !== "ios" && platform3 !== "android") {
       return c.json({ error: "platform must be 'ios' or 'android'" }, 400);
     }
+    const kind = body?.kind === void 0 ? DEFAULT_PUSH_TOKEN_KIND : body.kind;
+    if (!isPushTokenKind(kind)) {
+      return c.json(
+        { error: `kind must be one of ${PUSH_TOKEN_KINDS.join(", ")}`, code: "INVALID_KIND" },
+        400
+      );
+    }
+    if (kind === "liveactivity_update" && typeof body?.activityId !== "string") {
+      return c.json(
+        {
+          error: "activityId is required for kind 'liveactivity_update'",
+          code: "MISSING_ACTIVITY"
+        },
+        400
+      );
+    }
     const repo = deps.pushRepo();
     if (!repo) {
       return c.json({ error: "Push registration is unavailable", code: "STORE_UNAVAILABLE" }, 503);
@@ -4021,7 +4366,13 @@ var createMiscRoutes = (deps) => {
     repo.register({
       token,
       platform: platform3,
-      deviceId: typeof body?.deviceId === "string" ? body.deviceId : null
+      deviceId: typeof body?.deviceId === "string" ? body.deviceId : null,
+      kind,
+      activityId: typeof body?.activityId === "string" ? body.activityId : null,
+      sessionId: typeof body?.sessionId === "string" ? body.sessionId : null,
+      expiresAt: numberOrNull(body?.expiresAt),
+      staleDate: numberOrNull(body?.staleDate),
+      startedAt: numberOrNull(body?.startedAt)
     });
     return c.json({ ok: true });
   });
@@ -6118,125 +6469,6 @@ function deriveNameFromPath(path) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 
-// src/db/repositories/push.repository.ts
-var FAILURE_STREAK_LIMIT = 5;
-function tokenState(row) {
-  if (row.revoked_at != null) return "revoked";
-  if (row.failure_streak >= FAILURE_STREAK_LIMIT) return "dead";
-  if (row.failure_streak > 0) return "failing";
-  if (row.last_success_at == null) return "never-delivered";
-  return "healthy";
-}
-function toHealth(row) {
-  return {
-    platform: row.platform,
-    deviceId: row.device_id,
-    registeredAt: row.registered_at,
-    lastSuccessAt: row.last_success_at,
-    lastFailureAt: row.last_failure_at,
-    lastFailureCode: row.last_failure_code,
-    failureStreak: row.failure_streak,
-    revokedAt: row.revoked_at,
-    state: tokenState(row)
-  };
-}
-var PushRepository = class {
-  upsertStmt;
-  getStmt;
-  listActiveStmt;
-  listAllStmt;
-  successStmt;
-  failureStmt;
-  revokeStmt;
-  claimEventStmt;
-  markDeliveredStmt;
-  constructor(db) {
-    this.upsertStmt = db.prepare(`
-      INSERT INTO push_tokens (token, platform, device_id, registered_at)
-      VALUES (@token, @platform, @device_id, @registered_at)
-      ON CONFLICT(token) DO UPDATE SET
-        platform = excluded.platform,
-        device_id = COALESCE(excluded.device_id, push_tokens.device_id),
-        registered_at = excluded.registered_at,
-        -- A fresh registration clears prior failure state and any revocation:
-        -- the client is telling us this token is live again.
-        failure_streak = 0,
-        last_failure_at = NULL,
-        last_failure_code = NULL,
-        revoked_at = NULL
-    `);
-    this.getStmt = db.prepare("SELECT * FROM push_tokens WHERE token = ?");
-    this.listActiveStmt = db.prepare(`
-      SELECT * FROM push_tokens
-       WHERE revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
-       ORDER BY registered_at ASC
-    `);
-    this.listAllStmt = db.prepare("SELECT * FROM push_tokens ORDER BY registered_at ASC");
-    this.successStmt = db.prepare(`
-      UPDATE push_tokens
-         SET last_success_at = @at, failure_streak = 0,
-             last_failure_code = NULL
-       WHERE token = @token
-    `);
-    this.failureStmt = db.prepare(`
-      UPDATE push_tokens
-         SET last_failure_at = @at, last_failure_code = @code,
-             failure_streak = failure_streak + 1
-       WHERE token = @token
-    `);
-    this.revokeStmt = db.prepare("UPDATE push_tokens SET revoked_at = ? WHERE token = ?");
-    this.claimEventStmt = db.prepare(`
-      INSERT OR IGNORE INTO push_events (event_id, session_id, created_at)
-      VALUES (@event_id, @session_id, @created_at)
-    `);
-    this.markDeliveredStmt = db.prepare(
-      "UPDATE push_events SET delivered_at = ? WHERE event_id = ?"
-    );
-  }
-  register(args) {
-    this.upsertStmt.run({
-      token: args.token,
-      platform: args.platform,
-      device_id: args.deviceId ?? null,
-      registered_at: args.now ?? Date.now()
-    });
-  }
-  get(token) {
-    return this.getStmt.get(token) ?? null;
-  }
-  /** Tokens eligible for delivery — not revoked, not past the failure limit. */
-  listDeliverable() {
-    return this.listActiveStmt.all();
-  }
-  /** Every token, including dead and revoked ones, for the health report. */
-  listHealth() {
-    return this.listAllStmt.all().map(toHealth);
-  }
-  recordSuccess(token, now = Date.now()) {
-    this.successStmt.run({ token, at: now });
-  }
-  recordFailure(token, code, now = Date.now()) {
-    this.failureStmt.run({ token, at: now, code });
-  }
-  revoke(token, now = Date.now()) {
-    return this.revokeStmt.run(now, token).changes > 0;
-  }
-  /**
-   * Claim an event id for delivery.
-   *
-   * Returns true exactly once per event id. A retry, a reconnect
-   * reconciliation, or two triggers firing for the same underlying event all
-   * get false and must not notify — the user should never be told twice about
-   * one thing.
-   */
-  claimEvent(eventId, sessionId, now = Date.now()) {
-    return this.claimEventStmt.run({ event_id: eventId, session_id: sessionId, created_at: now }).changes > 0;
-  }
-  markDelivered(eventId, now = Date.now()) {
-    this.markDeliveredStmt.run(now, eventId);
-  }
-};
-
 // src/db/repositories/sessions.repository.ts
 var SessionsRepository = class {
   constructor(store) {
@@ -6469,10 +6701,10 @@ function fingerprintOf(ids) {
   return `sha256:${createHash3("sha256").update(sorted.join("\n")).digest("hex")}`;
 }
 var CacheIntegrityMonitor = class {
-  constructor(cache, wsHub, log3, cacheDir, rescan, runDuringReset) {
+  constructor(cache, wsHub, log7, cacheDir, rescan, runDuringReset) {
     this.cache = cache;
     this.wsHub = wsHub;
-    this.log = log3;
+    this.log = log7;
     this.cacheDir = cacheDir;
     this.rescan = rescan;
     this.runDuringReset = runDuringReset;
@@ -7085,6 +7317,577 @@ function deriveProjectChatTitle(input) {
   return `Untitled \xB7 ${input.id.slice(0, 8)}`;
 }
 
+// src/services/push/apnsClient.ts
+import { createSign } from "crypto";
+import { connect, constants } from "http2";
+var log3 = getLogger("apns");
+var APNS_HOST_SANDBOX = "api.sandbox.push.apple.com";
+var APNS_MAX_PAYLOAD_BYTES = 4096;
+var JWT_TTL_SECONDS = 3e3;
+var DEAD_TOKEN_REASONS = /* @__PURE__ */ new Set([
+  "BadDeviceToken",
+  "DeviceTokenNotForTopic",
+  "Unregistered",
+  "ExpiredToken"
+]);
+function base64url(input) {
+  return Buffer.from(input).toString("base64url");
+}
+function readApnsCredentialsFromEnv(env = process.env) {
+  const key = env.APNS_KEY;
+  if (!key || key.trim().length === 0) return null;
+  const keyId = env.APNS_KEY_ID?.trim();
+  const teamId = env.APNS_TEAM_ID?.trim();
+  const bundleId = env.APNS_BUNDLE_ID?.trim();
+  if (!keyId || !teamId || !bundleId) return null;
+  const host = env.APNS_HOST ?? APNS_HOST_SANDBOX;
+  return { key, keyId, teamId, bundleId, host };
+}
+function describeMissingApnsCredentials(env = process.env) {
+  if (!env.APNS_KEY || env.APNS_KEY.trim().length === 0) {
+    return "APNS_KEY is not set, so Live Activity push is disabled. Set it to the p8 key contents (not a path) to enable it.";
+  }
+  const missing = [
+    ["APNS_KEY_ID", env.APNS_KEY_ID],
+    ["APNS_TEAM_ID", env.APNS_TEAM_ID],
+    ["APNS_BUNDLE_ID", env.APNS_BUNDLE_ID]
+  ].filter(([, value]) => !value || value.trim().length === 0).map(([name]) => name);
+  if (missing.length === 0) return null;
+  return `APNS_KEY is set but ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not, so Live Activity push is disabled. Under launchd, APNS_KEY_ID is derived from the AuthKey_<keyId>.p8 filename; the team and bundle ids must be set explicitly.`;
+}
+var ApnsClient = class {
+  constructor(creds) {
+    this.creds = creds;
+  }
+  creds;
+  session = null;
+  cachedJwt = null;
+  /**
+   * The `apns-topic` for Live Activity pushes.
+   *
+   * The `.push-type.liveactivity` suffix is mandatory and is why the signing key
+   * must be Team Scoped (All Topics) — a key scoped to the bundle id alone
+   * cannot sign this topic.
+   */
+  get topic() {
+    return `${this.creds.bundleId}.push-type.liveactivity`;
+  }
+  /**
+   * Mint or reuse the provider JWT.
+   *
+   * ES256 over the p8 key. Cached until shortly before expiry: Apple rejects a
+   * token older than an hour, but minting one per request is wasteful and can
+   * trip APNs' provider-token-update throttle.
+   */
+  getJwt(now = Date.now()) {
+    const nowSeconds = Math.floor(now / 1e3);
+    if (this.cachedJwt && this.cachedJwt.expiresAt > nowSeconds + 60) {
+      return this.cachedJwt.token;
+    }
+    const header = base64url(JSON.stringify({ alg: "ES256", kid: this.creds.keyId, typ: "JWT" }));
+    const payload = base64url(JSON.stringify({ iss: this.creds.teamId, iat: nowSeconds }));
+    const signingInput = `${header}.${payload}`;
+    const signature = createSign("SHA256").update(signingInput).sign({ key: this.creds.key, dsaEncoding: "ieee-p1363" });
+    const token = `${signingInput}.${base64url(signature)}`;
+    this.cachedJwt = { token, expiresAt: nowSeconds + JWT_TTL_SECONDS };
+    return token;
+  }
+  /**
+   * Reuse one HTTP/2 session across sends.
+   *
+   * APNs expects a long-lived connection; a fresh TLS handshake per push is slow
+   * and Apple treats connection churn as abuse.
+   */
+  getSession() {
+    if (this.session && !this.session.closed && !this.session.destroyed) {
+      return this.session;
+    }
+    const session = connect(`https://${this.creds.host}`);
+    session.on("error", (err) => {
+      log3.warn("apns.session_error", { event: "apns.session_error", err: String(err) });
+    });
+    this.session = session;
+    return session;
+  }
+  /**
+   * Send one push.
+   *
+   * Resolves with a result rather than rejecting on an APNs rejection: a
+   * rejected push is an expected outcome the caller must act on (retire the
+   * token), not an exception. Only a genuinely unexpected local failure throws,
+   * and the caller logs it.
+   */
+  async send(args) {
+    const body = Buffer.from(JSON.stringify(args.payload), "utf-8");
+    if (body.byteLength > APNS_MAX_PAYLOAD_BYTES) {
+      throw new Error(
+        `APNs payload is ${body.byteLength} bytes, over the ${APNS_MAX_PAYLOAD_BYTES} byte limit`
+      );
+    }
+    const session = this.getSession();
+    const headers = {
+      [constants.HTTP2_HEADER_METHOD]: "POST",
+      [constants.HTTP2_HEADER_PATH]: `/3/device/${args.deviceToken}`,
+      [constants.HTTP2_HEADER_AUTHORIZATION]: `bearer ${this.getJwt()}`,
+      "apns-push-type": "liveactivity",
+      "apns-topic": this.topic,
+      "apns-priority": String(args.priority ?? 10),
+      ...args.expirationSeconds != null && {
+        "apns-expiration": String(args.expirationSeconds)
+      },
+      [constants.HTTP2_HEADER_CONTENT_TYPE]: "application/json",
+      [constants.HTTP2_HEADER_CONTENT_LENGTH]: String(body.byteLength)
+    };
+    return new Promise((resolve2, reject) => {
+      const req = session.request(headers);
+      req.setTimeout(args.timeoutMs ?? 1e4, () => {
+        req.close(constants.NGHTTP2_CANCEL);
+        resolve2({ ok: false, status: 0, reason: "Timeout", tokenDead: false });
+      });
+      let status = 0;
+      req.on("response", (resHeaders) => {
+        status = Number(resHeaders[constants.HTTP2_HEADER_STATUS] ?? 0);
+      });
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("error", reject);
+      req.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        let reason;
+        if (raw.length > 0) {
+          try {
+            reason = JSON.parse(raw).reason;
+          } catch {
+            reason = raw.slice(0, 200);
+          }
+        }
+        resolve2({
+          ok: status === 200,
+          status,
+          reason,
+          tokenDead: reason != null && DEAD_TOKEN_REASONS.has(reason)
+        });
+      });
+      req.end(body);
+    });
+  }
+  /** Close the shared connection. Called on server shutdown. */
+  close() {
+    this.session?.close();
+    this.session = null;
+  }
+};
+
+// src/services/push/liveActivityContentState.ts
+var LAST_OUTPUT_MAX_LENGTH = 90;
+function toLiveActivityStatus(status) {
+  return status === "running" || status === "waiting_input" ? status : null;
+}
+function truncateLastOutput(raw) {
+  const oneLine = raw.replace(/\s+/g, " ").trim();
+  return oneLine.length <= LAST_OUTPUT_MAX_LENGTH ? oneLine : oneLine.slice(0, LAST_OUTPUT_MAX_LENGTH);
+}
+
+// src/services/push/liveActivityNotifier.ts
+var log4 = getLogger("live-activity");
+function contentStateForSession(args) {
+  const status = toLiveActivityStatus(args.session.status);
+  if (!status) return null;
+  return {
+    sessionId: args.session.id,
+    serverId: args.serverId,
+    projectName: args.session.projectName,
+    status,
+    startedAt: args.startedAtOverride ?? args.session.startedAt.getTime(),
+    lastOutput: truncateLastOutput(args.session.lastOutput ?? ""),
+    ...args.serverLabel != null && { serverLabel: args.serverLabel }
+  };
+}
+var LiveActivityNotifier = class {
+  constructor(sender, serverId, serverLabel) {
+    this.sender = sender;
+    this.serverId = serverId;
+    this.serverLabel = serverLabel;
+  }
+  sender;
+  serverId;
+  serverLabel;
+  /**
+   * Last status pushed per session.
+   *
+   * Live Activity pushes are rate-limited by iOS and the surface only renders
+   * `running` vs `waiting_input`, so re-pushing an unchanged status is pure
+   * budget spend for no visible change. This is what makes the notifier
+   * edge-triggered rather than level-triggered.
+   */
+  lastPushed = /* @__PURE__ */ new Map();
+  /**
+   * React to a session status change.
+   *
+   * Fire-and-forget by design: a push must never delay or fail a session
+   * transition, so this returns a promise the caller may ignore and every error
+   * is logged rather than propagated.
+   */
+  async onStatusChange(session) {
+    const status = toLiveActivityStatus(session.status);
+    try {
+      if (!status) {
+        await this.endFor(session);
+        return;
+      }
+      if (this.lastPushed.get(session.id) === status) return;
+      const contentState = contentStateForSession({
+        session,
+        serverId: this.serverId,
+        serverLabel: this.serverLabel
+      });
+      if (!contentState) return;
+      const outcome = await this.sender.send({
+        sessionId: session.id,
+        event: "update",
+        contentState
+      });
+      this.lastPushed.set(session.id, status);
+      if (outcome.attempted > 0) {
+        log4.info("live_activity.updated", {
+          event: "live_activity.updated",
+          sessionId: session.id,
+          status,
+          ...outcome
+        });
+      }
+    } catch (err) {
+      log4.error("live_activity.notify_failed", {
+        event: "live_activity.notify_failed",
+        sessionId: session.id,
+        status: session.status,
+        err: String(err)
+      });
+    }
+  }
+  async endFor(session) {
+    const lastStatus = this.lastPushed.get(session.id);
+    this.lastPushed.delete(session.id);
+    const contentState = contentStateForSession({
+      session: {
+        ...session,
+        status: lastStatus === "waiting_input" ? "waiting_input" : "running"
+      },
+      serverId: this.serverId,
+      serverLabel: this.serverLabel
+    });
+    if (!contentState) return;
+    const outcome = await this.sender.end({ sessionId: session.id, contentState });
+    if (outcome.attempted > 0) {
+      log4.info("live_activity.ended", {
+        event: "live_activity.ended",
+        sessionId: session.id,
+        ...outcome
+      });
+    }
+  }
+  /** Drop cached state for a session, so a resume re-pushes its first status. */
+  forget(sessionId) {
+    this.lastPushed.delete(sessionId);
+  }
+};
+
+// src/services/push/liveActivitySender.ts
+var log5 = getLogger("live-activity");
+var ACTIVITY_MAX_LIFETIME_MS = 8 * 60 * 60 * 1e3;
+function buildActivityKitPayload(args) {
+  return {
+    aps: {
+      timestamp: Math.floor(args.now / 1e3),
+      event: args.event,
+      "content-state": args.contentState,
+      ...args.staleDate != null && { "stale-date": Math.floor(args.staleDate / 1e3) },
+      ...args.dismissalDate != null && {
+        "dismissal-date": Math.floor(args.dismissalDate / 1e3)
+      }
+    }
+  };
+}
+var LiveActivitySender = class {
+  constructor(apns, repo) {
+    this.apns = apns;
+    this.repo = repo;
+  }
+  apns;
+  repo;
+  /**
+   * Push to every live activity of a session.
+   *
+   * Sends are independent: one rejected token must not stop the others, because
+   * a single dead device would otherwise silence every other device watching the
+   * same session.
+   */
+  async send(args) {
+    const now = args.now ?? Date.now();
+    return this.sendToTokens({
+      tokens: this.repo.listForSession("liveactivity_update", args.sessionId, now),
+      sessionId: args.sessionId,
+      event: args.event,
+      contentState: args.contentState,
+      now,
+      priority: args.priority
+    });
+  }
+  /**
+   * Push to an explicit token list.
+   *
+   * Renewal needs this: a replacement activity does not exist yet, so it is
+   * started via the app-wide push-to-start token rather than any per-session
+   * lookup. Shares one fan-out body with `send()` so failure handling cannot
+   * drift between the two paths.
+   */
+  async sendToTokens(args) {
+    const now = args.now ?? Date.now();
+    const tokens = args.tokens;
+    const outcome = {
+      attempted: tokens.length,
+      succeeded: 0,
+      retired: 0
+    };
+    if (tokens.length === 0) return outcome;
+    const results = await Promise.all(
+      tokens.map(
+        (row) => this.sendToToken(row, args.event, args.contentState, now, args.priority, args.staleDate)
+      )
+    );
+    for (const { row, result, error } of results) {
+      if (error) {
+        log5.error("live_activity.send_failed", {
+          event: "live_activity.send_failed",
+          sessionId: args.sessionId,
+          activityId: row.activity_id,
+          apnsEvent: args.event,
+          err: String(error)
+        });
+        this.repo.recordFailure(row.token, "SendError", now);
+        continue;
+      }
+      if (!result) continue;
+      if (result.ok) {
+        this.repo.recordSuccess(row.token, now);
+        outcome.succeeded += 1;
+        continue;
+      }
+      this.repo.recordFailure(row.token, result.reason ?? `HTTP_${result.status}`, now);
+      if (result.tokenDead) {
+        this.repo.expire(row.token, now);
+        outcome.retired += 1;
+      }
+      log5.warn("live_activity.send_rejected", {
+        event: "live_activity.send_rejected",
+        sessionId: args.sessionId,
+        activityId: row.activity_id,
+        apnsEvent: args.event,
+        status: result.status,
+        reason: result.reason,
+        tokenDead: result.tokenDead
+      });
+    }
+    return outcome;
+  }
+  /**
+   * End every live activity for a session and stop tracking them.
+   *
+   * Expiring locally is what stops the renewal sweep from later resurrecting an
+   * activity for a session that has already finished.
+   */
+  async end(args) {
+    const now = args.now ?? Date.now();
+    const outcome = await this.send({
+      sessionId: args.sessionId,
+      event: "end",
+      contentState: args.contentState,
+      now
+    });
+    this.repo.expireSessionActivities(args.sessionId, now);
+    return outcome;
+  }
+  async sendToToken(row, event, contentState, now, priority, staleDateOverride) {
+    const staleDate = event === "update" ? staleDateOverride ?? row.stale_date ?? contentState.startedAt + ACTIVITY_MAX_LIFETIME_MS : null;
+    try {
+      const result = await this.apns.send({
+        deviceToken: row.token,
+        payload: buildActivityKitPayload({ event, contentState, now, staleDate }),
+        priority
+      });
+      return { row, result };
+    } catch (error) {
+      return { row, error };
+    }
+  }
+};
+
+// src/services/push/liveActivityRenewal.ts
+var log6 = getLogger("live-activity");
+var RENEWAL_LEAD_MS = 30 * 60 * 1e3;
+var MAX_TIMER_MS = 60 * 60 * 1e3;
+function renewalDueAt(row) {
+  return row.stale_date == null ? null : row.stale_date - RENEWAL_LEAD_MS;
+}
+var LiveActivityRenewalScheduler = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+  }
+  deps;
+  timer = null;
+  stopped = false;
+  now;
+  /**
+   * Arm the scheduler from persisted state.
+   *
+   * Called on boot, which is what makes a renewal survive a restart: the
+   * deadlines were never in memory to begin with.
+   */
+  start() {
+    this.stopped = false;
+    void this.tick();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Renew everything due, then sleep until the next deadline.
+   *
+   * Re-reads from the DB every tick rather than caching a schedule in memory, so
+   * an activity registered after boot is picked up without re-arming anything.
+   */
+  async tick() {
+    if (this.stopped) return;
+    const now = this.now();
+    try {
+      for (const row of this.deps.repo.listRenewable()) {
+        const dueAt = renewalDueAt(row);
+        if (dueAt == null || dueAt > now) continue;
+        await this.renew(row, now);
+      }
+    } catch (err) {
+      log6.error("live_activity.renewal_sweep_failed", {
+        event: "live_activity.renewal_sweep_failed",
+        err: String(err)
+      });
+    }
+    this.scheduleNext();
+  }
+  scheduleNext() {
+    if (this.stopped) return;
+    const now = this.now();
+    const pending = this.deps.repo.listRenewable().map(renewalDueAt).filter((d) => d != null);
+    const nextDue = pending.length > 0 ? Math.min(...pending) : now + MAX_TIMER_MS;
+    const delay = Math.min(Math.max(nextDue - now, 0), MAX_TIMER_MS);
+    this.timer = setTimeout(() => void this.tick(), delay);
+    this.timer.unref?.();
+  }
+  /**
+   * Renew one activity.
+   *
+   * Claims first: `claimRenewal()` succeeds exactly once per row, so a timer
+   * re-armed after a restart mid-window cannot send a second time.
+   */
+  async renew(row, now) {
+    if (!row.session_id) return;
+    const session = this.deps.sessionStore.getManaged(row.session_id);
+    const status = session ? toLiveActivityStatus(session.status) : null;
+    if (!session || !status) {
+      this.deps.repo.claimRenewal(row.token, now);
+      this.deps.repo.expire(row.token, now);
+      log6.info("live_activity.renewal_skipped", {
+        event: "live_activity.renewal_skipped",
+        sessionId: row.session_id,
+        activityId: row.activity_id,
+        reason: session ? `status_${session.status}` : "session_gone"
+      });
+      return;
+    }
+    if (!this.deps.repo.claimRenewal(row.token, now)) {
+      return;
+    }
+    const startedAt = row.started_at ?? session.startedAt.getTime();
+    const contentState = {
+      sessionId: session.id,
+      serverId: this.deps.serverId,
+      projectName: session.projectName,
+      status,
+      startedAt,
+      lastOutput: session.lastOutput ?? "",
+      ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel }
+    };
+    try {
+      await this.deps.sender.send({
+        sessionId: session.id,
+        event: "end",
+        contentState: { ...contentState, lastOutput: truncateLastOutput(contentState.lastOutput) },
+        now
+      });
+      this.deps.repo.expire(row.token, now);
+      const started = await this.startReplacement({
+        sessionId: session.id,
+        startedAt,
+        now
+      });
+      log6.info("live_activity.renewed", {
+        event: "live_activity.renewed",
+        sessionId: session.id,
+        activityId: row.activity_id,
+        // Logged because a regression here is invisible on the server and only
+        // shows up as a reset timer on someone's Lock Screen.
+        startedAt,
+        replacementRequested: started
+      });
+    } catch (err) {
+      log6.error("live_activity.renewal_failed", {
+        event: "live_activity.renewal_failed",
+        sessionId: session.id,
+        activityId: row.activity_id,
+        err: String(err)
+      });
+    }
+  }
+  /**
+   * Ask the device to start a replacement activity.
+   *
+   * Uses the app-wide push-to-start token, because the replacement does not
+   * exist yet and therefore has no per-activity token. Returns false when the
+   * device never registered one, which is not an error: the app simply cannot be
+   * asked to start an activity remotely, and the next foreground WS update
+   * recreates it.
+   */
+  async startReplacement(args) {
+    const starters = this.deps.repo.listByKind("liveactivity_start", args.now);
+    if (starters.length === 0) return false;
+    const session = this.deps.sessionStore.getManaged(args.sessionId);
+    const status = session ? toLiveActivityStatus(session.status) : null;
+    if (!session || !status) return false;
+    await this.deps.sender.sendToTokens({
+      tokens: starters,
+      event: "update",
+      sessionId: args.sessionId,
+      contentState: {
+        sessionId: session.id,
+        serverId: this.deps.serverId,
+        projectName: session.projectName,
+        status,
+        // Carried through unchanged — the whole point of the renewal.
+        startedAt: args.startedAt,
+        lastOutput: truncateLastOutput(session.lastOutput ?? ""),
+        ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel }
+      },
+      now: args.now,
+      staleDate: args.startedAt + ACTIVITY_MAX_LIFETIME_MS
+    });
+    return true;
+  }
+};
+
 // src/services/questions/parseStatusLine.ts
 var MODEL_RE = /(Opus|Sonnet|Haiku|Fable)\s+[\d.]+(?:\s*\([^)]*\))?/;
 var EFFORT_RE = /●\s*([A-Za-z]+)\s*·\s*\/effort/;
@@ -8036,6 +8839,12 @@ var StreamerServer = class {
   sessionInputAttempts = /* @__PURE__ */ new Map();
   ptyGracePeriodMs;
   defaultSystemPrompt;
+  // Resolved once at boot; see src/feature-flags.ts. Total map — every registry
+  // id is present, so indexing it never yields undefined.
+  featureFlags;
+  // Derived from featureFlags.codexSystemPrompt. Kept as its own field so the
+  // read site in startFresh() is unchanged.
+  codexSystemPromptEnabled;
   defaultPermissionMode;
   defaultModel;
   defaultEffort;
@@ -8091,6 +8900,12 @@ var StreamerServer = class {
   // Paired-device registry (C5). Null when the cache DB failed to open — auth
   // then falls back to the shared API key alone, which is the pre-C5 behaviour.
   devicesRepo = null;
+  // Live Activity push (Feature 12). Null when APNS_KEY is unset — the ordinary
+  // case on a dev machine and in CI, where the feature is simply off. Missing an
+  // optional push credential must never stop the server from booting.
+  apnsClient = null;
+  liveActivityNotifier = null;
+  liveActivityRenewal = null;
   discoveryCache = null;
   cacheDir;
   tailSize;
@@ -8126,6 +8941,11 @@ var StreamerServer = class {
     this.codexRoots = config.codexRoots ?? [join18(homedir9(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.featureFlags = resolveFeatureFlags({ cli: config.featureFlags, yaml: loadFeatureFlags() });
+    if (config.codexSystemPromptEnabled !== void 0) {
+      this.featureFlags.codexSystemPrompt = config.codexSystemPromptEnabled;
+    }
+    this.codexSystemPromptEnabled = this.featureFlags.codexSystemPrompt;
     this.defaultPermissionMode = config.defaultPermissionMode ?? loadDefaultPermissionMode() ?? "acceptEdits";
     this.defaultModel = config.defaultModel ?? "sonnet";
     this.defaultEffort = config.defaultEffort ?? "low";
@@ -8141,6 +8961,13 @@ var StreamerServer = class {
     }, this.directoryDebounceMs);
     this.includeAgents = parseIncludeAgentsEnv(process.env.THREADBASE_INCLUDE_AGENTS);
     this.agentEntrypoints = parseAgentEntrypointsEnv(process.env.THREADBASE_AGENT_ENTRYPOINTS);
+    const enabledFlags = nonDefaultFeatureFlags(this.featureFlags);
+    if (enabledFlags.length > 0) {
+      this.log.info(`Feature flags active: ${enabledFlags.join(", ")}`, {
+        event: "config.feature_flags_active",
+        flags: enabledFlags
+      });
+    }
     const rawRoot = process.env.THREADBASE_BROWSE_ROOT ?? loadBrowseRoot() ?? config.browseRoot;
     if (rawRoot) {
       realpath2(rawRoot).then((resolved) => {
@@ -8334,6 +9161,7 @@ var StreamerServer = class {
         if (resp) {
           this.wsHub.broadcast({ type: "session_update", session: resp });
         }
+        void this.liveActivityNotifier?.onStatusChange(session);
         this.sessionStatusBus.emit(`status:${session.id}`, session.status);
       }
     });
@@ -8368,6 +9196,7 @@ var StreamerServer = class {
       logMenubarRequests: this.logMenubarRequests,
       rotateApiKey: () => this.rotateApiKey(),
       claudeFlagsConfig: () => this.getClaudeFlagsConfig(),
+      featureFlagsConfig: () => this.getFeatureFlagsConfig(),
       setClaudeFlagsConfig: (values, extraArgs) => this.setClaudeFlagsConfig(values, extraArgs),
       publicUrl: this.publicUrl,
       browseRoot: this.browseRoot,
@@ -8599,6 +9428,41 @@ var StreamerServer = class {
     }
     this.ptyGraceDeferCounts.delete(sessionId);
   }
+  /**
+   * Bring up Live Activity push, if credentials are present (Feature 12).
+   *
+   * APNS_KEY absent is the ordinary case on a dev machine and in CI, so this
+   * logs once at info and leaves the feature off rather than failing: the server
+   * must not refuse to boot over a missing optional push credential.
+   *
+   * The key is read from the environment as PEM contents and never from a path
+   * on disk; neither it nor any device token is ever logged.
+   */
+  initLiveActivityPush(pushRepo) {
+    const creds = readApnsCredentialsFromEnv();
+    if (!creds) {
+      const why = describeMissingApnsCredentials();
+      if (why) this.log.info(why, { event: "live_activity.disabled" });
+      return;
+    }
+    this.apnsClient = new ApnsClient(creds);
+    const sender = new LiveActivitySender(this.apnsClient, pushRepo);
+    const serverId = process.env.THREADBASE_INSTANCE_ID ?? hostname2();
+    this.liveActivityNotifier = new LiveActivityNotifier(sender, serverId, hostname2());
+    this.liveActivityRenewal = new LiveActivityRenewalScheduler({
+      repo: pushRepo,
+      sender,
+      sessionStore: this.sessionStore,
+      serverId,
+      serverLabel: hostname2()
+    });
+    this.liveActivityRenewal.start();
+    this.log.info("Live Activity push enabled", {
+      event: "live_activity.enabled",
+      host: creds.host,
+      topic: `${creds.bundleId}.push-type.liveactivity`
+    });
+  }
   /**
    * Classify sessions left behind by previous streamer runs (C1 Phase 3a).
    *
@@ -8908,6 +9772,7 @@ var StreamerServer = class {
           this.cacheMetadataRepo = new CacheMetadataRepository(db);
           this.pushRepo = new PushRepository(db);
           this.devicesRepo = new DevicesRepository(db);
+          this.initLiveActivityPush(this.pushRepo);
           this.cacheMonitor = new CacheIntegrityMonitor(
             this.cache,
             this.wsHub,
@@ -9142,6 +10007,8 @@ var StreamerServer = class {
     this.externalTails.clear();
     this.wsHub.dispose();
     this.pairTokens.dispose();
+    this.liveActivityRenewal?.stop();
+    this.apnsClient?.close();
     if (this.dbPool) {
       await this.dbPool.end();
     }
@@ -9213,7 +10080,6 @@ var StreamerServer = class {
       json(res, 400, { error: message });
       return;
     }
-    const { hostname: hostname2 } = __require("os");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     this.log.info(`[pair] token exchanged from ${ip} at ${ts}`, {
       event: "pair.token_exchanged",
@@ -9258,6 +10124,16 @@ var StreamerServer = class {
     });
     return { newKey, persisted };
   }
+  /**
+   * The registry ships with the values so a client renders the list from one
+   * round-trip, same as getClaudeFlagsConfig().
+   *
+   * Deliberately no `persisted` field: unlike claude-flags there is no PUT, and
+   * the absence of that field is the signal that this endpoint is read-only.
+   */
+  getFeatureFlagsConfig() {
+    return { registry: FEATURE_FLAGS, values: this.featureFlags };
+  }
   getClaudeFlagsConfig() {
     return {
       registry: CLAUDE_FLAGS,
@@ -10970,12 +11846,13 @@ var StreamerServer = class {
       BROWSE_SYSTEM_PROMPT(this.browseRoot),
       typeof clientPrompt === "string" ? clientPrompt : null
     ].filter(Boolean);
+    const includeSystemPrompt = provider !== CODEX_CLI_PROVIDER || this.codexSystemPromptEnabled;
     try {
       const session = await this.ptyManager.startFresh({
         provider,
         projectPath: resolvedPath,
         projectName: body.projectName,
-        systemPrompt: systemPromptParts.join("\n"),
+        ...includeSystemPrompt && { systemPrompt: systemPromptParts.join("\n") },
         permissionMode: this.defaultPermissionMode,
         claudeFlags: this.claudeFlags,
         claudeExtraArgs: this.claudeExtraArgs,