docs(mollifier): strip internal planning labels from comments

Remove plan-tracking shorthand (Q#, C#, F#, Phase N, _plans/) from trigger-layer mollifier comments and test names; reword to plain English. Comment/test-name only; no behaviour change.

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

Author: d-cs

apps/webapp/app/runEngine/concerns/idempotencyKeys.server.ts

@@ -46,7 +46,7 @@ export class IdempotencyKeyConcern {
     private readonly traceEventConcern: TraceEventConcern
   ) {}
 
-  // Q5 buffer-side dedup. Resolves an idempotency key against the
+  // Buffer-side idempotency dedup. Resolves an idempotency key against the
   // mollifier buffer when PG missed. Returns a SyntheticRun cast to
   // TaskRun so the route handler (which only reads run.id / run.friendlyId)
   // can echo the buffered run's friendlyId as a cached hit. Returns null
@@ -114,7 +114,7 @@ export class IdempotencyKeyConcern {
         })
       : undefined;
 
-    // Buffer fallback per Q5 mollifier-idempotency design. PG missed —
+    // Buffer fallback per the mollifier-idempotency design. PG missed —
     // the same key may belong to a buffered run that hasn't materialised
     // yet. Skipped when `resumeParentOnCompletion` is set: blocking a
     // parent on a buffered child via waitpoint requires a PG row that
@@ -222,9 +222,8 @@ export class IdempotencyKeyConcern {
       return { isCached: true, run: existingRun };
     }
 
-    // Pre-gate claim — closes the PG+buffer race during gate transition
-    // (see _plans/2026-05-21-mollifier-idempotency-claim.md). All
-    // same-key triggers serialise here before evaluateGate decides
+    // Pre-gate claim — closes the PG+buffer race during gate transition.
+    // All same-key triggers serialise here before evaluateGate decides
     // PG-pass-through vs mollify. Skipped for triggerAndWait
     // (resumeParentOnCompletion) — that path bypasses the gate via F4
     // and its existing PG-side dedup is sufficient.

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

@@ -269,8 +269,7 @@ export class RunEngineTriggerTaskService {
       // resolve it — publish on success so waiters see our runId,
       // release on error so the next claimant can retry. Stored in an
       // outer scope so the try/catch at the bottom of `callV2` can act
-      // on whichever return path or throw the pipeline takes. Plan doc:
-      // _plans/2026-05-21-mollifier-idempotency-claim.md
+      // on whichever return path or throw the pipeline takes.
       idempotencyClaim = claimResult;
 
       if (idempotencyKey) {
@@ -471,7 +470,7 @@ export class RunEngineTriggerTaskService {
                   decision: mollifierOutcome.decision,
                   buffer: mollifierBuffer,
                   // Idempotency-key triple wires the buffer's SETNX into
-                  // the trigger-time dedup symmetric with PG (Q5).
+                  // the trigger-time dedup symmetric with PG.
                   idempotencyKey,
                   taskIdentifier: taskId,
                 });
@@ -539,8 +538,8 @@ export class RunEngineTriggerTaskService {
                 // onDebounced is a closure over webapp state (triggerRequest +
                 // traceEventConcern) and can't be serialised into the mollifier
                 // snapshot. The pass-through path attaches it here; the drainer
-                // path replays without it. C1/F4 gate bypasses ensure debounce
-                // and triggerAndWait never reach the mollify branch.
+                // path replays without it. The debounce and triggerAndWait gate
+                // bypasses ensure neither reaches the mollify branch.
                 onDebounced:
                   body.options?.debounce && body.options?.resumeParentOnCompletion
                     ? async ({ existingRun, waitpoint, debounceKey }) => {
@@ -643,7 +642,7 @@ export class RunEngineTriggerTaskService {
   }
 
   // Build the engine.trigger() input object from the values gathered during
-  // this.call(). Extracted so the mollify path (Phase 2) can construct the
+  // this.call(). Extracted so the mollify path can construct the
   // same input shape without re-entering the trace-run span. The pass-through
   // path spreads this result and attaches `onDebounced` inline; the mollify
   // path serialises it into the buffer for drainer replay.

apps/webapp/app/v3/mollifier/mollifierGate.server.ts

@@ -46,7 +46,8 @@ export type GateInputs = {
   // the pattern used by `canAccessAi`, `canAccessPrivateConnections`, and the
   // compute-template beta gate.
   orgFeatureFlags: Record<string, unknown> | null;
-  // Trigger options that drive C1/C3/F4 bypasses. The mollify path can't
+  // Trigger options that drive the debounce / OTU / triggerAndWait
+  // bypasses. The mollify path can't
   // serialise stateful callbacks (debounce), can't safely break OTU's
   // synchronous-rejection contract, and shouldn't intercept single
   // triggerAndWait (batchTriggerAndWait still funnels through per item).
@@ -151,25 +152,23 @@ export async function evaluateGate(
 ): Promise<GateOutcome> {
   const d = { ...defaultGateDependencies, ...deps };
 
-  // C1 — debounce bypass. onDebounced is a closure over webapp state and
+  // Debounce bypass. onDebounced is a closure over webapp state and
   // can't be snapshotted into the buffer for drainer replay. Skip before the
   // trip evaluator so debounce traffic is never counted against the rate.
   if (inputs.options?.debounce) {
     d.recordDecision("pass_through");
     return { action: "pass_through" };
   }
-  // C3 — OneTimeUseToken bypass. OTU is a security feature on the PUBLIC_JWT
+  // OneTimeUseToken bypass. OTU is a security feature on the PUBLIC_JWT
   // auth path; its synchronous-rejection contract is materially worse to
-  // break than the idempotency-key contract. Sibling brief:
-  // `_plans/2026-05-13-mollifier-otu-protection.md`.
+  // break than the idempotency-key contract.
   if (inputs.options?.oneTimeUseToken) {
     d.recordDecision("pass_through");
     return { action: "pass_through" };
   }
-  // F4 — single triggerAndWait bypass. batchTriggerAndWait still funnels
+  // Single triggerAndWait bypass. batchTriggerAndWait still funnels
   // through TriggerTaskService.call per item so the dominant burst pattern
-  // remains covered. Sibling brief:
-  // `_plans/2026-05-13-mollifier-trigger-and-wait-protection.md`.
+  // remains covered.
   if (inputs.options?.parentTaskRunId && inputs.options?.resumeParentOnCompletion) {
     d.recordDecision("pass_through");
     return { action: "pass_through" };

apps/webapp/app/v3/mollifier/mollifierMollify.server.ts

@@ -12,7 +12,7 @@ export type MollifyNotice = {
 export type MollifySyntheticResult = {
   // `id` is the canonical TaskRun primary key derived from `friendlyId`
   // via `RunId.fromFriendlyId`. Downstream consumers in the trigger
-  // route — notably `saveRequestIdempotency` (Q3) — index the request-
+  // route — notably `saveRequestIdempotency` — index the request-
   // idempotency cache by this id; without it the cache stores
   // `undefined` and Prisma's `findFirst({ where: { id: undefined } })`
   // on retry strips the predicate and returns an arbitrary TaskRun
@@ -25,7 +25,7 @@ export type MollifySyntheticResult = {
   // run-detail page with no span selected (parity gap with PG runs).
   run: { id: string; friendlyId: string; spanId: string };
   error: undefined;
-  // The race-loser path (Q5): if accept's SETNX hit an existing
+  // The race-loser path: if accept's SETNX hit an existing
   // buffered run with the same (env, task, idempotencyKey), the
   // response echoes the winner's runId with isCached=true. The
   // mollifier-queued notice is only attached for the happy accept.
@@ -49,7 +49,7 @@ export async function mollifyTrigger(args: {
   buffer: MollifierBuffer;
   // Optional idempotency context. When both are passed, accept SETNXes
   // the lookup so the buffered window participates in trigger-time
-  // dedup symmetrically with PG (Q5).
+  // dedup symmetrically with PG.
   idempotencyKey?: string;
   taskIdentifier?: string;
 }): Promise<MollifySyntheticResult> {

apps/webapp/test/engine/triggerTask.test.ts

@@ -1285,7 +1285,7 @@ describe("RunEngineTriggerTaskService", () => {
   containerTest(
     "mollifier · mollify action writes to buffer and returns synthetic result (no Postgres row)",
     async ({ prisma, redisOptions }) => {
-      // Phase 3 semantics: when the gate decides mollify, the call site
+      // When the gate decides mollify, the call site
       // invokes `mollifyTrigger` which writes the engine.trigger snapshot
       // to the buffer and returns a synthesised `MollifySyntheticResult`
       // (run.friendlyId + notice + isCached:false). `engine.trigger` is

apps/webapp/test/mollifierGate.test.ts

@@ -433,11 +433,10 @@ describe("evaluateGate — per-org isolation via Organization.featureFlags", ()
   });
 });
 
-// C1/C3/F4 bypasses: the three categories of trigger that the mollifier never
+// Bypasses: the three categories of trigger that the mollifier never
 // intercepts, regardless of the per-org flag or the trip-evaluator decision.
-// Documented in `_plans/2026-05-13-mollifier-{debounce,otu,trigger-and-wait}-protection.md`.
-describe("evaluateGate — C1/C3/F4 bypasses", () => {
-  it("C1: debounce triggers pass through without invoking the evaluator", async () => {
+describe("evaluateGate — debounce / OTU / triggerAndWait bypasses", () => {
+  it("debounce triggers pass through without invoking the evaluator", async () => {
     const { deps, spies } = makeDeps({
       enabled: true,
       shadow: false,
@@ -452,7 +451,7 @@ describe("evaluateGate — C1/C3/F4 bypasses", () => {
     expect(spies.evaluatorCalls).toBe(0);
   });
 
-  it("C3: oneTimeUseToken triggers pass through without invoking the evaluator", async () => {
+  it("oneTimeUseToken triggers pass through without invoking the evaluator", async () => {
     const { deps, spies } = makeDeps({
       enabled: true,
       shadow: false,
@@ -467,7 +466,7 @@ describe("evaluateGate — C1/C3/F4 bypasses", () => {
     expect(spies.evaluatorCalls).toBe(0);
   });
 
-  it("F4: single triggerAndWait (parentTaskRunId + resumeParentOnCompletion) passes through", async () => {
+  it("single triggerAndWait (parentTaskRunId + resumeParentOnCompletion) passes through", async () => {
     const { deps, spies } = makeDeps({
       enabled: true,
       shadow: false,
@@ -485,7 +484,7 @@ describe("evaluateGate — C1/C3/F4 bypasses", () => {
     expect(spies.evaluatorCalls).toBe(0);
   });
 
-  it("parentTaskRunId alone (no resumeParentOnCompletion) does NOT bypass — must be both for F4", async () => {
+  it("parentTaskRunId alone (no resumeParentOnCompletion) does NOT bypass — must be both", async () => {
     const { deps, spies } = makeDeps({
       enabled: true,
       shadow: false,