@@ -52,20 +52,12 @@ HUB_DATA_DIR=./tmp/hub-data
 # TRIAGE_RECONCILE_INTERVAL_MS=
 # Milliseconds before a pass that could not reach a listener tries again, doubling to two minutes. Default 15000.
 # TRIAGE_RECONCILE_RETRY_MS=
-# Milliseconds a listener waits for a just-deployed manager to reach a sidecar before it gives up on it. Default 120000.
-# TRIAGE_MANAGER_READY_MS=
-# Milliseconds a just-deployed manager may have no sidecar and still hold its pull request. Default 120000.
-# TRIAGE_MANAGER_START_GRACE_MS=
-# Milliseconds a manager waiting on CI or a reviewer waits between checks. Default 30000.
-# TRIAGE_MANAGER_POLL_MS=
-# Milliseconds between a listener's checks on whether its manager reached a sidecar. Default 2000.
-# TRIAGE_WAKE_POLL_MS=
 
 # Pull request heads the reconciler lets a tenant have queued or running at once. Default 5.
 # TRIAGE_MAX_IN_FLIGHT=
 # Milliseconds after a head is capped by runs that never started before it gets a fresh set of attempts. Default 21600000.
 # TRIAGE_CAPPED_RETRY_MS=
-# Milliseconds without a new webhook event before a pull request's events go out as one triage run; at most four times this after the first. Default 30000.
+# Milliseconds without a new webhook event before a pull request's events go out as one triage run; at most four times this after the first, which must stay under HUB_MAIL_HOLD_TTL_MS. Default 30000.
 # TRIAGE_COALESCE_QUIET_MS=
 # Milliseconds a pull request may wait for Triage to start before the hub logs triage_stalled, shows it in the portal and emails the workspace's owners and admins. Default 300000.
 # TRIAGE_STALLED_AFTER_MS=
@@ -75,6 +67,8 @@ HUB_DATA_DIR=./tmp/hub-data
 # Interchange settings. Unset keeps the default shown: Interchange's stock default, except
 # HUB_MAIL_HOLD_TTL_MS, HUB_MAIL_ACK_RETRY_INTERVAL_MS and HUB_MAIL_ACK_MAX_RETRIES,
 # which the hub raises so routed triage mail survives a long pack receive.
+# HUB_MAIL_HOLD_TTL_MS is also how long a just-deployed manager that has not come up keeps
+# its pull request, and how long a queued head may wait to start before it is asked again.
 # Durations are whole numbers ending in s, m, h or d; the max lifetime and max disconnected
 # must be above zero.
 # HUB_MAX_TARBALL_BYTES=10485760
 
@@ -92,7 +92,7 @@ jobs:
       matrix:
         include:
           - shard: 1/5
-            files: tests/chain/unwoken.test.ts
+            files: tests/chain/unstarted.test.ts
           - shard: 2/5
             files: tests/chain/woken.test.ts tests/chain/local-sidecars.test.ts tests/chain/deterministic.test.ts tests/chain/unset.test.ts
           - shard: 3/5
 
@@ -6,6 +6,7 @@ import { LifecycleDuration, lifecycleDurationMs, type ResolvedWorkflowLifecycleP
 import { DEFAULT_GITHUB_API_ORIGIN } from "./github/github-app-credential-adapter.js";
 import type { CoalesceWindow } from "./github/coalescer.js";
 import { DEFAULT_RECONCILE_POLICY, type ReconcilePolicy } from "./github/reconcile-plan.js";
+import { DEFAULT_MAIL_HOLD_MS } from "./timings.js";
 
 const secret = type("string").narrow((value, ctx) =>
   /^[0-9a-fA-F]{64}$/.test(value) || ctx.mustBe("32 bytes encoded as 64 hexadecimal characters"));
@@ -73,10 +74,6 @@ const HubEnvSchema = type({
   "RAILWAY_GIT_REPO_OWNER?": "string",
   "RAILWAY_GIT_REPO_NAME?": "string",
   "RAILWAY_ENVIRONMENT_ID?": "string",
-  "TRIAGE_MANAGER_READY_MS?": positiveInteger,
-  "TRIAGE_MANAGER_START_GRACE_MS?": positiveInteger,
-  "TRIAGE_MANAGER_POLL_MS?": positiveInteger,
-  "TRIAGE_WAKE_POLL_MS?": positiveInteger,
   "TRIAGE_RECONCILE_INTERVAL_MS?": positiveInteger,
   "TRIAGE_RECONCILE_RETRY_MS?": positiveInteger,
   "TRIAGE_COALESCE_QUIET_MS?": positiveInteger,
@@ -274,9 +271,11 @@ export function migrationEnv(db: DatabaseConfig): Record<string, string> {
 }
 
 /** Heads the reconciler lets a tenant have queued or running at once. */
-export function triageReconcilePolicy(env: Pick<HubEnv, "TRIAGE_MAX_IN_FLIGHT" | "TRIAGE_CAPPED_RETRY_MS">): ReconcilePolicy {
+/** A queued head counts as never started once stock's mail hold has dropped its manager's wake, `mailHoldMs`. */
+export function triageReconcilePolicy(env: Pick<HubEnv, "TRIAGE_MAX_IN_FLIGHT" | "TRIAGE_CAPPED_RETRY_MS">, mailHoldMs: number): ReconcilePolicy {
   return {
     ...DEFAULT_RECONCILE_POLICY,
+    unstartedAfterMs: mailHoldMs,
     maxInFlight: numberOr(env.TRIAGE_MAX_IN_FLIGHT, DEFAULT_RECONCILE_POLICY.maxInFlight),
     cappedRetryAfterMs: numberOr(env.TRIAGE_CAPPED_RETRY_MS, DEFAULT_RECONCILE_POLICY.cappedRetryAfterMs),
   };
@@ -386,9 +385,10 @@ export function interchangeSettings(env: HubEnv): InterchangeSettings {
     ...(env.HUB_API_ORIGIN !== undefined && { hubApiOrigin: env.HUB_API_ORIGIN }),
     // Triage mail is routed, not dispatched, so only the router's ack retries keep it alive. A
     // pack receive holds the connection queue for minutes and the stock 5 x 10 s give-up drops it.
+    // The mail hold is the hub's start grace for a just-deployed manager too, and how long a queued head may wait to start.
     sidecarLink: {
       ...(env.HUB_SIDECAR_REQUEST_TIMEOUT_MS !== undefined && { requestTimeoutMs: Number(env.HUB_SIDECAR_REQUEST_TIMEOUT_MS) }),
-      mailHoldTTLMs: numberOr(env.HUB_MAIL_HOLD_TTL_MS, 15 * 60_000),
+      mailHoldTTLMs: numberOr(env.HUB_MAIL_HOLD_TTL_MS, DEFAULT_MAIL_HOLD_MS),
       mailAckRetryIntervalMs: numberOr(env.HUB_MAIL_ACK_RETRY_INTERVAL_MS, 30_000),
       mailAckMaxRetries: numberOr(env.HUB_MAIL_ACK_MAX_RETRIES, 10),
     },
 
@@ -5,6 +5,8 @@ import { DEFAULT_RECONCILE_POLICY, planTenant, pullKey, requeue, runKey, type Ob
 const MINUTE = 60_000;
 const T0 = new Date("2026-10-07T00:00:00.000Z");
 const policy = DEFAULT_RECONCILE_POLICY;
+/** Minutes a queued head may wait to start. */
+const UNSTARTED = policy.unstartedAfterMs / MINUTE;
 
 function at(minutes: number): Date {
   return new Date(T0.getTime() + minutes * MINUTE);
@@ -77,8 +79,8 @@ describe("reconcile plan", () => {
 
   test("a queued mail lost before any run started is queued again", () => {
     const queued = plan([pr(1)], [], at(0)).rows;
-    expect(enqueued(plan([pr(1)], queued, at(9)))).toEqual([]);
-    expect(enqueued(plan([pr(1)], queued, at(11)))).toEqual([1]);
+    expect(enqueued(plan([pr(1)], queued, at(UNSTARTED - 1)))).toEqual([]);
+    expect(enqueued(plan([pr(1)], queued, at(UNSTARTED + 1)))).toEqual([1]);
   });
 
   test("failed runs retry with backoff and stop at the attempt cap", () => {
@@ -160,7 +162,7 @@ describe("reconcile plan", () => {
     const queued = plan([pr(1)], [], at(0)).rows;
     const result = plan([pr(1)], queued, at(3), [[pr(1), [{ ...run("run_a", "failed", 0), startedAt: at(-0.5).toISOString() }]]]);
     expect(status(result, 1)).toMatchObject({ status: "failed", runId: "run_a", attempts: 1, error: "run failed" });
-    const before = plan([pr(1)], queued, at(11), [[pr(1), [run("run_old", "failed", -5)]]]);
+    const before = plan([pr(1)], queued, at(UNSTARTED + 1), [[pr(1), [run("run_old", "failed", -5)]]]);
     expect(status(before, 1)).toMatchObject({ status: "queued", attempts: 2 });
   });
 
@@ -295,8 +297,8 @@ describe("a head whose manager was refused for capacity", () => {
     const placed = plan([pr(1)], waiting, at(31));
     expect(enqueued(placed)).toEqual([]);
     expect(status(placed, 1)).toEqual(expect.not.objectContaining({ error: expect.anything() }));
-    expect(status(plan([pr(1)], placed.rows, at(41)), 1)).toMatchObject({ status: "queued", attempts: 1 });
-    expect(status(plan([pr(1)], placed.rows, at(42)), 1)).toMatchObject({ status: "queued", attempts: 2 });
+    expect(status(plan([pr(1)], placed.rows, at(31 + UNSTARTED)), 1)).toMatchObject({ status: "queued", attempts: 1 });
+    expect(status(plan([pr(1)], placed.rows, at(32 + UNSTARTED)), 1)).toMatchObject({ status: "queued", attempts: 2 });
   });
 });
 
 
@@ -2,6 +2,7 @@
 // requests to queue again. Pure, so every recovery path is decided in one place.
 import { PR_TRIAGE_STUCK_RUN_MS, WAITING_FOR_CAPACITY, type AwaitedStage, type PrTriageRow, type RepoSource } from "@corbits/triage-contracts";
 import { MODEL_NOT_ASKED } from "@corbits/triage-workflows/logic/settled";
+import { DEFAULT_MAIL_HOLD_MS } from "../timings.js";
 
 /** `labels` only where the host lists them. */
 export type OpenPr = { number: number; headSha: string; updatedAt: string; draft: boolean; labels?: string[] };
@@ -53,7 +54,7 @@ const MINUTE = 60_000;
 
 export const DEFAULT_RECONCILE_POLICY: ReconcilePolicy = {
   webhookGraceMs: 2 * MINUTE,
-  unstartedAfterMs: 10 * MINUTE,
+  unstartedAfterMs: DEFAULT_MAIL_HOLD_MS,
   stuckAfterMs: PR_TRIAGE_STUCK_RUN_MS,
   clockSkewMs: MINUTE,
   backoffBaseMs: 5 * MINUTE,
 
@@ -5,6 +5,7 @@ import type { CheckRun } from "@corbits/github-reads";
 import { unsettledBy } from "@corbits/triage-workflows/logic/settled";
 import { DEFAULT_RECONCILE_POLICY, planTenant, runKey, type ObservedRun, type OpenPr } from "./reconcile-plan.js";
 import { triageReconcilePolicy } from "../env.js";
+import { DEFAULT_MAIL_HOLD_MS } from "../timings.js";
 import { TriageStateConflictError, type TriageStateStore } from "./triage-state-store.js";
 import { ListenerUnroutedError, type LiveDeployment } from "./deployment.js";
 import type { HostedVerdict } from "./verdict-record-store.js";
@@ -154,7 +155,7 @@ function harness(runs: Runs | (() => Runs), prs: OpenPr[] | Record<string, OpenP
       delivered.push({ payload: payload as Record<string, unknown> });
     },
     unroutedTries,
-    policy: triageReconcilePolicy({ ...(options.maxInFlight !== undefined && { TRIAGE_MAX_IN_FLIGHT: options.maxInFlight }) }),
+    policy: triageReconcilePolicy({ ...(options.maxInFlight !== undefined && { TRIAGE_MAX_IN_FLIGHT: options.maxInFlight }) }, DEFAULT_MAIL_HOLD_MS),
     now,
     log: (entry) => logged.push(entry),
   });
 
@@ -12,7 +12,8 @@
 //   the hub, so an ended run's sidecar has nothing left to keep. `sidecarLink`
 //   is spread into createSidecarRouter with longer mail hold and ack retries
 //   than the router's defaults: triage mail is routed, not dispatched, so only
-//   those retries keep it alive while a pack receive holds the connection.
+//   those retries keep it alive while a pack receive holds the connection. The
+//   hub's start grace for a just-deployed manager is that same mail hold.
 // - `adapterManifest` replaces stock's `sidecarAdapterManifest` and has no
 //   SIDECAR_ADAPTER_MANIFEST fallback: the hub's adapters are fixed in
 //   sidecar-config.ts, not operator configuration.
 
@@ -10,6 +10,7 @@ import { createPauseGate } from "./github/pr-workflow.js";
 import { createManagerIntake, createManagerWake, createOverdueWake, createSupersede } from "./manager-intake.js";
 import { ListenerUnroutedError, RunUnavailableError } from "./github/deployment.js";
 import { recordEvent } from "./manager-state.js";
+import { timings } from "./timings.js";
 import { migrateTriageTables } from "./triage-db.js";
 
 const TEST_DB = { host: "localhost", port: 5432, user: "postgres", password: "postgres", database: "interchange" };
@@ -282,7 +283,7 @@ test("PostgreSQL: the reconcile pass wakes a manager for a pull request whose re
     expect(logged).toEqual([{ level: "info", msg: "manager_woken_overdue", tenantId: TENANT, source: "github", repo: RECORD.name, number: 7, head: "h1" }]);
 
     // A manager the wake started took the claim and went away before done; past the start grace the next pass wakes again.
-    const earlier = new Date(Date.now() - 3 * 60_000);
+    const earlier = new Date(Date.now() - timings().mailHoldMs - 60_000);
     await db.execute(sql`UPDATE corbits_triage.manager_state SET state = state || ${JSON.stringify({ overdueWokenAt: earlier.toISOString(), deployAskedAt: earlier.toISOString(), claimedAt: new Date(earlier.getTime() + 1_000).toISOString() })}::jsonb WHERE key = ${`mgr:github:${RECORD.name}#7`}`);
     await wakeOverdue(TENANT);
     expect(mailed).toEqual([woken, woken]);
@@ -332,7 +333,7 @@ test("PostgreSQL: an overdue wake is recorded only once it succeeded, and one pu
 
 test("PostgreSQL: a manager deployed without a sidecar past the startup window is not mailed, and the listener is", async () => {
   await withDatabase(async function stuck(db) {
-    await claimManager(db, "run_stuck", 7, "deployed", new Date(Date.now() - 3 * 60_000));
+    await claimManager(db, "run_stuck", 7, "deployed", new Date(Date.now() - timings().mailHoldMs - 60_000));
     const { toListener, mailed } = stack(db, LISTENER);
     expect(await toListener(TENANT, requeued(7, "h1"))).toBe(true);
     expect(mailed).toEqual([{ address: LISTENER, payload: { kind: "pr", repo: RECORD.name, tenantId: TENANT, items: [{ prNumber: 7, headSha: "h1" }] } }]);
 
@@ -16,6 +16,7 @@ import { MAX_BODY_BYTES } from "./read-json.js";
 import { askDeploy, managedPulls, passRequest, recordEvent, recordRefused, type PullRequestRef } from "./manager-state.js";
 import { createVerdictRecordStore } from "./github/verdict-record-store.js";
 import { mountTenantRoutes } from "./tenant-routes.js";
+import { timings } from "./timings.js";
 import { migrateTriageTables } from "./triage-db.js";
 
 const TEST_DB = { host: "localhost", port: 5432, user: "postgres", password: "postgres", database: "interchange" };
@@ -243,7 +244,7 @@ test("PostgreSQL: a result whose wake fails stays recorded with nothing else, th
     const wakeOverdue = createOverdueWake({ db, wake: waker(woken), log });
     await wakeOverdue(TENANT);
     expect(woken).toEqual([]);
-    const earlier = new Date(Date.now() - 2 * 60_000 - 1_000).toISOString();
+    const earlier = new Date(Date.now() - timings().mailHoldMs - 1_000).toISOString();
     await db.execute(sql`UPDATE corbits_triage.manager_state SET state = jsonb_set(state, '{receivedAt}', to_jsonb(${earlier}::text)) WHERE key LIKE '%:run_reviewer'`);
     await wakeOverdue(TENANT);
     expect(woken).toEqual([{ tenantId: TENANT, pr: GITHUB, head: "h1" }]);
 
@@ -5,6 +5,7 @@ import { sql } from "drizzle-orm";
 import { createDB, runMigrations, schema } from "@intx/db";
 import type { Tx } from "./github/admin-github-grant.js";
 import { done, endNeverRan, liveListener, liveManager, notePlaced, recordEvent, recordResult, take, type PullRequestRef } from "./manager-state.js";
+import { timings } from "./timings.js";
 import { migrateTriageTables } from "./triage-db.js";
 
 const TEST_DB = { host: "localhost", port: 5432, user: "postgres", password: "postgres", database: "interchange" };
@@ -402,7 +403,7 @@ async function claimRun(db: Db, runId: string): Promise<void> {
 test("PostgreSQL: a manager deployed without a sidecar past the startup window does not hold the pull request", async () => {
   await withDatabase(async function stuck(db) {
     await recordEvent(db, TENANT, GITHUB, "d1", webhook("h1"));
-    await deployedRun(db, "run_stuck", new Date(Date.now() - 3 * MINUTE));
+    await deployedRun(db, "run_stuck", new Date(Date.now() - timings().mailHoldMs - MINUTE));
     await claimRun(db, "run_stuck");
     await liveRun(db, "run_next");
     expect(await take(db, TENANT, GITHUB, "run_next")).toMatchObject({ outcome: "pass", pass: { head: "h1" } });
@@ -422,7 +423,7 @@ test("PostgreSQL: a manager deployed inside the startup window, or one with a si
     await liveRun(db, "run_next");
     expect(await take(db, TENANT, GITHUB, "run_next")).toEqual({ outcome: "refused" });
 
-    await db.update(schema.workflowRun).set({ createdAt: new Date(Date.now() - 3 * MINUTE) }).where(sql`${schema.workflowRun.id} = 'run_fresh'`);
+    await db.update(schema.workflowRun).set({ createdAt: new Date(Date.now() - timings().mailHoldMs - MINUTE) }).where(sql`${schema.workflowRun.id} = 'run_fresh'`);
     await db.insert(schema.sidecar).values({
       id: "sdc_up",
       tokenHashSha256: new Uint8Array(32).fill(7),
@@ -453,7 +454,7 @@ test("PostgreSQL: a manager being cancelled is mailed nothing and takes nothing,
   await withDatabase(async function cancelling(db) {
     await recordEvent(db, TENANT, GITHUB, "d1", webhook("h1"));
     await startManager(db, GITHUB, "run_cancelling");
-    await db.update(schema.workflowRun).set({ cancellationRequestedAt: new Date(), cancellationDeadline: new Date(), cancellationReason: "unwoken" }).where(sql`${schema.workflowRun.id} = 'run_cancelling'`);
+    await db.update(schema.workflowRun).set({ cancellationRequestedAt: new Date(), cancellationDeadline: new Date(), cancellationReason: "stopped" }).where(sql`${schema.workflowRun.id} = 'run_cancelling'`);
     await liveRun(db, "run_next");
     expect(await liveManager(db, TENANT, GITHUB)).toBeUndefined();
     expect(await take(db, TENANT, GITHUB, "run_cancelling")).toEqual({ outcome: "refused" });
@@ -469,14 +470,14 @@ async function allocate(db: Db, runId: string, fields: { status: "allocated"; si
   await db.insert(schema.sidecarAllocation).values({ id: `alc_${runId}`, anchorRunId: runId, tenantId: TENANT, provisionerId: "local-process", provisionerApiVersion: 2, provisionerBindingFingerprint: "fp", adapterManifestDigest: "digest", maxDisconnectedMs: 60_000, ...fields });
 }
 
-test("PostgreSQL: a manager on its sidecar five minutes without running gives up the pull request, and the reaper ends it but never the listener", async () => {
+test("PostgreSQL: a manager on its sidecar past the mail hold without running gives up the pull request, and the reaper ends it but never the listener", async () => {
   await withDatabase(async function neverRan(db) {
     await db.insert(schema.workflowDefinition).values({ id: "wfd_listener", tenantId: TENANT, name: "triage-listener-github" });
     await db.insert(schema.workflowRun).values({ id: "run_listener", anchorRunId: "run_listener", definitionId: "wfd_listener", tenantId: TENANT, status: "deployed", createdAt: new Date(Date.now() - 60 * MINUTE) });
     await allocate(db, "run_listener", { status: "allocated", sidecarId: "sdc_local" });
-    await deployedRun(db, "run_quiet", new Date(Date.now() - 6 * MINUTE));
+    await deployedRun(db, "run_quiet", new Date(Date.now() - timings().mailHoldMs - MINUTE));
     await allocate(db, "run_quiet", { status: "allocated", sidecarId: "sdc_local" });
-    notePlaced({ allocationId: "alc_run_quiet", generation: 0 }, new Date(Date.now() - 6 * MINUTE));
+    notePlaced({ allocationId: "alc_run_quiet", generation: 0 }, new Date(Date.now() - timings().mailHoldMs - MINUTE));
     await claimRun(db, "run_quiet");
     const cancelled: string[][] = [];
     const logs: Record<string, unknown>[] = [];
@@ -491,9 +492,9 @@ test("PostgreSQL: a manager on its sidecar five minutes without running gives up
   });
 }, 120_000);
 
-test("PostgreSQL: a manager that waited past five minutes for a slot is timed from its placement, not its deploy", async () => {
+test("PostgreSQL: a manager that waited past the mail hold for a slot is timed from its placement, not its deploy", async () => {
   await withDatabase(async function placedLate(db) {
-    await deployedRun(db, "run_late", new Date(Date.now() - 10 * MINUTE));
+    await deployedRun(db, "run_late", new Date(Date.now() - timings().mailHoldMs - 5 * MINUTE));
     await allocate(db, "run_late", { status: "allocated", sidecarId: "sdc_local" });
     notePlaced({ allocationId: "alc_run_late", generation: 0 }, new Date(Date.now() - MINUTE));
     await claimRun(db, "run_late");