chore(run-ops): rename stale "ksuid" identifiers to runOpsId (no behavior change)

The run-ops NEW-store run id is a 26-char base32hex id, not a KSUID, so code
identifiers named "ksuid" were stale and misleading. Rename them to a consistent
runOpsId/run-ops family (vars, test constants, helpers, fixture strings) and
update comments/test descriptions to describe the current design. Also fixes 3
review findings in the touched test files: apiRunResultPresenter's newFriendlyId
helper now mints a valid 26-char NEW body (was 27-char, silently LEGACY),
lifecycleRouter's newRunId maps suffixes without the lossy outlier->"0" collision,
and triggerTask uses the static generateRunOpsId import.

Load-bearing wire values are untouched: the RUN_OPS_MINT_KSUID_ENABLED env var,
the runOpsMintKsuid feature-flag key, and the persisted "ksuid"/"cuid" enum
values. The one KSUID history note and the checksummed migration comment remain.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/env.server.ts

@@ -1727,8 +1727,8 @@ const EnvironmentSchema = z
     RUN_REPLICATION_LEGACY_ORIGIN_GENERATION: z.coerce.number().int().default(0),
     RUN_REPLICATION_NEW_ORIGIN_GENERATION: z.coerce.number().int().default(1),
 
-    // Run-ops KSUID mint cutover — per-env, canary-first, OFF by default.
-    // Even when on, an env mints KSUID only if its per-org runOpsMintKsuid flag is
+    // Run-ops id mint cutover — per-env, canary-first, OFF by default.
+    // Even when on, an env mints run-ops ids only if its per-org runOpsMintKsuid flag is
     // "ksuid" AND isSplitEnabled() is true. Cache mirrors REALTIME_BACKEND_FLAG_CACHE_*.
     RUN_OPS_MINT_KSUID_ENABLED: BoolEnv.default(false),
     RUN_OPS_MINT_FLAG_CACHE_TTL_MS: z.coerce.number().int().default(30_000),

apps/webapp/app/presenters/v3/ApiBatchResultsPresenter.server.ts

@@ -131,7 +131,7 @@ export class ApiBatchResultsPresenter extends BasePresenter {
   }
 
   // Split: resolve the batch row new-first then off the legacy READ REPLICA only (a batch id may
-  // be cuid or ksuid, and a cuid-shaped id can still have been backfilled onto NEW, so id-shape
+  // be cuid or run-ops id, and a cuid-shaped id can still have been backfilled onto NEW, so id-shape
   // residency is not authoritative for the row — the new-first-then-legacy probe is), then
   // hydrate every member run independently via the per-run read-through primitive.
   async #callSplit(

apps/webapp/app/presenters/v3/ApiWaitpointPresenter.server.ts

@@ -42,7 +42,7 @@ export class ApiWaitpointPresenter extends BasePresenter {
       // Public waitpoint retrieve. Split on: new run-ops client first, then the LEGACY
       // RUN-OPS READ REPLICA ONLY on a new-probe miss — never the legacy primary.
       // Split off (single-DB / self-host): one plain waitpoint.findFirst against the replica
-      // (passthrough). The waitpointId is the residency-classifiable KSUID id (the route
+      // (passthrough). The waitpointId is the residency-classifiable run-ops id (the route
       // pre-decodes the friendlyId via WaitpointId.toId).
       const hydrate = (client: PrismaReplicaClient) =>
         client.waitpoint.findFirst({

apps/webapp/app/presenters/v3/BatchListPresenter.server.ts

@@ -101,7 +101,7 @@ export class BatchListPresenter extends BasePresenter {
       }
     }
 
-    // codepoint comparator (NEVER localeCompare): BatchTaskRun.id is ASCII (cuid or ksuid).
+    // codepoint comparator (NEVER localeCompare): BatchTaskRun.id is ASCII (cuid or run-ops id).
     const sign = direction === "forward" ? 1 : -1; // forward => DESC; backward => ASC
     return Array.from(byId.values())
       .sort((a, b) => (a.id < b.id ? sign : a.id > b.id ? -sign : 0))

apps/webapp/app/presenters/v3/BatchPresenter.server.ts

@@ -79,7 +79,7 @@ export class BatchPresenter extends BasePresenter {
     const batchResult = await readThrough<BatchRow>({
       // The read-through key; here it is the batch friendlyId. A cuid-shaped batch friendlyId
       // classifies as LEGACY and the read-through probes both stores (new first, then legacy
-      // replica); a ksuid-shaped one (cut-over orgs) classifies as NEW and reads only the new
+      // replica); a run-ops-shaped one (cut-over orgs) classifies as NEW and reads only the new
       // store — either way the row is found on the DB that owns it.
       runId: batchId,
       environmentId,

apps/webapp/app/routes/api.v1.runs.$runFriendlyId.input-streams.wait.ts

@@ -78,7 +78,7 @@ const { action, loader } = createActionApiRoute(
         }
       }
 
-      // Create the waitpoint. Co-locate it with the owning run (run-ops split) so a ksuid
+      // Create the waitpoint. Co-locate it with the owning run (run-ops split) so a run-ops id
       // run's input-stream waitpoint lands on the run's DB and its block edge resolves.
       const result = await engine.createManualWaitpoint({
         runId: run.id,

apps/webapp/app/routes/api.v1.runs.$runFriendlyId.session-streams.wait.ts

@@ -99,7 +99,7 @@ const { action, loader } = createActionApiRoute(
         }
       }
 
-      // Create the waitpoint. Co-locate it with the owning run (run-ops split) so a ksuid
+      // Create the waitpoint. Co-locate it with the owning run (run-ops split) so a run-ops id
       // run's session-stream waitpoint lands on the run's DB and its block edge resolves.
       const result = await engine.createManualWaitpoint({
         runId: run.id,

apps/webapp/app/routes/engine.v1.runs.$runFriendlyId.wait.duration.ts

@@ -42,7 +42,7 @@ const { action } = createActionApiRoute(
         : undefined;
 
       const { waitpoint } = await engine.createDateTimeWaitpoint({
-        // Co-locate the waitpoint with the run that blocks on it (run-ops split): a ksuid run lives
+        // Co-locate the waitpoint with the run that blocks on it (run-ops split): a run-ops run lives
         // on the dedicated DB, but the minted waitpoint id is always a cuid, so without the run id
         // the waitpoint would route to the control-plane DB and the block edge would never resolve.
         runId: run.id,

apps/webapp/app/runEngine/concerns/idempotencyResidency.server.test.ts

@@ -38,7 +38,7 @@ describe("resolveIdempotencyDedupClient", () => {
     expect(client).toBe(FALLBACK);
   });
 
-  it("routes a root run to the NEW client when the env mints ksuid", async () => {
+  it("routes a root run to the NEW client when the env mints run-ops ids", async () => {
     const client = await resolveIdempotencyDedupClient(
       { environmentForMint: env, parentRunFriendlyId: undefined },
       makeDeps({ resolveMintKind: async () => "ksuid" })
@@ -54,10 +54,10 @@ describe("resolveIdempotencyDedupClient", () => {
     expect(client).toBe(LEGACY_CLIENT);
   });
 
-  it("routes a child to the NEW client when the ksuid parent is NEW-resident", async () => {
-    const ksuidParent = RunId.toFriendlyId("a".repeat(24) + "01");
+  it("routes a child to the NEW client when the run-ops parent is NEW-resident", async () => {
+    const runOpsParent = RunId.toFriendlyId("a".repeat(24) + "01");
     const client = await resolveIdempotencyDedupClient(
-      { environmentForMint: env, parentRunFriendlyId: ksuidParent },
+      { environmentForMint: env, parentRunFriendlyId: runOpsParent },
       makeDeps({ resolveMintKind: async () => "cuid" }) // mint flag must NOT win for a child
     );
     expect(client).toBe(NEW_CLIENT);

apps/webapp/app/runEngine/services/streamBatchItems.server.ts

@@ -129,7 +129,7 @@ export class StreamBatchItemsService extends WithRunEngine {
         const batchId = this.parseBatchFriendlyId(batchFriendlyId);
 
         // Validate batch exists and belongs to this environment. Routed by batch id so a
-        // ksuid (NEW-resident) batch is found on the owning DB; the env-ownership check that
+        // run-ops id (NEW-resident) batch is found on the owning DB; the env-ownership check that
         // was in the where clause is enforced app-side below.
         const batch = await this._engine.runStore.findBatchTaskRunById(batchId);