@jinn-network/client 0.1.9-canary.5c19fc6d → 0.1.9-canary.5ff3d8cb

package/dist/main.js

@@ -24,33 +24,35 @@ import { homedir, hostname, userInfo } from 'node:os';
 import { randomBytes as cryptoRandomBytes } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { loadConfig, getConfigPathFromArgs, DEFAULT_CONFIG_PATH } from './config.js';
+import { loadConfig, getConfigPathFromArgs, DEFAULT_CONFIG_PATH, DEFAULT_TESTNET_RPC_URLS } from './config.js';
 import { Store } from './store/store.js';
 import { startApiServer, isEmbeddedAgentEnabled } from './api/server.js';
-import { setDefaultTxSubmissionLedger } from './tx-retry.js';
+import { setDefaultTxSubmissionLedger, withEoaBroadcastLock } from './tx-retry.js';
 // addHarnessReadinessRoutes is wired through startApiServer's holder ref now
 // (jinn-mono-u34i). No direct import needed.
 import { CapturePublishUnavailableError } from './api/captures.js';
 import { invalidatePredictionOperatorStatusCache } from './api/gather-status.js';
 import { ensureUiToken } from './api/ui-token.js';
 import { getFileLogger, closeFileLogger } from './observability/file-logger.js';
+import { emitProgress } from './observability/progress.js';
 import { hashImplStateDir } from './harnesses/freeze.js';
 import { readModeState } from './harnesses/mode-state.js';
 import { attachAgentWs, updateAgentClaudePath } from './agent/agent-ws.js';
 import { createSetupModeController } from './setup-mode.js';
 import { requestDaemonRestart } from './restart-daemon.js';
-import { buildEnvelope, emitEnvelope } from './errors/envelope.js';
-import { clearBootstrapError, persistBootstrapError, } from './errors/persisted-bootstrap-error.js';
+import { emitEnvelope } from './errors/envelope.js';
 import { emitStructured } from './events/emitter.js';
 import { applyPidfileLivenessGate } from './preflight/pidfile-liveness.js';
 import { applyDeploymentReadinessGate } from './preflight/deployment-readiness.js';
+import { ensureStableCwd } from './preflight/stable-cwd.js';
 import { detectAuthContext } from './preflight/claude-auth.js';
 import { FleetBootstrapper, recoverEvictedService as recoverEvictedServiceFn } from './earning/bootstrap.js';
+import { runFleetBootstrap, SetupBootstrapHalted } from './earning/bootstrap-run.js';
 import { applyChainGasOverrides, getChainConfig } from './earning/contracts.js';
-import { runLegacyAgentIdMigration } from './earning/migrate-agent-id.js';
+import { getJinnRouterAddress } from './contracts/addresses.js';
 import { FleetStateStore } from './earning/store.js';
-import { isOperationalServiceStep, } from './earning/types.js';
-import { decryptMnemonic, deriveMasterSigner, walletPrivateKeyAtIndex } from './earning/wallet.js';
+import { isOperationalServiceStep } from './earning/types.js';
+import { decryptMnemonic, deriveMasterSigner } from './earning/wallet.js';
 import { MechAdapter } from './adapters/mech/adapter.js';
 import { ClaudeRunner } from './runner/claude.js';
 import { Daemon } from './daemon/daemon.js';
@@ -74,6 +76,7 @@ import { createCorpus } from './corpus/index.js';
 import { DEFAULT_EXECUTION_DISCOVERY_FROM_BLOCK } from './corpus/onchain-query.js';
 import { CapturesStore } from './store/captures.js';
 import { createLiveCapturePublisher } from './captures/live-publisher.js';
+import { EnsurePendingCaptureProcessor, ensurePendingCapture, ingestStopHookCapture } from './captures/ingest.js';
 import { startReceiver } from './trajectory/receiver.js';
 import { startSyntheticSpanProvider, emitSyntheticSpan } from './trajectory/synthetic-span-builder.js';
 import { CredentialScrubProcessor } from './trajectory/processors/credential-scrub.js';
@@ -83,10 +86,6 @@ import { PathScrubProcessor } from './trajectory/processors/path-scrub.js';
 import { buildScrubPipeline } from './trajectory/scrub/build.js';
 import { maybeBuildPiiDetector } from './trajectory/scrub/pii-build.js';
 import { SqliteExporterProcessor } from './trajectory/processors/sqlite-exporter.js';
-import { ClaudeCodeJsonlParser } from './trajectory/transcript-parsers/claude-code-jsonl.js';
-import { CodexSessionParser } from './trajectory/transcript-parsers/codex-session.js';
-import { GeminiSessionParser } from './trajectory/transcript-parsers/gemini-session.js';
-import { CursorSqliteParser } from './trajectory/transcript-parsers/cursor-sqlite.js';
 import { startTranscriptWatcher, } from './trajectory/transcript-watcher.js';
 import { defaultTranscriptWatchDirectories } from './trajectory/transcript-session-dirs.js';
 import { buildInfo } from './build-info.js';
@@ -95,7 +94,6 @@ import { GeneratedTaskSource, StaticConfiguredTaskSource, filterBindableTasks }
 import { checkRpcNetwork, logRpcLocalDevToStderr, probeFallbackChain, rpcNetworkFailureHint, summarizeFallbackChain, } from './preflight/rpc-network.js';
 import { apiPortFailureMessage, checkApiPortAvailable } from './preflight/api-port.js';
 import { openBrowser } from './cli/open-browser.js';
-import { keepSetupUiOnBootstrapError } from './setup/halt-mode.js';
 if (process.env['JINN_LOAD_DEV_ENV'] === '1' || process.env['NODE_ENV'] === 'development') {
     dotenvConfig({ path: join(dirname(fileURLToPath(import.meta.url)), '..', '.env') });
 }
@@ -183,456 +181,40 @@ const CHAIN_CONFIG = applyChainGasOverrides(getChainConfig(NETWORK_CHAIN, {
     minSafeEthWei: config.minSafeEthWei,
 });
 const MARKETPLACE_ADDRESS = CHAIN_CONFIG.mechMarketplace;
-const ROUTER_ADDRESS = (CHAIN_CONFIG.jinnRouter ?? '0xfFa7118A3D820cd4E820010837D65FAfF463181B');
-class EnsurePendingCaptureProcessor {
-    captures;
-    constructor(captures) {
-        this.captures = captures;
-    }
-    forceFlush() { return Promise.resolve(); }
-    shutdown() { return Promise.resolve(); }
-    onStart() { }
-    onEnd(span) {
-        const sessionId = stringAttribute(span.attributes['jinn.session.id']);
-        if (!sessionId)
-            return;
-        ensurePendingCapture(this.captures, {
-            sessionId,
-            capturedAt: hrTimeToIso(span.startTime),
-            tool: inferCaptureTool(span),
-            capturePath: inferCapturePath(span),
-            ...repoMetadataFromSpan(span),
-        });
-    }
-}
-function stringAttribute(value) {
-    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
-}
-function hrTimeToIso(time) {
-    const millis = (time[0] * 1000) + Math.floor(time[1] / 1_000_000);
-    return new Date(millis).toISOString();
-}
-function inferCaptureTool(span) {
-    return stringAttribute(span.attributes['transcript.tool'])
-        ?? stringAttribute(span.resource.attributes['service.name'])
-        ?? 'otel';
-}
-function inferCapturePath(span) {
-    if (stringAttribute(span.attributes['transcript.tool']))
-        return 'B';
-    return 'A';
-}
-function repoMetadataFromSpan(span) {
-    const attrs = span.attributes;
-    const repoRemoteUrl = stringAttribute(attrs['repo.remote_url'])
-        ?? stringAttribute(attrs['vcs.repository.url'])
-        ?? stringAttribute(attrs['git.remote_url']);
-    const repoCommitHash = stringAttribute(attrs['repo.commit_hash'])
-        ?? stringAttribute(attrs['vcs.ref.head.revision'])
-        ?? stringAttribute(attrs['git.commit']);
-    return {
-        ...(repoRemoteUrl ? { repoRemoteUrl } : {}),
-        ...(repoCommitHash ? { repoCommitHash } : {}),
-    };
-}
-function parserForStopHookTool(tool) {
-    switch (tool) {
-        case 'claude-code':
-            return new ClaudeCodeJsonlParser();
-        case 'codex':
-            return new CodexSessionParser();
-        case 'gemini-cli':
-            return new GeminiSessionParser();
-        case 'cursor':
-            return new CursorSqliteParser();
-        default: {
-            const exhaustive = tool;
-            throw new Error(`No transcript parser for stop-hook tool: ${String(exhaustive)}`);
-        }
-    }
-}
-function ensurePendingCapture(captures, params) {
-    if (captures.getBySession(params.sessionId))
-        return;
-    try {
-        captures.savePending({
-            sessionId: params.sessionId,
-            capturedAt: params.capturedAt,
-            originatingTool: { name: params.tool },
-            capturePath: params.capturePath,
-            status: 'pending',
-            spanCount: 0,
-            durationMs: 0,
-            redactedSpanCount: 0,
-            ...(params.repoRemoteUrl ? { repoRemoteUrl: params.repoRemoteUrl } : {}),
-            ...(params.repoCommitHash ? { repoCommitHash: params.repoCommitHash } : {}),
-        });
-    }
-    catch (err) {
-        if (!captures.getBySession(params.sessionId))
-            throw err;
-    }
-}
-async function ingestStopHookCapture(captures, receiver, payload) {
-    ensurePendingCapture(captures, {
-        sessionId: payload.sessionId,
-        capturedAt: payload.stoppedAt,
-        tool: payload.tool,
-        capturePath: 'D',
-    });
-    if (!payload.transcriptPath)
-        return;
-    if (!receiver) {
-        console.warn('[main] stop-hook capture received but OTLP receiver is unavailable; pending capture has no transcript spans.');
-        return;
-    }
-    const parser = parserForStopHookTool(payload.tool);
-    let events;
-    try {
-        events = await parser.parseFull({ sessionId: payload.sessionId, path: payload.transcriptPath });
-    }
-    catch (err) {
-        console.warn(`[main] stop-hook transcript import failed for ${payload.transcriptPath}: ` +
-            `${err instanceof Error ? err.message : String(err)}`);
-        return;
-    }
-    if (events.length === 0)
-        return;
-    const provider = startSyntheticSpanProvider({
-        otlpHttpEndpoint: `http://127.0.0.1:${receiver.httpPort}/v1/traces`,
-    });
+const ROUTER_ADDRESS = (CHAIN_CONFIG.jinnRouter ?? getJinnRouterAddress(CHAIN_CONFIG.chainId));
+/** #913: the bundled public RPC fallback chain for the current network. The
+ *  setup/network endpoint persists `[primary, ...RPC_PUBLIC_DEFAULTS]` so the
+ *  operator keeps the public backup chain when they set a primary, and the
+ *  Settings → Network UI renders these as the trailing read-only slots. */
+const RPC_PUBLIC_DEFAULTS = NETWORK_CHAIN === 'base-sepolia' ? DEFAULT_TESTNET_RPC_URLS : [CHAIN_CONFIG.rpcUrl];
+/** #913: last L2 boot-probe result per RPC slot. Captured at boot, surfaced
+ *  via /v1/bootstrap so Settings → Network can render per-slot health. Hosts
+ *  are already masked by probeFallbackChain. The RPC chain is restart-required,
+ *  so this never drifts without a re-probing restart. */
+let lastL2Probe = [];
+function configFileHasTopLevelKey(configPath, key) {
+    const filePath = configPath ?? join(process.env['HOME'] ?? '', '.jinn-client', 'config.json');
+    if (!filePath || !existsSync(filePath))
+        return false;
     try {
-        for (const event of events) {
-            emitSyntheticSpan(provider, { tool: parser.tool, sessionId: payload.sessionId, event });
-        }
-        await provider.flush();
+        const raw = JSON.parse(readFileSync(filePath, 'utf8'));
+        return !!raw && typeof raw === 'object' && Object.prototype.hasOwnProperty.call(raw, key);
     }
-    finally {
-        await provider.shutdown();
-    }
-}
-const STANDARD_SERVICE_PROGRESSION = [
-    'awaiting_stake',
-    'staked',
-    'mech_deployed',
-    'agent_registered',
-    'safe_binding_pending',
-    'complete',
-];
-const SELF_BOND_SERVICE_PROGRESSION = [
-    'awaiting_stake',
-    'service_created',
-    'service_activated',
-    'agents_registered',
-    'service_deployed',
-    'service_staked',
-    'mech_deployed',
-    'agent_registered',
-    'safe_binding_pending',
-    'complete',
-];
-/** §6.2 `bootstrap_incomplete` — `{ currentStep, nextStep }` from persisted fleet state. */
-function bootstrapIncompleteSteps(state) {
-    const progression = state.staking_mode === 'self-bond'
-        ? SELF_BOND_SERVICE_PROGRESSION
-        : STANDARD_SERVICE_PROGRESSION;
-    const byIndex = [...state.services].sort((a, b) => a.index - b.index);
-    const focus = byIndex.find(s => isOperationalServiceStep(s.step) && !s.safe_address) ??
-        byIndex.find(s => !isOperationalServiceStep(s.step)) ??
-        byIndex.find(s => s.step === 'safe_binding_pending') ??
-        byIndex[0];
-    if (!focus) {
-        return { currentStep: 'awaiting_service', nextStep: 'awaiting_stake' };
-    }
-    if (isOperationalServiceStep(focus.step) && !focus.safe_address) {
-        return { currentStep: 'complete', nextStep: 'bootstrap' };
-    }
-    const i = progression.indexOf(focus.step);
-    if (i === -1) {
-        return { currentStep: focus.step, nextStep: 'bootstrap' };
-    }
-    if (i < progression.length - 1) {
-        return { currentStep: focus.step, nextStep: progression[i + 1] };
-    }
-    return { currentStep: focus.step, nextStep: 'bootstrap' };
-}
-// ── Bootstrap ───────────────────────────────────────────────────────────────
-async function bootstrap() {
-    console.log('[main] Running fleet bootstrap...');
-    // A fresh bootstrap attempt clears any stale error breadcrumb. If this run
-    // hits the same failure, it'll be re-persisted below; if it succeeds (or
-    // proceeds past the previously-failed step), the panel returns to a clean
-    // state on the next /v1/bootstrap poll.
-    clearBootstrapError(config.earningDir);
-    // Persist the envelope to disk before emitEnvelope's process.exit fires,
-    // so /v1/bootstrap can surface it to the panel after the daemon has
-    // exited (operator restart → panel reload → error visible).
-    function failBootstrap(input) {
-        const envelope = buildEnvelope(input);
-        persistBootstrapError(envelope, config.earningDir);
-        if (keepSetupUiOnBootstrapError()) {
-            emitStructured({
-                kind: 'error',
-                message: envelope.message,
-                errorCode: envelope.code,
-                details: {
-                    phase: 'bootstrap',
-                    exitCode: envelope.exitCode,
-                    ...(envelope.details ?? {}),
-                },
-            });
-            console.error(`[main] Bootstrap halted (${envelope.code}); setup UI remains available. ` +
-                `Resolve the issue and run jinn run again.`);
-            throw new SetupBootstrapHalted(envelope);
-        }
-        emitEnvelope(input);
-        // Unreachable in production (emitEnvelope exits); satisfies `never`.
-        throw new Error('unreachable');
-    }
-    const bootstrapper = new FleetBootstrapper({
-        earningDir: config.earningDir,
-        chain: NETWORK_CHAIN,
-        rpcUrl: config.rpcUrl,
-        stakingMode: config.stakingMode,
-        targetServices: config.targetServices,
-        testnetL2DeploymentPath: config.testnetL2DeploymentPath,
-        testnetL2TokenDeploymentPath: config.testnetL2TokenDeploymentPath,
-        testnetMechDeploymentPath: config.testnetMechDeploymentPath,
-        testnetStolasDeploymentPath: config.testnetStolasDeploymentPath,
-        debug: config.debug,
-        masterEthDailyEstimateWei: config.masterEthDailyEstimateWei,
-        minEoaGasWei: config.minEoaGasWei,
-        minSafeEthWei: config.minSafeEthWei,
-        pollIntervalMs: config.pollIntervalMs,
-        autoTestnetFaucet: process.env['JINN_AUTO_TESTNET_FAUCET'] === '1',
-    });
-    // Funding poll: stay up while waiting for the operator to fund the wallet.
-    // The setup-mode API server is already running; the panel renders the
-    // funding card and auto-advances when funds land. Daemon-side, we poll
-    // bootstrap on a 15s tick and only escalate (exit) if a non-funding error
-    // occurs or the configured timeout elapses. Each tick re-runs the full
-    // bootstrap state machine — completed steps are no-ops, so this is safe.
-    // Testnet faucet funding is panel-driven: bootstrap reports the funding gate,
-    // and the operator clicks the funding action before this loop can advance.
-    const FUNDING_POLL_INTERVAL_MS = 15_000;
-    const fundingTimeoutMs = (() => {
-        const raw = process.env['JINN_FUNDING_TIMEOUT_MS'];
-        if (!raw)
-            return Number.POSITIVE_INFINITY;
-        const n = Number.parseInt(raw, 10);
-        return Number.isFinite(n) && n > 0 ? n : Number.POSITIVE_INFINITY;
-    })();
-    emitProgress({
-        type: 'progress',
-        phase: 'bootstrap',
-        step: 'advance_state_machine',
-        estimatedWaitMs: 60_000,
-    });
-    const fundingStartedAt = Date.now();
-    let result;
-    let lastFundingMessage = '';
-    const fundingGatePath = join(config.earningDir, 'bootstrap-funding.json');
-    const persistFundingGate = (funding) => {
-        mkdirSync(config.earningDir, { recursive: true, mode: 0o700 });
-        writeFileSyncMain(fundingGatePath, `${JSON.stringify({
-            schemaVersion: 1,
-            generatedAt: new Date().toISOString(),
-            ...funding,
-        }, null, 2)}\n`, { mode: 0o600 });
-    };
-    const clearFundingGate = () => {
-        try {
-            unlinkSync(fundingGatePath);
-        }
-        catch {
-            // best-effort: absent/stale funding gate should not affect bootstrap
-        }
-    };
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        result = await bootstrapper.ensureStage1And2(PASSWORD);
-        if (!result.funding) {
-            clearFundingGate();
-            break;
-        }
-        persistFundingGate(result.funding);
-        // Emit a structured event so the panel's Visibility region shows the gate.
-        // Dedupe by message to avoid spamming the ring buffer on each poll.
-        const fundingMsg = result.message ?? 'awaiting funding';
-        if (fundingMsg !== lastFundingMessage) {
-            emitStructured({
-                kind: 'fleet',
-                message: fundingMsg,
-                details: {
-                    phase: 'awaiting_funding',
-                    role: 'master',
-                    address: result.funding.master_address,
-                    asset: 'native',
-                    needWei: result.funding.eth_required,
-                    haveWei: result.funding.eth_balance,
-                },
-            });
-            // Mirror the structured event to NDJSON progress for --json-progress
-            // consumers (CI, agents). Same dedup gate so we don't spam stdout.
-            emitProgress({
-                type: 'progress',
-                phase: 'bootstrap',
-                step: 'awaiting_funding',
-                blocking: true,
-                nextAction: 'Fund the address shown in addresses.fundingAddress, then wait for automatic retry.',
-                addresses: { fundingAddress: result.funding.master_address },
-                estimatedWaitMs: 1_800_000,
-            });
-            lastFundingMessage = fundingMsg;
-        }
-        const elapsed = Date.now() - fundingStartedAt;
-        if (elapsed >= fundingTimeoutMs) {
-            failBootstrap({
-                code: 'funding_required',
-                message: `${result.message} (timeout after ${Math.round(elapsed / 1000)}s)`,
-                hint: 'Fund the listed address and re-run this command.',
-                exampleCli: 'jinn fund-requirements --json',
-                details: {
-                    // jinn-mono-hjex.6: structured envelope so SPA can render the
-                    // specific address + amount instead of a prose disjunction.
-                    category: 'insufficient_funds',
-                    step: 'awaiting_funding',
-                    address: result.funding.master_address,
-                    requiredWei: result.funding.eth_required,
-                    haveWei: result.funding.eth_balance,
-                    // Legacy aliases kept for any external consumers that read these.
-                    role: 'master',
-                    asset: 'native',
-                    needWei: result.funding.eth_required,
-                },
-            });
-        }
-        console.log(`[main] Awaiting funding... (${Math.round(elapsed / 1000)}s elapsed; ` +
-            `will retry in ${FUNDING_POLL_INTERVAL_MS / 1000}s)`);
-        await new Promise((r) => setTimeout(r, FUNDING_POLL_INTERVAL_MS));
-    }
-    if (!result.ok) {
-        failBootstrap({
-            code: 'fatal',
-            message: result.message,
-            hint: 'Bootstrap failed before the fleet reached a runnable state.',
-            details: {
-                cause: result.message,
-                // jinn-mono-hjex.6: propagate structured category from the bootstrapper
-                // so the SPA can render category-specific UI (e.g. funding shortfall).
-                ...(result.errorCategory !== undefined ? { category: result.errorCategory } : {}),
-                // Preserve the raw underlying error so a misclassified summary can
-                // be diagnosed without re-running with JINN_DEBUG. See jinn-mono-jz9f.
-                ...(result.rawErrorMessage && result.rawErrorMessage !== result.message
-                    ? { rawErrorMessage: result.rawErrorMessage }
-                    : {}),
-                // jinn-mono-hjex reviewer fix: propagate tx hash so the SPA can render
-                // a block-explorer link for failed on-chain revert transactions.
-                ...(result.txHash != null ? { txHash: result.txHash } : {}),
-            },
-        });
-    }
-    // Legacy migration (jinn-mono-jgp): backfill `agent_id` on `complete`
-    // services that pre-date j07. Idempotent + per-service failure-isolated;
-    // a failure here does not abort daemon startup, but we surface counts so
-    // operators notice. Disabled via `runLegacyMigrations: false` /
-    // JINN_RUN_LEGACY_MIGRATIONS=0 — operators can run `jinn migrate-agent-id`
-    // explicitly instead.
-    let state = result.fleet_state;
-    if (config.runLegacyMigrations) {
-        try {
-            const migration = await runLegacyAgentIdMigration({
-                earningDir: config.earningDir,
-                network: NETWORK_CHAIN,
-                rpcUrl: config.rpcUrl,
-                password: PASSWORD,
-                testnetL2DeploymentPath: config.testnetL2DeploymentPath,
-                testnetL2TokenDeploymentPath: config.testnetL2TokenDeploymentPath,
-                testnetMechDeploymentPath: config.testnetMechDeploymentPath,
-                testnetStolasDeploymentPath: config.testnetStolasDeploymentPath,
-            });
-            if (migration.migrated.length > 0 || migration.failed.length > 0) {
-                console.log(`[main] Legacy agent_id migration: migrated=${migration.migrated.length} ` +
-                    `skipped=${migration.skipped.length} failed=${migration.failed.length}`);
-                for (const f of migration.failed) {
-                    console.log(`[main]   service ${f.service.index} (agent ${f.service.agent_address}): ${f.error}`);
-                }
-                // Reload state so downstream wiring (agent_id, identityRegistry)
-                // sees the migrated rows.
-                state = await new FleetStateStore(config.earningDir).load(NETWORK_CHAIN);
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[main] Legacy agent_id migration failed (non-fatal): ${message}`);
-        }
-    }
-    // Use the first operational service for the daemon. `safe_binding_pending`
-    // means staking/mech are live; only the ERC-8004 Safe→agent metadata bind
-    // is still retrying.
-    const firstComplete = state.services.find(s => isOperationalServiceStep(s.step));
-    if (!firstComplete || !firstComplete.safe_address) {
-        failBootstrap({
-            code: 'bootstrap_incomplete',
-            message: 'Bootstrap completed but no service is ready.',
-            hint: 'Re-run to continue the state machine toward a running fleet.',
-            exampleCli: 'jinn bootstrap --json',
-            details: bootstrapIncompleteSteps(state),
-        });
-    }
-    // Derive agent private key from mnemonic
-    const store = new FleetStateStore(config.earningDir);
-    const mnemonic = await decryptMnemonic(await store.loadMnemonicKeystore(), PASSWORD);
-    const agentPrivateKey = walletPrivateKeyAtIndex(mnemonic, firstComplete.index);
-    console.log(`[main] Fleet bootstrap complete.`);
-    console.log(`  Master:  ${state.master_address}`);
-    console.log(`  Services: ${state.services.filter(s => isOperationalServiceStep(s.step)).length}/${config.targetServices}`);
-    console.log(`  Active:  service ${firstComplete.service_id} (agent ${firstComplete.agent_address})`);
-    if (firstComplete.mech_address) {
-        console.log(`  Mech:    ${firstComplete.mech_address}`);
-    }
-    return {
-        masterAddress: state.master_address,
-        serviceIndex: firstComplete.index,
-        serviceId: firstComplete.service_id ?? null,
-        stakingAddress: firstComplete.staking_address ? firstComplete.staking_address : null,
-        agentPrivateKey: agentPrivateKey,
-        safeAddress: firstComplete.safe_address,
-        mechAddress: firstComplete.mech_address ? firstComplete.mech_address : undefined,
-        agentId: firstComplete.agent_id ?? null,
-        identityRegistryAddress: firstComplete.identity_registry_address
-            ? firstComplete.identity_registry_address
-            : null,
-    };
-}
-class SetupBootstrapHalted extends Error {
-    envelope;
-    constructor(envelope) {
-        super(envelope.message);
-        this.envelope = envelope;
-        this.name = 'SetupBootstrapHalted';
+    catch {
+        return false;
     }
 }
 // hjex.6: gate for the halt-and-resume loop. Lives in ./setup/halt-mode.ts
 // so it can be unit-tested without dragging main.ts's top-level side
 // effects (password resolution, config load) into the test.
 // ── Main ────────────────────────────────────────────────────────────────────
-/**
- * --json-progress: emit NDJSON progress envelopes on stdout during long
- * phases (init, bootstrap, daemon startup). The `jinn run --json-progress`
- * flag flips JINN_JSON_PROGRESS=1 in run.ts before calling main(); when
- * unset this is a no-op so tests / non-flag invocations stay silent on
- * stdout.
- */
-function progressEnabled() {
-    return process.env['JINN_JSON_PROGRESS'] === '1';
-}
-function emitProgress(envelope) {
-    if (progressEnabled()) {
-        process.stdout.write(JSON.stringify(envelope) + '\n');
-    }
-}
 export async function main() {
+    // Issue #909: chdir to a stable directory before spawning any child process.
+    // `jinn run` inherits the launch shell's CWD; when daemonised from an
+    // ephemeral dir that is later deleted, the CWD becomes a dangling inode and
+    // child processes (the `claude` CLI harness probe) crash on getcwd() ENOENT.
+    // Must run first — before getFileLogger() and any subprocess spawn.
+    ensureStableCwd({ earningDir: config.earningDir });
     console.log(`[main] jinn-client starting on ${NETWORK_CHAIN}`);
     // Issue #420: initialise the rotating daemon file logger early so lifecycle
     // events (tapped in `observability/emit-event.ts`) accumulate durable,
@@ -682,7 +264,7 @@ export async function main() {
     // Boot-time RPC fallback-chain probe (issue #592, AC7 + AC9). Log-only —
     // per-slot 429s/5xx never gate startup. checkRpcNetwork above already
     // fail-loud on chain-id mismatch against the head provider.
-    await probeFallbackChain(config.rpcUrls, config.network, 'L2');
+    lastL2Probe = await probeFallbackChain(config.rpcUrls, config.network, 'L2');
     console.error(summarizeFallbackChain('L2', config.rpcUrls));
     const portPreflight = await checkApiPortAvailable(config.apiPort);
     if (!portPreflight.ok) {
@@ -950,6 +532,25 @@ export async function main() {
                 configReader: () => ({
                     rpcUrl: config.rpcUrl,
                     defaultRpcUrl: CHAIN_CONFIG.rpcUrl,
+                    rpcUrls: config.rpcUrls,
+                    publicDefaults: RPC_PUBLIC_DEFAULTS,
+                    rpcSlotHealth: lastL2Probe.map((p) => p.ok
+                        ? {
+                            ok: true,
+                            host: p.host,
+                            latencyMs: p.latencyMs,
+                            expectedChainId: p.expectedChainId,
+                            actualChainId: p.actualChainId,
+                            ...(p.localDev ? { localDev: true } : {}),
+                        }
+                        : {
+                            ok: false,
+                            host: p.host,
+                            code: p.code,
+                            reason: p.reason,
+                            expectedChainId: p.expectedChainId,
+                            actualChainId: p.actualChainId,
+                        }),
                     joinedSolverNets: config.joinedSolverNets,
                     onboardingComplete: config.onboardingComplete,
                 }),
@@ -1076,6 +677,7 @@ export async function main() {
                 getClaudePath: () => activeClaudePath,
                 configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
                 defaultRpcUrlForChain: () => CHAIN_CONFIG.rpcUrl,
+                defaultRpcUrlsForChain: () => RPC_PUBLIC_DEFAULTS,
                 onClaudePathSelected: selectClaudePath,
                 // Issue #421 retired the legacy `solverNets` write target. Setup
                 // endpoints no longer call back into the daemon to mutate operator
@@ -1225,6 +827,11 @@ export async function main() {
                         const rows = sharedStore.listPostedTasksByCreator(opts);
                         return rows.map((r) => ({
                             taskId: r.taskId,
+                            // On-chain decimal id (#579) — the launcher status chip keys its
+                            // indexer lookup on this, not the off-chain display taskId. Empty
+                            // string (no on-chain id recorded) maps to undefined so the
+                            // gatherer falls back to taskId.
+                            ...(r.protocolTaskId ? { protocolTaskId: r.protocolTaskId } : {}),
                             taskCid: r.taskCid,
                             solverType: r.solverType ?? undefined,
                             postedAt: r.postedAt,
@@ -1232,6 +839,16 @@ export async function main() {
                             ...(r.claims ? { claims: r.claims } : {}),
                         }));
                     },
+                    // #579: on-chain finalized/open/expired status for the Recent posted
+                    // Tasks chip. discoveryApiHolder is populated post-bootstrap; before
+                    // that (or with no discovery API) we return an empty Map → all chips
+                    // render 'unknown', the safe degraded default.
+                    fetchTaskStatuses: async (manifestCid) => {
+                        const api = discoveryApiHolder.current;
+                        if (!api)
+                            return new Map();
+                        return api.getTaskStatuses({ manifestCid });
+                    },
                 },
             },
         });
@@ -1355,7 +972,7 @@ export async function main() {
     // eslint-disable-next-line no-constant-condition
     while (true) {
         try {
-            bootstrapResult = await bootstrap();
+            bootstrapResult = await runFleetBootstrap({ config, password: PASSWORD, network: NETWORK_CHAIN, emitProgress });
             break; // success — exit the retry loop
         }
         catch (err) {
@@ -2261,7 +1878,7 @@ export async function main() {
                 store: earningStore,
                 chain: NETWORK_CHAIN,
                 writeCheckpoint: async ({ stakingProxy }) => {
-                    const txHash = await masterWallet.writeContract({
+                    const txHash = await withEoaBroadcastLock(masterAccount.address, () => masterWallet.writeContract({
                         address: stakingProxy,
                         abi: [
                             {
@@ -2275,7 +1892,7 @@ export async function main() {
                         functionName: 'checkpoint',
                         account: masterAccount,
                         chain: null,
-                    });
+                    }));
                     return { txHash };
                 },
             }