agentwrangler 0.1.1-next.bca85ea → 0.1.1-next.e259583

package/dist/daemon/http.js

@@ -140,6 +140,14 @@ function requiresSessionToken(pathname) {
         return true;
     if (/^\/api\/esf\/effects\/(track|stop|close|rollback|attest-rollback)$/.test(pathname))
         return true;
+    if (pathname === "/api/work-records" || pathname === "/api/work-records/ids")
+        return true;
+    if (/^\/api\/work-records\/[^/]+\/(edit|closeout|archive|reopen|sessions|contexts|delete)$/.test(pathname))
+        return true;
+    if (/^\/api\/work-records\/[^/]+\/(sessions|contexts)\/[^/]+\/detach$/.test(pathname))
+        return true;
+    if (pathname === "/api/work-records/allocations/recompute")
+        return true;
     return false;
 }
 /**

package/dist/daemon/index.js

@@ -38,6 +38,7 @@ import { getSettingsData, setHealthInstance, setRuntimeResetHook, } from "../que
 import { loadConfig } from "./config.js";
 import { runEffectMeasurementPass } from "./effect-pass.js";
 import { createServer } from "./http.js";
+import { createDaemonLifecycle } from "./lifecycle.js";
 import { createOutcomesPassRunner } from "./outcomes-pass.js";
 import { setReady, setScanRoots, setScanState } from "./readiness.js";
 const VERSION = "0.1.0";
@@ -171,10 +172,6 @@ runProbePass("boot");
 // The runner (src/daemon/outcomes-pass.ts) adds a hard 15-min per-pass deadline:
 // a hung pass can no longer wedge the poll cadence forever — the running flag
 // always clears and the next poll resumes.
-let outcomesTimer = null;
-let reportsTimer = null;
-let reportsRunning = false;
-let bptCalibrationTimer = null;
 const outcomesRunner = createOutcomesPassRunner({
     db,
     probe: () => runProbePass("poll"),
@@ -188,29 +185,31 @@ const outcomesRunner = createOutcomesPassRunner({
 function runOutcomesPass() {
     return outcomesRunner.run();
 }
+// R12 bytes→token calibration — best-effort, never crash the daemon.
+// Runs on boot (deferred) and weekly when: opt-in enabled AND ratio is absent
+// or older than 30 days. Mirrors the outcomes bootstrap pattern.
+const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+function runBptCalibrationIfStale() {
+    const enabled = bptConfigGet(db, "bytes_per_token_calibration_enabled");
+    if (enabled !== "true")
+        return;
+    const measuredAt = bptConfigGet(db, "bytes_per_token_measured_at");
+    if (measuredAt !== null && Date.now() - new Date(measuredAt).getTime() < THIRTY_DAYS_MS)
+        return;
+    calibrateBytesPerToken(db).catch((e) => {
+        console.error(`Bytes-per-token calibration failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+    });
+}
 // ── Deferred boot scan (runs AFTER the HTTP port is bound) ───────────────────
 // startTailBatched() performs a yielding initial back-scan (ingestAllKnown +
 // reconcile), then arms the tail/discovery timers. We do NOT
 // also call runBackscan — that would spin up a second Ingestor whose separate
 // Health instance is the one surfaced in Settings. One Ingestor, one Health.
 // Bounded: if ingestion fails to start, still serve the dashboard (degraded).
-let handle = null;
-// One-shot guard: runBootScan executes exactly once regardless of how many
-// requests or timers fire kickBootScan concurrently.
-let scanKicked = false;
-function kickBootScan() {
-    if (scanKicked)
-        return;
-    scanKicked = true;
-    // Use setImmediate so the triggering HTTP response flushes before boot work
-    // starts. The scan itself also yields between bounded batches.
-    setImmediate(() => {
-        runBootScan().catch((e) => {
-            console.error(`Boot scan failed: ${e instanceof Error ? e.message : String(e)}`);
-        });
-    });
-}
+// The one-shot kick guard, the daemon-owned intervals, and shutdown ordering
+// live in the lifecycle harness (src/daemon/lifecycle.ts).
 async function runBootScan() {
+    let handle = null;
     try {
         const scanRoots = getSettingsData(db).scan_roots;
         setScanRoots(scanRoots);
@@ -263,21 +262,8 @@ async function runBootScan() {
             console.error(`Self-churn collection failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
         }
     });
-    // R12 bytes→token calibration — best-effort, never crash the daemon.
-    // Runs on boot (deferred) and weekly when: opt-in enabled AND ratio is absent
-    // or older than 30 days. Mirrors the outcomes bootstrap pattern.
-    const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
-    function runBptCalibrationIfStale() {
-        const enabled = bptConfigGet(db, "bytes_per_token_calibration_enabled");
-        if (enabled !== "true")
-            return;
-        const measuredAt = bptConfigGet(db, "bytes_per_token_measured_at");
-        if (measuredAt !== null && Date.now() - new Date(measuredAt).getTime() < THIRTY_DAYS_MS)
-            return;
-        calibrateBytesPerToken(db).catch((e) => {
-            console.error(`Bytes-per-token calibration failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
-        });
-    }
+    // Deferred boot calibration check (the weekly interval is armed by the
+    // lifecycle harness after this scan resolves).
     setImmediate(() => {
         try {
             runBptCalibrationIfStale();
@@ -286,42 +272,31 @@ async function runBootScan() {
             console.error(`Bytes-per-token calibration boot failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
         }
     });
-    bptCalibrationTimer = setInterval(() => {
-        try {
-            runBptCalibrationIfStale();
-        }
-        catch (e) {
-            console.error(`Bytes-per-token calibration poll failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }, 7 * 24 * 60 * 60 * 1000);
-    // 10-minute poll — guarded by outcomesRunning to prevent overlap
-    outcomesTimer = setInterval(() => {
+    return handle;
+}
+// ── Lifecycle harness: boot-kick guard, daemon intervals, shutdown ordering ──
+// closeServer closes over `server` (declared below); shutdown only ever runs
+// after listen, so the reference is initialized by then.
+const lifecycle = createDaemonLifecycle({
+    bootScan: runBootScan,
+    calibrationTick: runBptCalibrationIfStale,
+    outcomesTick: () => {
         runOutcomesPass().catch((e) => {
             console.error(`Outcomes poll failed: ${e instanceof Error ? e.message : String(e)}`);
         });
-    }, 10 * 60 * 1000);
-    reportsTimer = setInterval(async () => {
-        if (reportsRunning)
-            return;
-        reportsRunning = true;
-        try {
-            await Promise.resolve(generateWeeklyReport(db, new Date()));
-        }
-        catch (e) {
-            console.error(`Weekly report poll failed: ${e instanceof Error ? e.message : String(e)}`);
-        }
-        finally {
-            reportsRunning = false;
-        }
-    }, 7 * 24 * 60 * 60 * 1000);
-}
+    },
+    reportsTick: () => generateWeeklyReport(db, new Date()),
+    closeServer: (onClosed) => server.close(onClosed),
+    closeDb: () => db.close(),
+    onClosed: () => process.exit(0),
+});
 // ── 4. Start HTTP server ──────────────────────────────────────────────────────
 // Bind the port BEFORE the back-scan so the loading page is delivered
 // immediately while the initial scan yields between file batches.
 // Generate a random in-memory session token for the CSRF token gate.
 // NEVER log it, NEVER persist it — it lives only in process memory.
 const sessionToken = randomUUID();
-const server = createServer(db, config.port, config.uiRoot, sessionToken, kickBootScan);
+const server = createServer(db, config.port, config.uiRoot, sessionToken, lifecycle.kickBootScan);
 server.listen(config.port, "127.0.0.1", () => {
     const url = `http://127.0.0.1:${config.port}`;
     console.log(`Listening on ${url}`);
@@ -334,7 +309,7 @@ server.listen(config.port, "127.0.0.1", () => {
     // Fallback: kick the back-scan after 3 s even if no browser request arrives
     // (headless mode, --no-open, CI). The one-shot guard in kickBootScan() makes
     // whichever trigger fires first the only one that runs the scan.
-    setTimeout(kickBootScan, 3000);
+    lifecycle.armBootFallback();
 });
 /** Open `url` in the system default browser (best-effort; never crashes the daemon). */
 function openBrowser(url) {
@@ -357,24 +332,8 @@ function openBrowser(url) {
 // ── Graceful shutdown ─────────────────────────────────────────────────────────
 process.on("SIGINT", () => {
     console.log("Shutting down…");
-    handle?.stop();
-    if (outcomesTimer !== null)
-        clearInterval(outcomesTimer);
-    if (reportsTimer !== null)
-        clearInterval(reportsTimer);
-    server.close(() => {
-        db.close();
-        process.exit(0);
-    });
+    lifecycle.shutdown();
 });
 process.on("SIGTERM", () => {
-    handle?.stop();
-    if (outcomesTimer !== null)
-        clearInterval(outcomesTimer);
-    if (reportsTimer !== null)
-        clearInterval(reportsTimer);
-    server.close(() => {
-        db.close();
-        process.exit(0);
-    });
+    lifecycle.shutdown();
 });

package/dist/daemon/lifecycle.js

@@ -0,0 +1,122 @@
+/**
+ * src/daemon/lifecycle.ts — daemon timer registration and graceful shutdown.
+ *
+ * Extracted from daemon/index.ts (PERF5) so the boot-kick guard, the three
+ * daemon-owned intervals (calibration / outcomes / weekly reports), and the
+ * shutdown ordering are deterministically unit-testable without booting the
+ * daemon. The signal handlers in index.ts stay thin: both call shutdown().
+ *
+ * Shutdown contract:
+ *   - idempotent — a second signal is a no-op
+ *   - clears the boot-fallback timeout so a shutdown during the 3 s window
+ *     cannot start a scan afterwards
+ *   - a pending boot-kick setImmediate checks the flag and never starts the
+ *     scan after shutdown
+ *   - when shutdown lands while the boot scan is still in flight, the timers
+ *     are never armed and the tail handle is stopped as soon as the scan
+ *     resolves (previously both leaked past db.close())
+ *   - stopping the tail does NOT drain a suspended tail pass; the Ingestor's
+ *     stopped flag makes it quit at the next file boundary (its contract)
+ */
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+export function createDaemonLifecycle(deps) {
+    const error = deps.error ?? ((msg) => console.error(msg));
+    const calibrationIntervalMs = deps.calibrationIntervalMs ?? WEEK_MS;
+    const outcomesIntervalMs = deps.outcomesIntervalMs ?? 10 * 60 * 1000;
+    const reportsIntervalMs = deps.reportsIntervalMs ?? WEEK_MS;
+    const bootFallbackMs = deps.bootFallbackMs ?? 3000;
+    let scanKicked = false;
+    let shutDown = false;
+    let handle = null;
+    let calibrationTimer = null;
+    let outcomesTimer = null;
+    let reportsTimer = null;
+    let fallbackTimer = null;
+    let reportsRunning = false;
+    function armTimers() {
+        calibrationTimer = setInterval(() => {
+            try {
+                deps.calibrationTick();
+            }
+            catch (e) {
+                error(`Bytes-per-token calibration poll failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }, calibrationIntervalMs);
+        outcomesTimer = setInterval(() => {
+            try {
+                deps.outcomesTick();
+            }
+            catch (e) {
+                error(`Outcomes poll failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }, outcomesIntervalMs);
+        reportsTimer = setInterval(() => {
+            if (reportsRunning)
+                return;
+            reportsRunning = true;
+            Promise.resolve()
+                .then(() => deps.reportsTick())
+                .catch((e) => {
+                error(`Weekly report poll failed: ${e instanceof Error ? e.message : String(e)}`);
+            })
+                .finally(() => {
+                reportsRunning = false;
+            });
+        }, reportsIntervalMs);
+    }
+    function kickBootScan() {
+        if (scanKicked || shutDown)
+            return;
+        scanKicked = true;
+        // setImmediate so the triggering HTTP response flushes before boot work
+        // starts. The scan itself also yields between bounded batches.
+        setImmediate(() => {
+            if (shutDown)
+                return;
+            deps
+                .bootScan()
+                .then((h) => {
+                handle = h;
+                if (shutDown) {
+                    // Shutdown landed mid-scan: never arm timers; stop the tail now.
+                    handle?.stop();
+                    handle = null;
+                    return;
+                }
+                armTimers();
+            })
+                .catch((e) => {
+                error(`Boot scan failed: ${e instanceof Error ? e.message : String(e)}`);
+            });
+        });
+    }
+    function shutdown() {
+        if (shutDown)
+            return;
+        shutDown = true;
+        if (fallbackTimer !== null)
+            clearTimeout(fallbackTimer);
+        handle?.stop();
+        handle = null;
+        if (calibrationTimer !== null)
+            clearInterval(calibrationTimer);
+        if (outcomesTimer !== null)
+            clearInterval(outcomesTimer);
+        if (reportsTimer !== null)
+            clearInterval(reportsTimer);
+        deps.closeServer(() => {
+            deps.closeDb();
+            deps.onClosed?.();
+        });
+    }
+    return {
+        kickBootScan,
+        armBootFallback() {
+            fallbackTimer = setTimeout(kickBootScan, bootFallbackMs);
+        },
+        shutdown,
+        get isShutDown() {
+            return shutDown;
+        },
+    };
+}

package/dist/daemon/router.js

@@ -1,11 +1,4 @@
-/**
- * src/daemon/router.ts — minimal API route dispatcher.
- *
- * Routes /api/* requests to the LocalQueryAPI stubs.
- * WP2 and WP4 replace the stub calls with real implementations.
- *
- * All responses are JSON with no permissive CORS headers.
- */
+import { getReportedWork } from "../query/api/reported-work.js";
 import { getPractices } from "../detector/practice-registry.js";
 import { getOAuthStatus } from "../oauth/credentials.js";
 import { getGithubTokenStatus } from "../outcomes/github/credential.js";
@@ -17,6 +10,7 @@ import { getDeliveryMetrics } from "../query/api/delivery.js";
 import { EffectRequestError, listEffectEvidence, mutateEffectCycle, trackCompletedChange, } from "../query/api/effect-service.js";
 import { getClosureProxy } from "../query/api/effectiveness.js";
 import { getEfficiencyHeadroom } from "../query/api/efficiency-headroom.js";
+import { getEsfObservations, getSessionEsfObservations } from "../query/api/esf-observations.js";
 import { getHeadroomTrend } from "../query/api/headroom-trend.js";
 import { getHotSessions } from "../query/api/hot-sessions.js";
 import { adoptRecommendation, calibrateBytesPerToken, calibrateLimit, confirmApplyJob, dismissRecommendation, getApplyJob, getContextBudget, getContextComposition, getGlobalOverview, getHookConfig, getIdleSessions, getLinkageRate, getLoopGuard, getSession, getSessionDrivers, getSettings, getSuccessRate, getTurnTimeline, getWorkspaceOutcomeDetail, installHookRoute, listLedger, listLiveSessions, listRecommendations, listSessions, listWorkspaceOutcomes, listWorkspaces, openTerminalForRec, resetDatabase, rollbackApplyJob, startApplyJob, uninstallHookRoute, updateHookConfig, updateSettings, } from "../query/api/index.js";
@@ -26,6 +20,7 @@ import { getSelfChurn } from "../query/api/self-churn.js";
 import { getSessionSpendPercentile, getWeeklySelfPercentile, } from "../query/api/self-percentiles.js";
 import { getFlavorDecomposition } from "../query/api/spend-flavor.js";
 import { getCacheWriteTrend, getTrends } from "../query/api/trends.js";
+import { WorkRecordError, attachWorkRecordContextRoute, attachWorkRecordSessionRoute, closeoutWorkRecordRoute, createWorkRecordRoute, deleteWorkRecordRoute, detachWorkRecordContextRoute, detachWorkRecordSessionRoute, editWorkRecordRoute, getWorkAllocation, getWorkAllocationClaimKinds, getWorkRecord, issueWorkRecordId, listWorkRecords, recomputeWorkAllocationRoute, setWorkRecordArchivedRoute, workRecordResponse, } from "../query/api/work-records.js";
 import { getSettingsData } from "../query/settings-store.js";
 import { getScanStatus, isReady } from "./readiness.js";
 function sendJson(res, status, body) {
@@ -134,10 +129,96 @@ function jobRoute(pathname) {
     const action = m[2] === "confirm" || m[2] === "rollback" ? m[2] : "get";
     return { jobId: decodeURIComponent(m[1]), action };
 }
+function workRecordId(pathname) {
+    const match = pathname.match(/^\/api\/work-records\/([^/]+)$/);
+    return match?.[1] === undefined ? null : decodeURIComponent(match[1]);
+}
+function listSavedCostReports(db, workspaceId) {
+    return db
+        .prepare(`SELECT r.allocation_revision_id, r.created_at, r.cohort_from, r.cohort_to,
+      SUM(CASE WHEN a.disposition = 'OWNED' THEN 1 ELSE 0 END) AS allocated_session_count,
+      COUNT(a.session_id) AS eligible_session_count
+    FROM work_allocation_revisions r
+    LEFT JOIN work_session_allocations a ON a.allocation_revision_id = r.allocation_revision_id
+    WHERE r.workspace_id = ?
+    GROUP BY r.allocation_revision_id
+    ORDER BY r.created_at DESC, r.allocation_revision_id DESC`)
+        .all(workspaceId);
+}
+function workRecordAction(pathname) {
+    const match = pathname.match(/^\/api\/work-records\/([^/]+)\/(edit|closeout|archive|reopen|sessions|contexts|delete)(?:\/([^/]+)\/detach)?$/);
+    if (match?.[1] === undefined || match[2] === undefined)
+        return null;
+    const result = { recordId: decodeURIComponent(match[1]), action: match[2] };
+    return match[3] === undefined ? result : { ...result, relatedId: decodeURIComponent(match[3]) };
+}
+function workRecordBody(raw, recordId, related) {
+    let body;
+    try {
+        body = JSON.parse(raw);
+    }
+    catch {
+        throw new WorkRecordError(400, "INVALID_REQUEST", "Invalid JSON body");
+    }
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new WorkRecordError(400, "INVALID_REQUEST", "request body must be an object");
+    }
+    const result = { ...body };
+    if (recordId !== undefined) {
+        if (result.work_record_id !== undefined && result.work_record_id !== recordId) {
+            throw new WorkRecordError(400, "INVALID_REQUEST", "work_record_id must match the route");
+        }
+        result.work_record_id = recordId;
+    }
+    if (related !== undefined) {
+        if (result[related.key] !== undefined && result[related.key] !== related.value) {
+            throw new WorkRecordError(400, "INVALID_REQUEST", `${related.key} must match the route`);
+        }
+        result[related.key] = related.value;
+    }
+    return result;
+}
+function sendWorkRecordError(res, error) {
+    if (error instanceof EffectRequestError) {
+        sendJson(res, error.status, { error: error.message, code: "INVALID_REQUEST" });
+        return;
+    }
+    if (error instanceof WorkRecordError) {
+        sendJson(res, error.status, { error: error.message, code: error.code });
+        return;
+    }
+    sendJson(res, 500, { error: "Internal error" });
+}
 export function handleApiRequest(_db, req, res, method, url) {
     // Strip query string for routing.
     const pathname = url.split("?")[0] ?? url;
     try {
+        if (method === "GET" && pathname === "/api/work-records/summary") {
+            const params = new URLSearchParams(url.split("?")[1] ?? "");
+            sendJson(res, 200, getReportedWork(_db, params.get("workspace_id") || null));
+            return;
+        }
+        // GET /api/esf/observations — complete selected-turn accounting cohort.
+        if (method === "GET" && pathname === "/api/esf/observations") {
+            const params = new URLSearchParams(url.split("?")[1] ?? "");
+            const window = resolveWindow(parseWindowFilter(url));
+            if (Date.parse(window.from) >= Date.parse(window.to)) {
+                sendJson(res, 400, { error: "from must precede to" });
+                return;
+            }
+            sendJson(res, 200, getEsfObservations(_db, {
+                workspaceId: params.get("workspace_id") || null,
+                ...window,
+            }));
+            return;
+        }
+        // Full-session aggregate: never derive this from a paginated timeline.
+        const sessionObservationId = pathname.match(/^\/api\/esf\/session-observations\/([^/]+)$/)?.[1];
+        if (method === "GET" && sessionObservationId !== undefined) {
+            const evidence = getSessionEsfObservations(_db, decodeURIComponent(sessionObservationId));
+            sendJson(res, evidence.data === null ? 404 : 200, evidence);
+            return;
+        }
         // GET /api/esf/effects — independently keyset-paged versioned and legacy evidence.
         if (method === "GET" && pathname === "/api/esf/effects") {
             const params = new URLSearchParams(url.split("?")[1] ?? "");
@@ -179,6 +260,172 @@ export function handleApiRequest(_db, req, res, method, url) {
             }));
             return;
         }
+        // ESF3 work records are local-only, structured records.  The HTTP token gate
+        // in http.ts covers every mutation and ID issuance route below.
+        if (method === "GET" && pathname === "/api/work-records") {
+            const params = new URLSearchParams(url.split("?")[1] ?? "");
+            const workspaceId = params.get("workspace_id");
+            const includeArchived = params.get("include_archived");
+            if (workspaceId === null ||
+                workspaceId.length === 0 ||
+                (includeArchived !== null && includeArchived !== "true" && includeArchived !== "false")) {
+                sendJson(res, 400, { error: "workspace_id and include_archived are invalid" });
+                return;
+            }
+            const records = listWorkRecords(_db, workspaceId, includeArchived === "true");
+            sendJson(res, 200, workRecordResponse(records, { n: records.length, workspaceId }));
+            return;
+        }
+        if (method === "GET" && pathname === "/api/work-records/allocations") {
+            const workspaceId = new URLSearchParams(url.split("?")[1] ?? "").get("workspace_id");
+            if (workspaceId === null || workspaceId.length === 0) {
+                sendJson(res, 400, { error: "workspace_id is required" });
+                return;
+            }
+            const reports = listSavedCostReports(_db, workspaceId);
+            sendJson(res, 200, workRecordResponse(reports, { n: reports.length, workspaceId }));
+            return;
+        }
+        if (method === "GET" && pathname.startsWith("/api/work-records/allocations/")) {
+            const allocationId = pathname.slice("/api/work-records/allocations/".length);
+            if (allocationId.length === 0 || allocationId.includes("/")) {
+                sendJson(res, 404, { error: "Not found" });
+                return;
+            }
+            try {
+                const allocation = getWorkAllocation(_db, decodeURIComponent(allocationId));
+                sendJson(res, 200, workRecordResponse(allocation, {
+                    n: allocation.eligible_session_count,
+                    workspaceId: allocation.workspace_id,
+                    claimKind: "EXPERIMENTAL",
+                    meta: {
+                        window: { from: allocation.cohort_from, to: allocation.cohort_to },
+                        qualification: {
+                            provisional_excluded: true,
+                            unpriced_turns: allocation.unpriced_turn_count,
+                            claim_kinds_count: getWorkAllocationClaimKinds(_db, allocation.allocation_revision_id),
+                            note: "Frozen ESF3 allocation; unpriced turns are not zero cost.",
+                        },
+                    },
+                }));
+            }
+            catch (error) {
+                sendWorkRecordError(res, error);
+            }
+            return;
+        }
+        const recordId = workRecordId(pathname);
+        if (method === "GET" && recordId !== null) {
+            try {
+                const record = getWorkRecord(_db, recordId);
+                sendJson(res, 200, workRecordResponse(record, { workspaceId: record.workspace_id }));
+            }
+            catch (error) {
+                sendWorkRecordError(res, error);
+            }
+            return;
+        }
+        if (method === "POST" && pathname === "/api/work-records/ids") {
+            readBody(req, 1024)
+                .then((raw) => {
+                try {
+                    sendJson(res, 200, workRecordResponse(issueWorkRecordId(_db, workRecordBody(raw))));
+                }
+                catch (error) {
+                    sendWorkRecordError(res, error);
+                }
+            })
+                .catch((error) => sendWorkRecordError(res, error));
+            return;
+        }
+        if (method === "POST" && pathname === "/api/work-records") {
+            readBody(req, 4096)
+                .then((raw) => {
+                try {
+                    const result = createWorkRecordRoute(_db, workRecordBody(raw));
+                    sendJson(res, 200, workRecordResponse(result, { workspaceId: result.record.workspace_id }));
+                }
+                catch (error) {
+                    sendWorkRecordError(res, error);
+                }
+            })
+                .catch((error) => sendWorkRecordError(res, error));
+            return;
+        }
+        if (method === "POST" && pathname === "/api/work-records/allocations/recompute") {
+            readBody(req, 4096)
+                .then((raw) => {
+                try {
+                    const result = recomputeWorkAllocationRoute(_db, workRecordBody(raw));
+                    sendJson(res, 200, workRecordResponse(result, {
+                        n: result.allocation.eligible_session_count,
+                        workspaceId: result.allocation.workspace_id,
+                        claimKind: "EXPERIMENTAL",
+                        meta: {
+                            window: {
+                                from: result.allocation.cohort_from,
+                                to: result.allocation.cohort_to,
+                            },
+                            qualification: {
+                                provisional_excluded: true,
+                                unpriced_turns: result.allocation.unpriced_turn_count,
+                                claim_kinds_count: getWorkAllocationClaimKinds(_db, result.allocation.allocation_revision_id),
+                                note: "Frozen ESF3 allocation; unpriced turns are not zero cost.",
+                            },
+                        },
+                    }));
+                }
+                catch (error) {
+                    sendWorkRecordError(res, error);
+                }
+            })
+                .catch((error) => sendWorkRecordError(res, error));
+            return;
+        }
+        const recordAction = workRecordAction(pathname);
+        if (recordAction !== null &&
+            ((method === "POST" && recordAction.action !== "delete") ||
+                (method === "DELETE" && recordAction.action === "delete"))) {
+            readBody(req, 4096)
+                .then((raw) => {
+                try {
+                    const related = recordAction.relatedId === undefined
+                        ? undefined
+                        : {
+                            key: recordAction.action === "contexts" ? "context_ref_id" : "session_id",
+                            value: recordAction.relatedId,
+                        };
+                    const body = workRecordBody(raw, recordAction.recordId, related);
+                    const result = recordAction.action === "edit"
+                        ? editWorkRecordRoute(_db, body)
+                        : recordAction.action === "closeout"
+                            ? closeoutWorkRecordRoute(_db, body)
+                            : recordAction.action === "archive"
+                                ? setWorkRecordArchivedRoute(_db, body, true)
+                                : recordAction.action === "reopen"
+                                    ? setWorkRecordArchivedRoute(_db, body, false)
+                                    : recordAction.action === "sessions" && recordAction.relatedId === undefined
+                                        ? attachWorkRecordSessionRoute(_db, body)
+                                        : recordAction.action === "sessions"
+                                            ? detachWorkRecordSessionRoute(_db, body)
+                                            : recordAction.action === "contexts" &&
+                                                recordAction.relatedId === undefined
+                                                ? attachWorkRecordContextRoute(_db, body)
+                                                : recordAction.action === "contexts"
+                                                    ? detachWorkRecordContextRoute(_db, body)
+                                                    : deleteWorkRecordRoute(_db, body);
+                    const workspaceId = "record" in result ? result.record.workspace_id : undefined;
+                    sendJson(res, 200, workspaceId === undefined
+                        ? workRecordResponse(result)
+                        : workRecordResponse(result, { workspaceId }));
+                }
+                catch (error) {
+                    sendWorkRecordError(res, error);
+                }
+            })
+                .catch((error) => sendWorkRecordError(res, error));
+            return;
+        }
         // GET /api/overview
         if (method === "GET" && pathname === "/api/overview") {
             sendJson(res, 200, getGlobalOverview(parseWindowFilter(url)));