@@ -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 plus TRIAGE_RECONCILE_INTERVAL_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; a queued head may wait that plus TRIAGE_RECONCILE_INTERVAL_MS to start.
 # 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
 
@@ -5,7 +5,8 @@ import type { DockerTls, FindDockerHostOpts } from "@corbits/provisioner-docker"
 import { LifecycleDuration, lifecycleDurationMs, type ResolvedWorkflowLifecyclePolicy } from "@intx/types";
 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_RECONCILE_POLICY, unstartedAfterMs, 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,
@@ -273,10 +270,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 {
+/** Heads the reconciler lets a tenant have queued or running at once, and how long a queued head may wait to start. */
+export function triageReconcilePolicy(env: Pick<HubEnv, "TRIAGE_MAX_IN_FLIGHT" | "TRIAGE_CAPPED_RETRY_MS">, { mailHoldMs, reconcileIntervalMs }: { mailHoldMs: number; reconcileIntervalMs: number }): ReconcilePolicy {
   return {
     ...DEFAULT_RECONCILE_POLICY,
+    unstartedAfterMs: unstartedAfterMs(mailHoldMs, reconcileIntervalMs),
     maxInFlight: numberOr(env.TRIAGE_MAX_IN_FLIGHT, DEFAULT_RECONCILE_POLICY.maxInFlight),
     cappedRetryAfterMs: numberOr(env.TRIAGE_CAPPED_RETRY_MS, DEFAULT_RECONCILE_POLICY.cappedRetryAfterMs),
   };
@@ -386,9 +384,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 });
   });
 });
 
 
@@ -1,7 +1,8 @@
 // Decides, from what the host and the managers' runs say now, which open pull
 // 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 { DEFAULT_TIMINGS, 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[] };
@@ -51,9 +52,18 @@ export type ReconcilePolicy = {
 
 const MINUTE = 60_000;
 
+/**
+ * A queued head counts as never started one reconcile pass after stock's mail hold, `mailHoldMs`, has dropped its
+ * manager's wake: by then the hub's start grace and deploy-ask hold, both the hold, have lapsed for a manager deployed
+ * after the head was queued.
+ */
+export function unstartedAfterMs(mailHoldMs: number, reconcileIntervalMs: number): number {
+  return mailHoldMs + reconcileIntervalMs;
+}
+
 export const DEFAULT_RECONCILE_POLICY: ReconcilePolicy = {
   webhookGraceMs: 2 * MINUTE,
-  unstartedAfterMs: 10 * MINUTE,
+  unstartedAfterMs: unstartedAfterMs(DEFAULT_MAIL_HOLD_MS, DEFAULT_TIMINGS.reconcileIntervalMs),
   stuckAfterMs: PR_TRIAGE_STUCK_RUN_MS,
   clockSkewMs: MINUTE,
   backoffBaseMs: 5 * MINUTE,
 
@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
 import { formatRunAddress } from "@intx/types";
-import { emptyPack, type ActionKind, type CheckPack, type PrTriageRow } from "@corbits/triage-contracts";
+import { DEFAULT_TIMINGS, emptyPack, type ActionKind, type CheckPack, type PrTriageRow } from "@corbits/triage-contracts";
 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 }) }, { mailHoldMs: DEFAULT_MAIL_HOLD_MS, reconcileIntervalMs: DEFAULT_TIMINGS.reconcileIntervalMs }),
     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" }]);