sneakoscope 2.0.4 → 2.0.6

package/dist/core/commands/local-model-command.js

@@ -1,4 +1,6 @@
-import { resolveOllamaWorkerConfig, writeLocalModelConfig, readLocalModelConfig } from '../agents/ollama-worker-config.js';
+import { applyLocalLlmSmokeResult, normalizeProvider, resolveOllamaWorkerConfig, writeLocalModelConfig, readLocalModelConfig } from '../agents/ollama-worker-config.js';
+import { detectInstalledLocalModelCandidate, probeLocalLlmEndpoint } from '../local-llm/local-llm-client.js';
+import { runLocalLlmGenerationSmoke, localLlmSmokeSchema } from '../local-llm/local-llm-smoke.js';
 export async function localModelCommand(args = []) {
     const action = normalizeLocalModelAction(args[0]);
     if (action === 'enable')
@@ -28,16 +30,62 @@ function normalizeLocalModelAction(value) {
 async function enable(args) {
     const model = readOption(args, '--model', firstPositional(args) || '');
     const baseUrl = readOption(args, '--base-url', '');
+    const provider = readOption(args, '--provider', '');
     const think = readBoolFlag(args, '--think', '--no-think');
-    const patch = { enabled: true, provider: 'ollama' };
+    const skipSmoke = args.includes('--skip-smoke') || process.env.SKS_LOCAL_LLM_TOGGLE_ONLY === '1';
+    const patch = { enabled: true, status: 'enabled_unverified' };
+    const explicitConfig = Boolean(model || baseUrl || provider);
+    let detection = null;
+    if (!explicitConfig) {
+        detection = await detectInstalledLocalModelCandidate();
+        if (!detection) {
+            const config = await writeLocalModelConfig({ enabled: false, blockers: ['local_model_not_found'] });
+            process.exitCode = 1;
+            return {
+                schema: 'sks.local-model-command.v1',
+                ok: false,
+                action: 'enable',
+                message: '확인해보니 로컬 모델이 존재하지 않아 실행할 수 없습니다.',
+                config,
+                detection: null,
+                blockers: ['local_model_not_found']
+            };
+        }
+        patch.provider = detection.provider;
+        patch.model = detection.model;
+        patch.base_url = detection.base_url;
+        patch.endpoint = detection.endpoint;
+    }
+    if (provider)
+        patch.provider = normalizeProvider(provider);
     if (model)
         patch.model = model;
-    if (baseUrl)
+    if (baseUrl) {
         patch.base_url = baseUrl;
+        patch.endpoint = baseUrl;
+    }
     if (think !== null)
         patch.think = think;
     const config = await writeLocalModelConfig(patch);
-    return { schema: 'sks.local-model-command.v1', ok: true, action: 'enable', config };
+    const smoke = skipSmoke
+        ? { ok: false, skipped: true, status: 'enabled_unverified', reason: 'operator_skip_smoke', schema_valid: false, blockers: ['operator_skip_smoke'] }
+        : await runLocalLlmGenerationSmoke(config, {
+            prompt: 'Return strict JSON: {"status":"ok","summary":"local smoke passed"}',
+            schema: localLlmSmokeSchema,
+            timeoutMs: 20_000
+        });
+    const next = await writeLocalModelConfig(applyLocalLlmSmokeResult(config, smoke));
+    if (!skipSmoke && smoke.ok !== true)
+        process.exitCode = 1;
+    return {
+        schema: 'sks.local-model-command.v1',
+        ok: skipSmoke ? true : smoke.ok === true,
+        action: 'enable',
+        config: next,
+        detection,
+        smoke,
+        blockers: next.blockers
+    };
 }
 async function disable() {
     const config = await writeLocalModelConfig({ enabled: false });
@@ -55,37 +103,35 @@ async function setModel(args) {
 async function status() {
     const config = await readLocalModelConfig();
     const resolved = await resolveOllamaWorkerConfig();
-    const api = await probeOllama(resolved.base_url);
+    const api = await probeLocalLlmEndpoint(resolved);
     return { schema: 'sks.local-model-command.v1', ok: true, action: 'status', config, resolved, api };
 }
-async function probeOllama(baseUrl) {
-    try {
-        const response = await fetch(`${baseUrl}/api/version`, { signal: AbortSignal.timeout(3000) });
-        const text = await response.text();
-        return { ok: response.ok, status: response.status, data: response.ok ? JSON.parse(text) : null };
-    }
-    catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-}
 function emit(result, args) {
     if (args.includes('--json')) {
         console.log(JSON.stringify(result, null, 2));
         return result;
     }
     if (result.ok !== true) {
+        if (result.message)
+            console.log(result.message);
         console.log(`Local model: blocked (${(result.blockers || []).join(', ') || 'unknown'})`);
         return result;
     }
     const config = result.config || result.resolved || {};
     console.log(`Local model: ${config.enabled ? 'enabled' : 'disabled'}`);
-    console.log(`Provider: ollama`);
+    console.log(`Provider: ${config.provider || 'unknown'}`);
     console.log(`Model: ${config.model || 'unknown'}`);
     console.log(`Base URL: ${config.base_url || config.baseUrl || 'unknown'}`);
+    if (config.status)
+        console.log(`Status: ${config.status}`);
+    if (result.detection)
+        console.log(`Detected: ${result.detection.source}`);
+    if (config.last_smoke?.result_path)
+        console.log(`Smoke: ${config.last_smoke.ok ? 'ok' : 'failed'} ${config.last_smoke.result_path}`);
     if (typeof config.think === 'boolean')
         console.log(`Think: ${config.think ? 'enabled' : 'disabled'}`);
     if (result.api)
-        console.log(`Ollama API: ${result.api.ok ? 'ok' : 'not reachable'}`);
+        console.log(`Local model API: ${result.api.ok ? 'ok' : 'not reachable'}`);
     return result;
 }
 function readOption(args, name, fallback) {
@@ -105,12 +151,12 @@ function readBoolFlag(args, trueName, falseName) {
 function firstPositional(args = []) {
     for (let i = 0; i < args.length; i += 1) {
         const arg = String(args[i] || '');
-        if (arg === '--model' || arg === '--base-url') {
+        if (arg === '--model' || arg === '--base-url' || arg === '--provider') {
             if (args[i + 1] && !String(args[i + 1]).startsWith('--'))
                 i += 1;
             continue;
         }
-        if (arg.startsWith('--model=') || arg.startsWith('--base-url='))
+        if (arg.startsWith('--model=') || arg.startsWith('--base-url=') || arg.startsWith('--provider='))
             continue;
         if (!arg.startsWith('--'))
             return arg;

package/dist/core/commands/naruto-command.js

@@ -1,12 +1,20 @@
 import path from 'node:path';
 import { createMission, findLatestMission, loadMission } from '../mission.js';
-import { readJson, sksRoot } from '../fsx.js';
+import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
 import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/agent-roster.js';
 import { DEFAULT_NARUTO_CLONES, MAX_NARUTO_AGENT_COUNT } from '../agents/agent-schema.js';
 import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
 import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/zellij-launcher.js';
+import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
+import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
+import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
+import { simulateNarutoActivePool } from '../naruto/naruto-active-pool.js';
+import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
+import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
+import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
+import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -25,6 +33,28 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
 }
 async function narutoRun(parsed) {
     const root = await sksRoot();
+    const writeCapable = parsed.readonly !== true && parsed.writeMode !== 'off';
+    const patchEnvelopeBasePath = '.sneakoscope/naruto/patch-envelopes';
+    const placeholderGuard = checkPromptPlaceholders({
+        prompt: parsed.prompt,
+        writeCapable,
+        targetPaths: writeCapable ? [patchEnvelopeBasePath] : []
+    });
+    if (!placeholderGuard.ok) {
+        return emit(parsed, {
+            schema: NARUTO_RESULT_SCHEMA,
+            ok: false,
+            mode: 'NARUTO',
+            action: 'run',
+            status: 'blocked',
+            prompt_placeholder_guard: placeholderGuard,
+            blockers: placeholderGuard.blockers
+        }, () => {
+            console.log('$Naruto blocked before work graph creation: unresolved prompt placeholder or empty write target path.');
+            for (const blocker of placeholderGuard.blockers)
+                console.log('- ' + blocker);
+        });
+    }
     const roster = buildNarutoCloneRoster({
         clones: parsed.clones,
         prompt: parsed.prompt,
@@ -37,9 +67,52 @@ async function narutoRun(parsed) {
     const localWorker = await resolveNarutoLocalWorkerMode(parsed);
     const schedulerBackend = localWorker.auto_select_eligible ? 'ollama' : parsed.backend;
     const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || safe.cap));
+    const workGraph = buildNarutoWorkGraph({
+        prompt: parsed.prompt,
+        requestedClones: roster.agent_count,
+        totalWorkItems: parsed.workItems,
+        readonly: parsed.readonly,
+        writeCapable,
+        leaseBasePath: patchEnvelopeBasePath,
+        maxActiveWorkers: parsed.concurrency || safe.cap
+    });
+    const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
+    const governor = decideNarutoConcurrency({
+        requestedClones: roster.agent_count,
+        totalWorkItems: workGraph.total_work_items,
+        pendingWorkQueueSize: workGraph.total_work_items,
+        backend: schedulerBackend
+    });
+    const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
+    const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
+    const activePool = simulateNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
+    const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
+    const gptFinalPack = buildNarutoGptFinalPack({
+        missionId: 'pending',
+        graph: workGraph,
+        roleDistribution,
+        localLlmMetrics: localWorker
+    });
+    const zellijDashboard = planNarutoZellijDashboard({
+        targetActiveWorkers: activeSlots,
+        visiblePaneCap: governor.safe_zellij_visible_panes,
+        backpressure: governor.backpressure,
+        roles: roleDistribution.work_item_roles.map((row) => row.role),
+        backend: schedulerBackend
+    });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     const ledgerRoot = path.join(mission.dir, 'agents');
+    await writeNarutoArtifacts(ledgerRoot, {
+        workGraph,
+        roleDistribution,
+        governor,
+        activePool,
+        verificationDag,
+        gptFinalPack: { ...gptFinalPack, mission_id: mission.id },
+        zellijDashboard,
+        placeholderGuard
+    });
     let liveZellij = null;
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
@@ -47,12 +120,12 @@ async function narutoRun(parsed) {
             missionId: mission.id,
             ledgerRoot,
             kind: 'naruto',
-            slotCount: roster.agent_count,
+            slotCount: zellijVisiblePanes,
             dryRun: false,
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
-            console.log('Zellij: prepared ' + roster.agent_count + ' live clone lane(s) in ' + liveZellij.session_name + '. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
+            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
         }
@@ -73,7 +146,7 @@ async function narutoRun(parsed) {
         agents: roster.agent_count,
         concurrency: activeSlots,
         targetActiveSlots: activeSlots,
-        visualLaneCount: roster.agent_count,
+        visualLaneCount: zellijVisiblePanes,
         desiredWorkItemCount: parsed.workItems,
         maxAgentCount: MAX_NARUTO_AGENT_COUNT,
         narutoMode: true,
@@ -91,7 +164,7 @@ async function narutoRun(parsed) {
         fastMode: true,
         serviceTier: 'fast',
         noFast: false,
-        ...(parsed.writeMode ? { writeMode: parsed.writeMode } : {}),
+        writeMode: writeCapable ? parsed.writeMode || 'parallel' : 'off',
         json: parsed.json
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
@@ -109,6 +182,22 @@ async function narutoRun(parsed) {
         target_active_slots: result.target_active_slots ?? activeSlots,
         concurrency_capped: clones > (result.target_active_slots ?? activeSlots),
         system: { cores: safe.cores, free_gb: safe.free_gb, safe_concurrency: safe.cap, heavy_backend: safe.heavy },
+        work_graph: {
+            total_work_items: workGraph.total_work_items,
+            mixed_work_kinds: workGraph.mixed_work_kinds,
+            write_allowed_count: workGraph.write_allowed_count,
+            active_wave_count: workGraph.active_waves.length,
+            parallel_write_wave_count: workGraph.active_waves.filter((wave) => wave.write_paths.length > 1).length,
+            ok: workGraph.ok
+        },
+        role_distribution: roleDistribution,
+        concurrency_governor: governor,
+        active_pool: {
+            ok: activePool.ok,
+            max_observed_active_workers: activePool.max_observed_active_workers,
+            refill_events: activePool.refill_events,
+            completed_count: activePool.completed_count
+        },
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
         run: result,
@@ -120,9 +209,10 @@ async function narutoRun(parsed) {
         console.log('Mission: ' + result.mission_id);
         console.log('Clones: ' + summary.clones + ' / max ' + MAX_NARUTO_AGENT_COUNT + ', running ' + summary.target_active_slots + ' at a time' + (summary.concurrency_capped ? ` (throttled to host capacity: ${safe.cores} cores, ${safe.free_gb} GB free)` : ''));
         console.log('Backend: ' + result.backend);
+        console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
         if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok')
-            console.log('Zellij: prepared ' + summary.clones + ' native clone lane(s) in ' + summary.zellij.session_name);
+            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + summary.zellij.session_name + '; dashboard tracks ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s)');
         else if (summary.zellij?.ok)
             console.log('Zellij: optional live panes unavailable (' + ((summary.zellij.warnings || []).join('; ') || summary.zellij.capability?.status || 'unknown') + ')');
     });
@@ -148,6 +238,9 @@ async function narutoStatus(parsed) {
     const { dir } = await loadMission(root, id);
     const proof = await readJson(path.join(dir, 'agents', 'agent-proof-evidence.json'), null);
     const scheduler = await readJson(path.join(dir, 'agents', 'agent-scheduler-state.json'), null);
+    const roleDistribution = await readJson(path.join(dir, 'agents', 'naruto-role-distribution.json'), null);
+    const workGraph = await readJson(path.join(dir, 'agents', 'naruto-work-graph.json'), null);
+    const governor = await readJson(path.join(dir, 'agents', 'naruto-concurrency-governor.json'), null);
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: proof !== null,
@@ -156,13 +249,24 @@ async function narutoStatus(parsed) {
         proof: proof?.status || 'missing',
         target_active_slots: scheduler?.target_active_slots ?? null,
         max_active_slots: scheduler?.max_active_slots ?? null,
-        completed: scheduler?.completed_count ?? null
+        completed: scheduler?.completed_count ?? null,
+        role_distribution: roleDistribution,
+        work_graph: workGraph ? {
+            total_work_items: workGraph.total_work_items,
+            mixed_work_kinds: workGraph.mixed_work_kinds,
+            write_allowed_count: workGraph.write_allowed_count,
+            active_wave_count: Array.isArray(workGraph.active_waves) ? workGraph.active_waves.length : null,
+            parallel_write_wave_count: Array.isArray(workGraph.active_waves) ? workGraph.active_waves.filter((wave) => Array.isArray(wave.write_paths) && wave.write_paths.length > 1).length : null
+        } : null,
+        concurrency_governor: governor
     };
     return emit(parsed, summary, () => {
         console.log('🍥 Naruto mission: ' + id);
         console.log('Proof: ' + summary.proof);
         if (summary.target_active_slots !== null)
             console.log('Active clones: ' + summary.target_active_slots + ' / max ' + summary.max_active_slots);
+        if (roleDistribution?.entries)
+            console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
     });
 }
 async function narutoHelp(parsed) {
@@ -186,6 +290,8 @@ async function narutoHelp(parsed) {
     });
 }
 function parseNarutoArgs(args = []) {
+    if (hasFlag(args, '--help') || hasFlag(args, '-h'))
+        args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
     const actions = new Set(['run', 'status', 'help']);
     const action = (actions.has(first) ? first : 'run');
@@ -213,6 +319,16 @@ function parseNarutoArgs(args = []) {
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
     return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach };
 }
+async function writeNarutoArtifacts(ledgerRoot, artifacts) {
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-concurrency-governor.json'), artifacts.governor);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-active-pool.json'), artifacts.activePool);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-verification-dag.json'), artifacts.verificationDag);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);
+    await writeJsonAtomic(path.join(ledgerRoot, 'prompt-placeholder-guard.json'), artifacts.placeholderGuard);
+}
 function clampClones(value) {
     if (!Number.isFinite(value) || value < 1)
         return DEFAULT_NARUTO_CLONES;

package/dist/core/commands/run-command.js

@@ -290,7 +290,7 @@ async function runSks(root, commandArgs) {
         cwd: root,
         timeoutMs: 180_000,
         maxOutputBytes: 512 * 1024,
-        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
+        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_LOCAL_LLM_TOGGLE_ONLY: '1', CI: 'true' },
     });
 }
 function routeExecutionResult(route, command, result, options = {}) {

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -54,6 +54,14 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('codex_app_fast_selector_repaired_restart_app_if_needed');
     if (input.codex_lb?.ok === false)
         warnings.add(`codex_lb_${input.codex_lb?.circuit?.state || 'blocked'}`);
+    const localModel = input.local_model || {};
+    const localStatus = String(localModel.status || (localModel.enabled ? 'enabled_unverified' : 'disabled'));
+    if (localModel.enabled === true && localStatus === 'enabled_unverified')
+        warnings.add('local_llm_enabled_unverified');
+    if (localModel.enabled === true && localStatus === 'degraded')
+        warnings.add('local_llm_degraded');
+    if (localModel.enabled === true && localStatus === 'blocked')
+        warnings.add('local_llm_blocked_worker_tier_disabled');
     const localCollaborationPolicy = resolveLocalCollaborationPolicy({ mode: input.local_collaboration?.mode || null });
     const gptFinalAvailable = input.local_collaboration?.gpt_final_arbiter_available === undefined
         ? codexBinOk
@@ -101,12 +109,23 @@ export function buildDoctorReadinessMatrix(input = {}) {
         codex_app_required_for_cli: false,
         local_collaboration: {
             mode: localCollaborationPolicy.mode,
-            local_backend: input.local_collaboration?.local_backend || input.local_model?.provider || 'ollama',
-            local_model: input.local_collaboration?.local_model || input.local_model?.model || null,
+            local_backend: input.local_collaboration?.local_backend || localModel.provider || 'ollama',
+            local_model: input.local_collaboration?.local_model || localModel.model || null,
             final_arbiter: gptFinalAvailable ? 'GPT available' : 'missing',
             final_apply_allowed: localCollaborationPolicy.gpt_final_required ? gptFinalAvailable : localCollaborationPolicy.mode === 'disabled',
             blockers: localCollaborationPolicy.gpt_final_required && !gptFinalAvailable ? ['gpt_final_arbiter_unavailable'] : localCollaborationPolicy.blockers
         },
+        local_llm: {
+            enabled: localModel.enabled === true,
+            status: localStatus,
+            provider: localModel.provider || 'ollama',
+            model: localModel.model || null,
+            endpoint: localModel.endpoint || localModel.base_url || null,
+            last_smoke: localModel.last_smoke || null,
+            final_arbiter: 'GPT required',
+            worker_tier_enabled: localModel.enabled === true && localStatus === 'verified',
+            blockers: normalizeList(localModel.blockers)
+        },
         ready: blockers.size === 0 && cliReady,
         primary_blocker: [...blockers][0] || null,
         blockers: [...blockers],

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.4';
+export const PACKAGE_VERSION = '2.0.6';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {