target-supabase-sdk 0.2.11 → 0.2.13

package/dist/node.js

@@ -1,14 +1,14 @@
 import { z } from 'zod';
-import { M as MAX_POLL_TARGET_LIST_SIZE, Q as validateWithSchema, f as createLogger, x as pollTargetList, j as generateResponse, g as createTarget, H as supabase, v as logManager, T as createScope, c as LogLevel, V as patchScope, G as scanTargetList, W as withModule, k as getPossibleTarget, s as isOptimisticLockResponse, K as updateTargetDetails } from './chunks/list.api-DSTOHzOC.js';
-export { B as BaseValidator, C as CREATE_TARGET_ALREADY_EXISTS_MESSAGE, a as CategoryList, L as LOG_BATCH_LOADER_KEY, b as LOG_PERSIST_LOADER_KEY, d as MAX_TARGET_LIST_PAGE_SIZE, O as OPTIMISTIC_LOCK_ERROR_CODE, e as OPTIMISTIC_LOCK_FAILED_MESSAGE, P as PostListValidator, S as StatusCode, U as UPDATE_TARGET_NOT_FOUND_MESSAGE, h as deleteTarget, i as formatZodError, l as getTarget, m as getTargetList, n as getTargetTotalCount, o as handleSupabaseError, p as isCreateTargetAlreadyExistsError, q as isDevEnvironment, r as isOptimisticLockError, t as logDev, u as logDevGroup, w as patchTarget, y as postListCreate, z as postLogListCreate, A as postTarget, D as postTargetPayloadSchema, E as queryFilterSchema, F as safeParseWithSchema, I as targetDraftSchema, J as updateTarget, N as validateWith } from './chunks/list.api-DSTOHzOC.js';
-import { l as loadEnvFiles, b as readEnv, c as requireEnv, d as createJsonFileStateStore, a as logPersistEnabledFromEnv, e as disableLogPersist, g as getLogPersistStats, s as snapshotLogPersistReady, w as waitForLogPersistReady, f as ensureLogPersistFromEnv } from './chunks/enable-log-persist-Cu3SGxK7.js';
-export { C as CLI_PROD_FLAG, S as SERVICE_ENV_PROFILE_ENV_KEY, h as SERVICE_ENV_PROFILE_PROD, i as enableLogPersist, j as envBool, k as envInt, m as envMs, n as envNumber, o as envPort, q as envProfileFromProcess, t as parseEnvFile, u as parseEnvLine, p as pinEnvProfileFromArgv, x as pollUntil, y as resolveDefaultEnvFiles, z as resolveLogPersistRegistryPath, r as resolveProjectRootByPackageName, A as resolveProjectRootFromModule, v as validateLogPersistPreloadEnv } from './chunks/enable-log-persist-Cu3SGxK7.js';
-import { access, stat, readFile, mkdir, unlink, writeFile, readdir } from 'node:fs/promises';
-import { resolve, join, dirname, isAbsolute } from 'node:path';
-import { bi as sha256Hex, bn as getErrorMessage, aN as postRegisterNode, ar as patchChangeNodeStatus, N as NodeStatus, aC as patchStopNode, az as patchNodeHeartBeat, E as EMPTY_REGISTRY_SLOT_RUNTIME_STATE, b8 as runRegistrySlotGuardCheck, a$ as registrySlotRuntimePatchFromGuardResult, d as CategoryNode, V as evaluateBusyNodeLiveness, aB as patchServiceRuntime, l as ServiceRegistryError, y as claimServiceRegistrySlot, f as CategoryRepo, R as ResultCode, bo as LOG_TOPIC_TASK, n as TASK_REPO_USAGE, a8 as getScanRemoteRepoValues, av as patchClaimTask, bp as CRITICAL_UNKNOWN_TASK_TRACE_ID, at as patchChangeTaskStatus, p as TaskStatusAction, bq as toError, aV as postTaskSchema, br as createTaskRow, o as TaskStatus } from './chunks/task-queue-BHvNgb-X.js';
-export { A as ApiMethod, C as CategoryConfig, a as CategoryExtraction, b as CategoryIdea, c as CategoryLink, e as CategoryParcel, g as CategoryService, h as CategoryTask, D as DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS, L as LINK_MANIFEST_VERSION, i as LIST_MANIFEST_VERSION, M as Market, P as POST_TASK_DEFAULT_MAX_ATTEMPTS, j as ParcelManager, k as PostLinkValidator, S as ServiceLifecycleStatus, m as ServiceSlotStatus, T as TARGET_SYSTEM_REGISTRY_KEY, q as apiDetailsSchema, r as appendSystemRegistrySlots, s as assertRegistrySlotAvailable, t as assertRegistrySlotOwner, u as buildEmptyServiceSlots, v as buildLinkTargetDraft, w as buildListTargetDraft, x as buildSystemRegistryConfigDetails, z as classifyNetworkError, B as countTasksByType, F as createActiveServiceLifecycle, G as createClaimedRegistrySlotRuntimeState, H as createStorageProviderRegistry, I as createUploadTracker, J as decodeLogBatch, K as decodeLogBatchList, O as defaultL3ServiceDetails, Q as deleteParcel, U as deleteParcelSchema, W as fetchBinaryWithRetry, X as fetchWithRetry, Y as fieldDefinitionSchema, Z as flattenLogBatch, _ as flattenLogBatches, $ as formatNetworkError, a0 as getApi, a1 as getApiSchema, a2 as getConfig, a3 as getConfigSchema, a4 as getExtraction, a5 as getExtractionSchema, a6 as getParcel, a7 as getParcelSchema, a9 as getScanRemoteRepoValuesSchema, aa as getService, ab as getServiceSchema, ac as getTargetSystemRegistry, ad as getValueAtPath, ae as installChunkFetchRegistry, af as isHttpUrl, ag as isLocalFilesystemPath, ah as isLogBatchList, ai as isLogEntry, aj as isOpaqueChunkUrl, ak as isRetryableHttpStatus, al as linkTargetDraftBuildInputSchema, am as parcelDetailsSchema, an as parseLogBatchMeta, ao as parseProviderPrefixedUrl, ap as parseServiceSlot, aq as parseServiceSlots, as as patchChangeNodeStatusSchema, au as patchChangeTaskStatusSchema, aw as patchClaimTaskSchema, ax as patchExtractionObjects, ay as patchExtractionObjectsSchema, aA as patchNodeHeartBeatSchema, aD as patchStopNodeSchema, aE as patchTaskProgress, aF as patchTaskProgressSchema, aG as postApi, aH as postApiSchema, aI as postExtraction, aJ as postExtractionSchema, aK as postLinkCreate, aL as postParcel, aM as postParcelSchema, aO as postRegisterNodeSchema, aP as postService, aQ as postServiceInstance, aR as postServiceSchema, aS as postSystemRegistryConfig, aT as postSystemRegistryConfigSchema, aU as postTask, aW as postTaskWithRetry, aX as publishParcel, aY as registerProviderChunkResolver, aZ as registerService, a_ as registerServiceAtStartup, b0 as releaseSystemRegistrySlots, b1 as requestHasBody, b2 as resetSystemRegistryConfig, b3 as resetSystemRegistryConfigSchema, b4 as resolveActiveRegistryServiceId, b5 as resolveFetchUrl, b6 as restoreParcel, b7 as restoreParcelById, b9 as sanitizeFileName, ba as sanitizeParcelFileName, bb as scanExtractionList, bc as scanExtractionListSchema, bd as schemaDefinitionSchema, be as serviceDetailsSchema, bf as serviceLifecycleSchema, bg as serviceNodeSnapshotSchema, bh as serviceRuntimeSchema, bj as summarizeTaskQueue, bk as systemRegistrySeedSlotSchema, bl as unregisterService, bm as unregisterServiceAtShutdown } from './chunks/task-queue-BHvNgb-X.js';
+import { M as MAX_POLL_TARGET_LIST_SIZE, V as validateWithSchema, g as createLogger, z as pollTargetList, k as generateResponse, h as createTarget, K as supabase, w as logManager, X as createScope, d as LogLevel, Y as patchScope, J as scanTargetList, Z as withModule, l as getPossibleTarget, t as isOptimisticLockResponse, R as updateTargetDetails } from './chunks/list.api-BzbTJBsM.js';
+export { B as BaseValidator, C as CREATE_TARGET_ALREADY_EXISTS_MESSAGE, a as CategoryList, L as LOG_BATCH_LOADER_KEY, b as LOG_MIN_LEVEL_ENV_KEY, c as LOG_PERSIST_LOADER_KEY, e as MAX_TARGET_LIST_PAGE_SIZE, O as OPTIMISTIC_LOCK_ERROR_CODE, f as OPTIMISTIC_LOCK_FAILED_MESSAGE, P as PostListValidator, S as StatusCode, U as UPDATE_TARGET_NOT_FOUND_MESSAGE, i as deleteTarget, j as formatZodError, m as getTarget, n as getTargetList, o as getTargetTotalCount, p as handleSupabaseError, q as isCreateTargetAlreadyExistsError, r as isDevEnvironment, s as isOptimisticLockError, u as logDev, v as logDevGroup, x as logMinLevelFromEnv, y as patchTarget, A as postListCreate, D as postLogListCreate, E as postTarget, F as postTargetPayloadSchema, G as queryFilterSchema, H as resolveLogMinLevel, I as safeParseWithSchema, N as targetDraftSchema, Q as updateTarget, T as validateWith } from './chunks/list.api-BzbTJBsM.js';
+import { l as loadEnvFiles, b as readEnv, c as requireEnv, d as resolveLogSpoolSpawnEnvForLabel, e as resolveLogSpoolConfig, f as resolveLogSpoolRoot, g as resolveAllLogSpoolProcessRoles, h as logSpoolProcessDir, s as spoolLogger, i as parseLogSpoolBatchFilename, j as computeLogBatchIdempotencyKey, k as buildLogListDraft, n as postLogBatch, a as logSpoolEnabledFromEnv, o as logSpoolConfigFromEnv, L as LOG_SPOOL_SERVICE_ID_ENV, q as ensureLogSpoolFromEnv, t as shutdownLogSpoolFromEnv, u as getLogSpoolStats } from './chunks/enable-DqnfLPsQ.js';
+export { C as CLI_PROD_FLAG, S as SERVICE_ENV_PROFILE_ENV_KEY, w as SERVICE_ENV_PROFILE_PROD, x as buildLogSpoolSpawnEnv, y as envBool, z as envInt, A as envMs, B as envNumber, D as envPort, E as envProfileFromProcess, F as parseEnvFile, G as parseEnvLine, p as pinEnvProfileFromArgv, H as resolveDefaultEnvFiles, r as resolveProjectRootByPackageName, I as resolveProjectRootFromModule, v as validateLogSpoolPreloadEnv } from './chunks/enable-DqnfLPsQ.js';
+import { randomBytes, createHash } from 'node:crypto';
+import { readFile, unlink, mkdir, writeFile, rename, access, stat, readdir, constants } from 'node:fs/promises';
+import { dirname, resolve, join, isAbsolute } from 'node:path';
+import { bh as sha256Hex, bm as getErrorMessage, aL as postRegisterNode, ap as patchChangeNodeStatus, N as NodeStatus, aA as patchStopNode, ax as patchNodeHeartBeat, E as EMPTY_REGISTRY_SLOT_RUNTIME_STATE, ag as isLogEntry, b7 as runRegistrySlotGuardCheck, aZ as registrySlotRuntimePatchFromGuardResult, c as CategoryNode, Q as evaluateBusyNodeLiveness, az as patchServiceRuntime, k as ServiceRegistryError, x as claimServiceRegistrySlot, e as CategoryRepo, R as ResultCode, bn as LOG_TOPIC_TASK, m as TASK_REPO_USAGE, a6 as getScanRemoteRepoValues, at as patchClaimTask, bo as CRITICAL_UNKNOWN_TASK_TRACE_ID, ar as patchChangeTaskStatus, o as TaskStatusAction, bp as toError, aT as postTaskSchema, bq as createTaskRow, n as TaskStatus } from './chunks/task-queue-6X3aglJh.js';
+export { A as ApiMethod, C as CategoryConfig, a as CategoryExtraction, b as CategoryLink, d as CategoryParcel, f as CategoryService, g as CategoryTask, D as DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS, L as LINK_MANIFEST_VERSION, h as LIST_MANIFEST_VERSION, P as POST_TASK_DEFAULT_MAX_ATTEMPTS, i as ParcelManager, j as PostLinkValidator, S as ServiceLifecycleStatus, l as ServiceSlotStatus, T as TARGET_SYSTEM_REGISTRY_KEY, p as apiDetailsSchema, q as appendSystemRegistrySlots, r as assertRegistrySlotAvailable, s as assertRegistrySlotOwner, t as buildEmptyServiceSlots, u as buildLinkTargetDraft, v as buildListTargetDraft, w as buildSystemRegistryConfigDetails, y as classifyNetworkError, z as countTasksByType, B as createActiveServiceLifecycle, F as createClaimedRegistrySlotRuntimeState, G as createStorageProviderRegistry, H as createUploadTracker, I as decodeLogBatch, J as decodeLogBatchList, K as defaultL3ServiceDetails, M as deleteParcel, O as deleteParcelSchema, U as fetchBinaryWithRetry, V as fetchWithRetry, W as fieldDefinitionSchema, X as flattenLogBatch, Y as flattenLogBatches, Z as formatNetworkError, _ as getApi, $ as getApiSchema, a0 as getConfig, a1 as getConfigSchema, a2 as getExtraction, a3 as getExtractionSchema, a4 as getParcel, a5 as getParcelSchema, a7 as getScanRemoteRepoValuesSchema, a8 as getService, a9 as getServiceSchema, aa as getTargetSystemRegistry, ab as getValueAtPath, ac as installChunkFetchRegistry, ad as isHttpUrl, ae as isLocalFilesystemPath, af as isLogBatchList, ah as isOpaqueChunkUrl, ai as isRetryableHttpStatus, aj as linkTargetDraftBuildInputSchema, ak as parcelDetailsSchema, al as parseLogBatchMeta, am as parseProviderPrefixedUrl, an as parseServiceSlot, ao as parseServiceSlots, aq as patchChangeNodeStatusSchema, as as patchChangeTaskStatusSchema, au as patchClaimTaskSchema, av as patchExtractionObjects, aw as patchExtractionObjectsSchema, ay as patchNodeHeartBeatSchema, aB as patchStopNodeSchema, aC as patchTaskProgress, aD as patchTaskProgressSchema, aE as postApi, aF as postApiSchema, aG as postExtraction, aH as postExtractionSchema, aI as postLinkCreate, aJ as postParcel, aK as postParcelSchema, aM as postRegisterNodeSchema, aN as postService, aO as postServiceInstance, aP as postServiceSchema, aQ as postSystemRegistryConfig, aR as postSystemRegistryConfigSchema, aS as postTask, aU as postTaskWithRetry, aV as publishParcel, aW as registerProviderChunkResolver, aX as registerService, aY as registerServiceAtStartup, a_ as releaseSystemRegistrySlots, a$ as releaseSystemRegistrySlotsByServiceId, b0 as requestHasBody, b1 as resetSystemRegistryConfig, b2 as resetSystemRegistryConfigSchema, b3 as resolveActiveRegistryServiceId, b4 as resolveFetchUrl, b5 as restoreParcel, b6 as restoreParcelById, b8 as sanitizeFileName, b9 as sanitizeParcelFileName, ba as scanExtractionList, bb as scanExtractionListSchema, bc as schemaDefinitionSchema, bd as serviceDetailsSchema, be as serviceLifecycleSchema, bf as serviceNodeSnapshotSchema, bg as serviceRuntimeSchema, bi as summarizeTaskQueue, bj as systemRegistrySeedSlotSchema, bk as unregisterService, bl as unregisterServiceAtShutdown } from './chunks/task-queue-6X3aglJh.js';
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import 'lodash-es';
@@ -119,6 +119,98 @@ function publicBaseUrlFromEnv(port, options) {
     return `http://localhost:${port}`;
 }
 
+/** Per-file write queue — serializes read-modify-write for a single JSON path within one process. */
+const writeChains = new Map();
+function withSerializedFileWrites(filePath, operation) {
+    const previous = writeChains.get(filePath) ?? Promise.resolve();
+    const next = previous.then(operation, operation);
+    writeChains.set(filePath, next.then(() => undefined, () => undefined));
+    return next;
+}
+
+function mergeWithNested(defaults, current, patch, nestedKeys) {
+    const merged = {
+        ...defaults,
+        ...current,
+        ...patch,
+    };
+    for (const key of nestedKeys) {
+        const defaultNested = defaults[key];
+        if (defaultNested != null && typeof defaultNested === "object") {
+            merged[key] = {
+                ...defaultNested,
+                ...current?.[key],
+                ...patch[key],
+            };
+        }
+    }
+    return merged;
+}
+async function atomicWriteJson(filePath, data) {
+    await mkdir(dirname(filePath), { recursive: true });
+    const content = `${JSON.stringify(data, null, 2)}\n`;
+    JSON.parse(content);
+    const tempPath = `${filePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    try {
+        await writeFile(tempPath, content, "utf8");
+        await rename(tempPath, filePath);
+    }
+    catch (error) {
+        await unlink(tempPath).catch(() => undefined);
+        throw error;
+    }
+}
+/** JSON file-backed state with optional nested key merge and atomic writes. */
+function createJsonFileStateStore(options) {
+    const { filePath, defaultState, nestedKeys = [], updatedAtKey } = options;
+    function touchUpdatedAt(state) {
+        if (updatedAtKey == null) {
+            return state;
+        }
+        return {
+            ...state,
+            [updatedAtKey]: new Date().toISOString(),
+        };
+    }
+    async function readFromDisk() {
+        try {
+            const raw = await readFile(filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            return mergeWithNested(defaultState, parsed, {}, nestedKeys);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return mergeWithNested(defaultState, {}, {}, nestedKeys);
+            }
+            if (error instanceof SyntaxError) {
+                await unlink(filePath).catch(() => undefined);
+                return mergeWithNested(defaultState, {}, {}, nestedKeys);
+            }
+            throw error;
+        }
+    }
+    return {
+        read() {
+            return readFromDisk();
+        },
+        write(patch) {
+            return withSerializedFileWrites(filePath, async () => {
+                const current = await readFromDisk();
+                const next = touchUpdatedAt(mergeWithNested(defaultState, current, patch, nestedKeys));
+                await atomicWriteJson(filePath, next);
+                return next;
+            });
+        },
+        reset() {
+            return withSerializedFileWrites(filePath, async () => {
+                const next = touchUpdatedAt({ ...defaultState });
+                await atomicWriteJson(filePath, next);
+                return next;
+            });
+        },
+    };
+}
+
 /** Copy a Node.js Buffer view to a standalone ArrayBuffer. */
 function nodeBufferToArrayBuffer(nodeBuffer) {
     return nodeBuffer.buffer.slice(nodeBuffer.byteOffset, nodeBuffer.byteOffset + nodeBuffer.byteLength);
@@ -725,12 +817,16 @@ class ManagedChildProcesses {
         if (existing != null) {
             return { child: existing, created: false };
         }
+        const logSpoolEnv = resolveLogSpoolSpawnEnvForLabel(label);
+        const childEnv = spawnOptions?.env != null
+            ? { ...process.env, ...logSpoolEnv, ...spawnOptions.env }
+            : { ...process.env, ...logSpoolEnv };
         const child = spawnTsxChild({
             projectRoot: this.projectRoot,
             entryScript,
             preloadModules: this.preloadModules,
             useTsx: spawnOptions?.useTsx ?? this.defaultUseTsx,
-            env: spawnOptions?.env != null ? { ...process.env, ...spawnOptions.env } : process.env,
+            env: childEnv,
         });
         child.on("exit", (code, signal) => {
             this.logger?.info("child exited", { topic: "process", data: { label, code, signal } });
@@ -805,6 +901,25 @@ function createManagedChildProcesses(options) {
     });
 }
 
+function sleep$1(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Poll `until()` until it returns true or `timeoutMs` elapses.
+ * @throws Error on timeout
+ */
+async function pollUntil(options) {
+    const intervalMs = options.intervalMs ?? 500;
+    const deadline = Date.now() + options.timeoutMs;
+    while (Date.now() < deadline) {
+        if (await options.until()) {
+            return;
+        }
+        await sleep$1(intervalMs);
+    }
+    throw new Error(`pollUntil timeout after ${options.timeoutMs}ms`);
+}
+
 /** Factory: all listed env keys must be non-empty. */
 function createRequiredEnvCheck(name, keys, options) {
     return () => {
@@ -1362,6 +1477,314 @@ async function runRunner(ctx, runner) {
     return succeeded;
 }
 
+const UPLOAD_LANE = "slow";
+/** Per serviceId — guard collect-log tick runs GC at most once per `gc.intervalMs`. */
+const lastGcAtMsByServiceId = new Map();
+async function pathExists$1(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readBatchTmpFile(tmpPath) {
+    try {
+        const raw = await readFile(tmpPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.entries) || parsed.entries.length === 0) {
+            return null;
+        }
+        const entries = parsed.entries.filter(isLogEntry);
+        if (entries.length === 0) {
+            return null;
+        }
+        return { entries, meta: parsed.meta };
+    }
+    catch {
+        return null;
+    }
+}
+function processMetaKey(serviceId, processRole) {
+    return `${serviceId}:${processRole}`;
+}
+async function uploadTmpBatch(input) {
+    const parsed = parseLogSpoolBatchFilename(input.fileName);
+    if (parsed == null) {
+        spoolLogger.warn("collect-log skipped — invalid tmp filename", { fileName: input.fileName });
+        return "failed";
+    }
+    const jsonFileName = input.fileName.replace(/\.tmp$/, ".json");
+    const jsonPath = join(logSpoolProcessDir(input.spoolRoot, input.serviceId, input.processRole), jsonFileName);
+    if (await pathExists$1(jsonPath)) {
+        try {
+            await unlink(input.tmpPath);
+            spoolLogger.info("collect-log removed orphan tmp (json exists)", {
+                tmpPath: input.tmpPath,
+                jsonPath,
+            });
+        }
+        catch {
+            // best-effort
+        }
+        return "skipped";
+    }
+    const batch = await readBatchTmpFile(input.tmpPath);
+    if (batch == null) {
+        spoolLogger.warn("collect-log skipped — tmp failed validation", {
+            tmpPath: input.tmpPath,
+            fileName: input.fileName,
+        });
+        try {
+            await unlink(input.tmpPath);
+            spoolLogger.info("collect-log removed invalid tmp", { tmpPath: input.tmpPath });
+        }
+        catch {
+            // best-effort
+        }
+        return "failed";
+    }
+    const processKey = processMetaKey(input.serviceId, input.processRole);
+    // TODO: `lane` is legacy transport metadata — scheduled for removal; fixed to "slow" for downstream decode compatibility.
+    const idempotencyKey = computeLogBatchIdempotencyKey({
+        service: input.serviceValue,
+        process: processKey,
+        lane: UPLOAD_LANE,
+        entries: batch.entries,
+    });
+    const draft = buildLogListDraft({
+        service: input.serviceValue,
+        process: processKey,
+        lane: UPLOAD_LANE,
+        idempotencyKey,
+        entries: batch.entries,
+    });
+    try {
+        await postLogBatch(draft, input.postTimeoutMs);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        spoolLogger.error("collect-log upload failed", {
+            fileName: input.fileName,
+            processRole: input.processRole,
+            error: message,
+        });
+        return "failed";
+    }
+    try {
+        await rename(input.tmpPath, jsonPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        spoolLogger.error("collect-log rename tmp→json failed after upload", {
+            tmpPath: input.tmpPath,
+            jsonPath,
+            error: message,
+        });
+        return "failed";
+    }
+    spoolLogger.info("collect-log uploaded batch", {
+        processRole: input.processRole,
+        fileName: jsonFileName,
+        entryCount: batch.entries.length,
+        idempotencyKey,
+    });
+    return "uploaded";
+}
+async function gcTmpFiles(input) {
+    const processDir = logSpoolProcessDir(input.spoolRoot, input.serviceId, input.processRole);
+    let removed = 0;
+    try {
+        const names = await readdir(processDir);
+        for (const name of names) {
+            if (!name.endsWith(".tmp")) {
+                continue;
+            }
+            const parsed = parseLogSpoolBatchFilename(name);
+            if (parsed == null) {
+                continue;
+            }
+            if (input.nowMs - parsed.timestampMs <= input.tmpRetentionMs) {
+                continue;
+            }
+            try {
+                await unlink(join(processDir, name));
+                removed += 1;
+                spoolLogger.info("collect-log gc removed stale tmp", {
+                    fileName: name,
+                    processRole: input.processRole,
+                });
+            }
+            catch {
+                // best-effort
+            }
+        }
+    }
+    catch {
+        // directory may not exist yet
+    }
+    return removed;
+}
+async function gcSyncedJsonFiles(input) {
+    let removed = 0;
+    for (const processRole of resolveAllLogSpoolProcessRoles()) {
+        const processDir = logSpoolProcessDir(input.spoolRoot, input.serviceId, processRole);
+        let names = [];
+        try {
+            names = await readdir(processDir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith(".json")) {
+                continue;
+            }
+            if (parseLogSpoolBatchFilename(name) == null) {
+                continue;
+            }
+            const jsonPath = join(processDir, name);
+            try {
+                const fileStat = await stat(jsonPath);
+                if (input.nowMs - fileStat.mtimeMs <= input.syncedRetentionMs) {
+                    continue;
+                }
+                await unlink(jsonPath);
+                removed += 1;
+                spoolLogger.info("collect-log gc removed synced json", {
+                    fileName: name,
+                    processRole,
+                });
+            }
+            catch {
+                // best-effort
+            }
+        }
+    }
+    return removed;
+}
+function shouldRunGc(serviceId, nowMs, intervalMs) {
+    const lastAt = lastGcAtMsByServiceId.get(serviceId) ?? 0;
+    if (nowMs - lastAt < intervalMs) {
+        return false;
+    }
+    lastGcAtMsByServiceId.set(serviceId, nowMs);
+    return true;
+}
+/**
+ * Guard-only: upload pending `.tmp` batches, rename to `.json`, then periodic GC.
+ * Upload completion is implied by `.json` presence; no sync-state file.
+ */
+async function runCollectLogTick(input) {
+    const config = resolveLogSpoolConfig(input.config);
+    const spoolRoot = input.spoolRoot ?? resolveLogSpoolRoot();
+    const nowMs = input.nowMs ?? Date.now();
+    const result = {
+        uploaded: 0,
+        skipped: 0,
+        failed: 0,
+        gcTmpRemoved: 0,
+        gcSyncedRemoved: 0,
+    };
+    for (const processRole of resolveAllLogSpoolProcessRoles()) {
+        const processDir = logSpoolProcessDir(spoolRoot, input.serviceId, processRole);
+        let names = [];
+        try {
+            names = await readdir(processDir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith(".tmp")) {
+                continue;
+            }
+            const status = await uploadTmpBatch({
+                serviceId: input.serviceId,
+                serviceValue: input.serviceValue,
+                processRole,
+                tmpPath: join(processDir, name),
+                fileName: name,
+                spoolRoot,
+                postTimeoutMs: config.writer.postTimeoutMs,
+            });
+            if (status === "uploaded") {
+                result.uploaded += 1;
+            }
+            else if (status === "skipped") {
+                result.skipped += 1;
+            }
+            else {
+                result.failed += 1;
+            }
+        }
+    }
+    if (shouldRunGc(input.serviceId, nowMs, config.gc.intervalMs)) {
+        for (const processRole of resolveAllLogSpoolProcessRoles()) {
+            result.gcTmpRemoved += await gcTmpFiles({
+                spoolRoot,
+                serviceId: input.serviceId,
+                processRole,
+                tmpRetentionMs: config.gc.tmpRetentionMs,
+                nowMs,
+            });
+        }
+        result.gcSyncedRemoved = await gcSyncedJsonFiles({
+            spoolRoot,
+            serviceId: input.serviceId,
+            syncedRetentionMs: config.gc.syncedRetentionMs,
+            nowMs,
+        });
+    }
+    if (result.uploaded > 0 || result.failed > 0) {
+        spoolLogger.info("collect-log tick complete", { ...result, serviceId: input.serviceId });
+    }
+    return result;
+}
+
+const COLLECT_LOG_RUNNER_KEY = "collect-log";
+/**
+ * Guard process only — uploads `.tmp` spool batches and runs GC.
+ * Register before {@link TriggerNode.start} (e.g. in {@link ServiceGuardNode.create}).
+ */
+function registerCollectLogRunner(options) {
+    if (!logSpoolEnabledFromEnv()) {
+        return;
+    }
+    const config = logSpoolConfigFromEnv();
+    const intervalMs = options.intervalMs ?? config.collectIntervalMs;
+    TriggerManager.registerRunner({
+        key: options.runnerKey ?? COLLECT_LOG_RUNNER_KEY,
+        intervalMs,
+        initialDelayMs: options.initialDelayMs ?? 0,
+        retryCount: 1,
+        fn: async (ctx) => {
+            const serviceId = await options.getServiceId();
+            if (serviceId == null) {
+                ctx.logger.warn("collect-log skipped — serviceId unavailable", { topic: LOG_TOPIC_TRIGGER });
+                return;
+            }
+            const result = await runCollectLogTick({
+                serviceId,
+                serviceValue: options.serviceValue,
+                spoolRoot: options.spoolRoot,
+                config,
+            });
+            if (result.uploaded > 0 || result.failed > 0) {
+                ctx.logger.info("collect-log runner finished", {
+                    topic: LOG_TOPIC_TRIGGER,
+                    data: result,
+                });
+            }
+        },
+    });
+    spoolLogger.info("collect-log runner registered", {
+        intervalMs,
+        serviceValue: options.serviceValue,
+    });
+}
+
 /**
  * Run registry slot ownership check and optionally SIGTERM the parent main process.
  * Used by guard / supervisor TriggerNode runners across L3 services.
@@ -1646,6 +2069,10 @@ class ServiceGuardNode extends TriggerNode {
             logTopic: options.logTopic,
             ...options.guardRunner,
         });
+        registerCollectLogRunner({
+            serviceValue: options.serviceValue,
+            getServiceId: options.guardRunner.getServiceId,
+        });
         return new ServiceGuardNode(options);
     }
     async onBeforeRegisterNode(nodeLogger) {
@@ -1735,11 +2162,21 @@ function createServiceHost(options) {
             }
             throw error;
         }
+        const hostCtx = { service: session.service, session, serviceId: session.service.id };
         if (options.onRegistryClaimed != null) {
-            await options.onRegistryClaimed({ service: session.service, session });
+            await options.onRegistryClaimed(hostCtx);
+        }
+        const enableSpool = options.enableLogSpoolAfterClaim ?? true;
+        if (enableSpool && logSpoolEnabledFromEnv()) {
+            process.env[LOG_SPOOL_SERVICE_ID_ENV] = session.service.id;
+            await ensureLogSpoolFromEnv({
+                serviceId: session.service.id,
+                serviceValue: options.serviceValue,
+                processRole: "main",
+            });
         }
         if (options.startSupervisors != null) {
-            await options.startSupervisors();
+            await options.startSupervisors(hostCtx);
         }
         if (options.waitUntilReady != null) {
             await options.waitUntilReady();
@@ -2265,58 +2702,66 @@ const RepoManager = {
     clearRepoScriptModuleCache,
 };
 
-/**
- * Bind service-specific log-persist registry settings (process list, paths, timeouts).
- * Each L3 service exports one instance from `src/startup/log-persist.ts`.
- */
-function createLogPersistCoordinator(options) {
-    const { service, registryFilePath, expectedProcesses, readyTimeoutMs } = options;
+function createLogSpoolCoordinator(options) {
+    const { serviceValue, serviceId } = options;
     return {
         isEnabled() {
-            return logPersistEnabledFromEnv();
+            return logSpoolEnabledFromEnv();
         },
-        getRegistryFilePath() {
-            return registryFilePath;
+        getServiceId() {
+            return serviceId;
         },
         registerProcess(process) {
-            return ensureLogPersistFromEnv({
-                process,
-                service,
-                registryFilePath,
-            });
-        },
-        waitForAllProcessesReady() {
-            return waitForLogPersistReady({
-                registryFilePath,
-                service,
-                expectedProcesses: [...expectedProcesses],
-                timeoutMs: readyTimeoutMs,
-            });
-        },
-        async snapshotProcessesReady() {
-            if (!logPersistEnabledFromEnv()) {
-                return null;
-            }
-            return snapshotLogPersistReady({
-                registryFilePath,
-                expectedProcesses: [...expectedProcesses],
+            return ensureLogSpoolFromEnv({
+                serviceValue,
+                serviceId,
+                processRole: process,
             });
         },
-        getPersistStats() {
-            if (!logPersistEnabledFromEnv()) {
+        getWriterStats() {
+            if (!logSpoolEnabledFromEnv()) {
                 return null;
             }
-            return getLogPersistStats();
+            return getLogSpoolStats();
         },
-        async shutdownLogPersist() {
-            if (!logPersistEnabledFromEnv()) {
+        async shutdownLogSpool() {
+            if (!logSpoolEnabledFromEnv()) {
                 return;
             }
-            await disableLogPersist();
+            await shutdownLogSpoolFromEnv();
         },
     };
 }
 
+/** Whether file log spool is enabled (`LOG_PERSIST_ENABLED=true`). */
+function isLogSpoolEnabled(env = process.env) {
+    return logSpoolEnabledFromEnv(env);
+}
+/**
+ * Guard / scheduler / worker (and extra roles) — enable writer from spawn env.
+ * Main is enabled by `createServiceHost` after registry claim.
+ */
+async function enableLogSpoolFromEnvInChild() {
+    if (!logSpoolEnabledFromEnv()) {
+        return;
+    }
+    await ensureLogSpoolFromEnv();
+}
+/** Writer buffer stats when spool enabled; `null` when disabled. Typical use: main observability. */
+function getMainLogSpoolWriterStats() {
+    if (!logSpoolEnabledFromEnv()) {
+        return null;
+    }
+    return getLogSpoolStats();
+}
+/** Flush memory buffer and disable writer when spool enabled; no-op otherwise. */
+async function shutdownLogSpool() {
+    if (!logSpoolEnabledFromEnv()) {
+        return;
+    }
+    await shutdownLogSpoolFromEnv();
+}
+
 const EMPTY_RESULT = {
     status: "not_configured",
     registered: [],
@@ -3228,5 +3673,5 @@ const patchTriggerFired = validateWithSchema(patchTriggerFiredSchema, "patchTrig
     }
 });
 
-export { BaseNodeRuntime, CategoryCommand, CategoryNode, CategoryRepo, CategoryTrigger, CommandType, EMPTY_REGISTRY_SLOT_RUNTIME_STATE, LOG_TOPIC_TRIGGER, LogLevel, MAX_POLL_TARGET_LIST_SIZE, ManagedChildProcesses, NodeStatus, RepoManager, ResultCode, SERVICE_GUARD_RUNNER_KEY, ServiceGuardNode, ServiceRegistryError, TASK_LOCAL_PACKAGE_CONFIG_FILENAME, TASK_REPO_SCRIPT_CATEGORY, TASK_REPO_USAGE, TASK_RUNNER_CONFIG_DIR, TASK_RUNNER_ROOT_CONFIG_FILENAME, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TRIGGER_LOOP_INTERVAL_MS, TRIGGER_RUNNER_DEFAULT_RETRY_COUNT, TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS, TaskManager, TaskNode, TaskRepoValidation, TaskStatus, TaskStatusAction, TriggerManager, TriggerNode, TriggerStatus, applyRegistrySlotGuardStep, buildNodeImportArgs, claimServiceRegistrySlot, createJsonFileStateStore, createLogPersistCoordinator, createLogger, createManagedChildProcesses, createPathsExistCheck, createRequiredEnvCheck, createServiceHost, createServiceRuntimeStateStore, createSupabaseReachableCheck, createTarget, disableLogPersist, ensureLogPersistFromEnv, evaluateBusyNodeLiveness, generateResponse, getConfigFileDir, getLogPersistStats, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, getWorkerSpawnCooldownLastAt, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isOptimisticLockResponse, loadCachedJsConfigModule, loadEnvFiles, logManager, logPersistEnabledFromEnv, markWorkerSpawned, nodeBufferToArrayBuffer, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchServiceRuntime, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pathExists, pollTargetList, postCommand, postCommandSchema, postRegisterNode, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, registerServiceGuardRunner, registrySlotRuntimePatchFromGuardResult, requireEnv, resolveFirstExistingPath, resolvePathFromBaseDir, resolvePathFromConfigFile, resolvePathFromCwd, runReadinessChecks, runReadinessGate, runRegistrySlotGuardCheck, runServiceGuardTick, runSingleProcessService, scanEnabledTriggers, scanEnabledTriggersSchema, scanTargetList, sha256Hex, snapshotLogPersistReady, spawnTsxChild, supabase, toFileImportHref, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForLogPersistReady, waitForServiceReady };
+export { BaseNodeRuntime, COLLECT_LOG_RUNNER_KEY, CategoryCommand, CategoryNode, CategoryRepo, CategoryTrigger, CommandType, EMPTY_REGISTRY_SLOT_RUNTIME_STATE, LOG_SPOOL_SERVICE_ID_ENV, LOG_TOPIC_TRIGGER, LogLevel, MAX_POLL_TARGET_LIST_SIZE, ManagedChildProcesses, NodeStatus, RepoManager, ResultCode, SERVICE_GUARD_RUNNER_KEY, ServiceGuardNode, ServiceRegistryError, TASK_LOCAL_PACKAGE_CONFIG_FILENAME, TASK_REPO_SCRIPT_CATEGORY, TASK_REPO_USAGE, TASK_RUNNER_CONFIG_DIR, TASK_RUNNER_ROOT_CONFIG_FILENAME, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TRIGGER_LOOP_INTERVAL_MS, TRIGGER_RUNNER_DEFAULT_RETRY_COUNT, TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS, TaskManager, TaskNode, TaskRepoValidation, TaskStatus, TaskStatusAction, TriggerManager, TriggerNode, TriggerStatus, applyRegistrySlotGuardStep, buildNodeImportArgs, claimServiceRegistrySlot, createJsonFileStateStore, createLogSpoolCoordinator, createLogger, createManagedChildProcesses, createPathsExistCheck, createRequiredEnvCheck, createServiceHost, createServiceRuntimeStateStore, createSupabaseReachableCheck, createTarget, enableLogSpoolFromEnvInChild, ensureLogSpoolFromEnv, evaluateBusyNodeLiveness, generateResponse, getConfigFileDir, getLogSpoolStats, getMainLogSpoolWriterStats, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, getWorkerSpawnCooldownLastAt, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isLogEntry, isLogSpoolEnabled, isOptimisticLockResponse, loadCachedJsConfigModule, loadEnvFiles, logManager, logSpoolEnabledFromEnv, markWorkerSpawned, nodeBufferToArrayBuffer, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchServiceRuntime, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pathExists, pollTargetList, pollUntil, postCommand, postCommandSchema, postRegisterNode, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, registerCollectLogRunner, registerServiceGuardRunner, registrySlotRuntimePatchFromGuardResult, requireEnv, resolveFirstExistingPath, resolveLogSpoolRoot, resolvePathFromBaseDir, resolvePathFromConfigFile, resolvePathFromCwd, runCollectLogTick, runReadinessChecks, runReadinessGate, runRegistrySlotGuardCheck, runServiceGuardTick, runSingleProcessService, scanEnabledTriggers, scanEnabledTriggersSchema, scanTargetList, sha256Hex, shutdownLogSpool, shutdownLogSpoolFromEnv, spawnTsxChild, supabase, toFileImportHref, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForServiceReady };
 //# sourceMappingURL=node.js.map