@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/daemon/interactive-repair.js

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ * Interactive repair flow for degraded agents detected during `ouro up`.
+ *
+ * Examines each degraded agent's errorReason and fixHint to detect common
+ * issue patterns and prompt the user for repair actions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRunnableInteractiveRepair = hasRunnableInteractiveRepair;
+exports.isAffirmativeAnswer = isAffirmativeAnswer;
+exports.runInteractiveRepair = runInteractiveRepair;
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const terminal_ui_1 = require("./terminal-ui");
+function isCredentialIssue(degraded) {
+    const reason = degraded.errorReason.toLowerCase();
+    const hint = degraded.fixHint.toLowerCase();
+    return reason.includes("credentials") || hint.includes("ouro auth");
+}
+function isVaultUnlockIssue(degraded) {
+    const text = `${degraded.errorReason}\n${degraded.fixHint}`.toLowerCase();
+    return /ouro vault unlock|credential vault is locked|vault(?: is)? locked/.test(text);
+}
+function isConfigError(degraded) {
+    return degraded.fixHint.length > 0 && !isVaultUnlockIssue(degraded) && !isCredentialIssue(degraded);
+}
+function hasRunnableInteractiveRepair(degraded) {
+    if (degraded.issue?.actions.some((action) => typedActionToRunnable(degraded, action) !== undefined)) {
+        return true;
+    }
+    return isVaultUnlockIssue(degraded) || isCredentialIssue(degraded);
+}
+function isAgentProvider(value) {
+    return Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
+}
+function extractProviderFromFixHint(fixHint) {
+    const provider = fixHint.match(/--provider\s+([a-z0-9-]+)/)?.[1]
+        ?? fixHint.match(/providers\.([a-z0-9-]+)/)?.[1];
+    if (!provider || !isAgentProvider(provider))
+        return undefined;
+    return provider;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cleanExtractedCommand(command) {
+    const cleaned = command?.trim().replace(/[`'",;:.)]+$/g, "").trim();
+    return cleaned && cleaned.length > 0 ? cleaned : undefined;
+}
+function extractRepairCommand(fixHint, commandPrefix) {
+    const escapedPrefix = escapeRegExp(commandPrefix);
+    const commandBody = `${escapedPrefix}(?=\\s|$)[^\`'"]*`;
+    const quoted = fixHint.match(new RegExp(`[\`'"](${commandBody})[\`'"]`, "i"))?.[1];
+    const unquoted = fixHint.match(new RegExp(`(${escapedPrefix}(?=\\s|$)[^\\n,;.]+)`, "i"))?.[1];
+    return cleanExtractedCommand(quoted) ?? cleanExtractedCommand(unquoted);
+}
+function authCommandFor(degraded) {
+    const command = extractRepairCommand(degraded.fixHint, "ouro auth");
+    return command && command.length > 0 ? command : `ouro auth --agent ${degraded.agent}`;
+}
+function vaultUnlockCommandFor(degraded) {
+    const command = extractRepairCommand(degraded.fixHint, "ouro vault unlock");
+    return command && command.length > 0 ? command : `ouro vault unlock --agent ${degraded.agent}`;
+}
+function isAffirmativeAnswer(answer) {
+    return /^(y|yes)$/i.test(answer.trim());
+}
+function uniqueCommands(commands) {
+    const seen = new Set();
+    const unique = [];
+    commands.forEach((command) => {
+        if (!command)
+            return;
+        if (seen.has(command))
+            return;
+        seen.add(command);
+        unique.push(command);
+    });
+    return unique;
+}
+function fallbackCommandsFor(degraded, primaryCommand) {
+    const issueCommands = degraded.issue?.actions.map((action) => action.command) ?? [];
+    return uniqueCommands([
+        primaryCommand,
+        ...issueCommands,
+        extractRepairCommand(degraded.fixHint, "ouro vault replace"),
+        extractRepairCommand(degraded.fixHint, "ouro vault recover"),
+        extractRepairCommand(degraded.fixHint, "ouro use"),
+    ]);
+}
+function renderRepairChoices(prefix, commands) {
+    return commands.map((command, index) => `  ${index === 0 ? prefix : "or"}: ${command}`);
+}
+function repairStatusFor(action) {
+    return action.kind === "vault-unlock" ? "locked" : "needs credentials";
+}
+function renderRepairQueueSummaryLines(degraded) {
+    const repairable = degraded
+        .map((entry) => ({ entry, action: runnableRepairActionFor(entry) }))
+        .filter((item) => item.action !== undefined);
+    if (repairable.length < 2)
+        return [];
+    const lines = [
+        "Repair queue",
+        `${repairable.length} agents need attention before startup can finish.`,
+        "",
+    ];
+    repairable.forEach(({ entry, action }, index) => {
+        lines.push(`${entry.agent} - ${action.label}`);
+        lines.push(`  ${action.command}`);
+        if (index < repairable.length - 1)
+            lines.push("");
+    });
+    return lines;
+}
+function renderRepairQueueSummary(degraded, deps) {
+    const repairable = degraded
+        .map((entry) => ({ entry, action: runnableRepairActionFor(entry) }))
+        .filter((item) => item.action !== undefined);
+    if (!deps.isTTY) {
+        return renderRepairQueueSummaryLines(degraded).join("\n");
+    }
+    return (0, terminal_ui_1.renderTerminalWizard)({
+        isTTY: true,
+        columns: deps.stdoutColumns,
+        masthead: {
+            subtitle: "Repair paths ready.",
+        },
+        title: "Needs attention before startup can finish",
+        summary: "Ouro found repair steps it can open right now. It will walk through them one at a time.",
+        sections: [{
+                title: "Repair queue",
+                items: repairable.map(({ entry, action }) => ({
+                    label: entry.agent,
+                    status: repairStatusFor(action),
+                    summary: action.label,
+                    detailLines: [entry.errorReason],
+                    command: action.command,
+                })),
+            }],
+        suppressEvent: true,
+    }).trimEnd();
+}
+function renderActionPromptLines(agent, action) {
+    const lines = [
+        `${agent}`,
+        `  needs: ${action.label}`,
+        `  run:   ${action.command}`,
+    ];
+    if (action.kind === "vault-unlock") {
+        lines.push("  note:  use the saved vault unlock secret");
+    }
+    return lines;
+}
+function renderActionPrompt(entry, action, deps) {
+    if (!deps.isTTY)
+        return renderActionPromptLines(entry.agent, action).join("\n");
+    const footer = action.kind === "vault-unlock"
+        ? "Only say yes if you have the saved vault unlock secret."
+        : "Say yes if you want Ouro to open the auth flow now.";
+    return (0, terminal_ui_1.renderTerminalWizard)({
+        isTTY: true,
+        columns: deps.stdoutColumns,
+        masthead: {
+            subtitle: "One repair step at a time.",
+        },
+        title: `Repair ${entry.agent}`,
+        summary: "Ouro found one clear next move for this agent.",
+        nextStep: {
+            label: action.kind === "vault-unlock"
+                ? "Unlock the credential vault on this machine."
+                : "Refresh provider authentication.",
+            detail: action.kind === "vault-unlock"
+                ? "Use the saved unlock secret if you have it. If not, leave this for later and choose a replacement or recovery path."
+                : "This opens the provider login or refresh flow for the selected provider.",
+            command: action.command,
+        },
+        sections: [{
+                title: "Why startup paused",
+                items: [{
+                        label: entry.agent,
+                        status: repairStatusFor(action),
+                        summary: entry.errorReason,
+                    }],
+            }],
+        footerLines: [footer],
+        suppressEvent: true,
+    }).trimEnd();
+}
+function renderDeferredRepair(agent, commands, deps) {
+    if (!deps.isTTY) {
+        return [
+            `Leaving ${agent} for later.`,
+            ...renderRepairChoices("next", commands),
+        ].join("\n");
+    }
+    return (0, terminal_ui_1.renderTerminalWizard)({
+        isTTY: true,
+        columns: deps.stdoutColumns,
+        masthead: {
+            subtitle: "Nothing changed yet.",
+        },
+        title: `Leaving ${agent} for later`,
+        summary: "Ouro did not open this repair flow right now.",
+        sections: [{
+                title: "Next time",
+                items: commands.map((command, index) => ({
+                    key: String(index + 1),
+                    label: index === 0 ? "Start here" : "Or try this",
+                    command,
+                })),
+            }],
+        suppressEvent: true,
+    }).trimEnd();
+}
+function renderManualRepairHint(agent, fixHint) {
+    return [
+        `${agent}`,
+        "  needs manual attention",
+        `  next: ${fixHint}`,
+    ].join("\n");
+}
+function renderUnknownRepair(agent, errorReason) {
+    return [
+        `${agent}`,
+        `  ${errorReason}`,
+    ].join("\n");
+}
+function writeDeclinedRepair(degraded, command, deps) {
+    deps.writeStdout(renderDeferredRepair(degraded.agent, fallbackCommandsFor(degraded, command), deps));
+}
+function runnableRepairActionFor(degraded) {
+    const typedAction = degraded.issue?.actions
+        .map((action) => typedActionToRunnable(degraded, action))
+        .find((action) => action !== undefined);
+    if (typedAction)
+        return typedAction;
+    if (isVaultUnlockIssue(degraded)) {
+        return { kind: "vault-unlock", label: "vault unlock", command: vaultUnlockCommandFor(degraded) };
+    }
+    if (isCredentialIssue(degraded)) {
+        return {
+            kind: "provider-auth",
+            label: "provider auth",
+            command: authCommandFor(degraded),
+            provider: extractProviderFromFixHint(degraded.fixHint),
+        };
+    }
+    return undefined;
+}
+function typedActionToRunnable(degraded, action) {
+    if (action.executable === false || action.command.includes("<"))
+        return undefined;
+    if (action.kind === "vault-unlock") {
+        return { kind: "vault-unlock", label: "vault unlock", command: action.command };
+    }
+    if (action.kind === "provider-auth") {
+        return {
+            kind: "provider-auth",
+            label: "provider auth",
+            command: action.command || `ouro auth --agent ${degraded.agent}`,
+            provider: action.provider,
+        };
+    }
+    return undefined;
+}
+function writeRepairQueueSummary(degraded, deps) {
+    const lines = renderRepairQueueSummaryLines(degraded);
+    if (lines.length > 0)
+        deps.writeStdout(renderRepairQueueSummary(degraded, deps));
+}
+async function attemptVaultUnlock(entry, action, deps) {
+    deps.writeStdout(renderActionPrompt(entry, action, deps));
+    const answer = await deps.promptInput(`Unlock ${entry.agent}'s vault now? [y/N] `);
+    if (!isAffirmativeAnswer(answer)) {
+        writeDeclinedRepair(entry, action.command, deps);
+        return { succeeded: false, attempted: false };
+    }
+    try {
+        if (!deps.runVaultUnlock) {
+            deps.writeStdout(renderManualRepairHint(entry.agent, entry.fixHint));
+            return { succeeded: false, attempted: false };
+        }
+        await deps.runVaultUnlock(entry.agent);
+        return { succeeded: true, attempted: true };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        deps.writeStdout(`Vault unlock did not finish for ${entry.agent}.\n  ${msg}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.interactive_repair_vault_unlock_error",
+            message: `vault unlock failed for ${entry.agent}`,
+            meta: { agent: entry.agent, error: msg },
+        });
+        return { succeeded: false, attempted: true };
+    }
+}
+async function attemptProviderAuth(entry, action, deps) {
+    deps.writeStdout(renderActionPrompt(entry, action, deps));
+    const answer = await deps.promptInput(`Open the auth flow for ${entry.agent} now? [y/N] `);
+    if (!isAffirmativeAnswer(answer)) {
+        writeDeclinedRepair(entry, action.command, deps);
+        return { succeeded: false, attempted: false };
+    }
+    try {
+        if (action.provider) {
+            await deps.runAuthFlow(entry.agent, action.provider);
+        }
+        else {
+            await deps.runAuthFlow(entry.agent);
+        }
+        return { succeeded: true, attempted: true };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        deps.writeStdout(`Auth did not finish for ${entry.agent}.\n  ${msg}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.interactive_repair_auth_error",
+            message: `auth flow failed for ${entry.agent}`,
+            meta: { agent: entry.agent, error: msg },
+        });
+        return { succeeded: false, attempted: true };
+    }
+}
+async function processEntry(entry, deps) {
+    let current = entry;
+    while (current) {
+        const action = runnableRepairActionFor(current);
+        let outcome;
+        if (action?.kind === "vault-unlock") {
+            outcome = await attemptVaultUnlock(current, action, deps);
+        }
+        else if (action?.kind === "provider-auth") {
+            outcome = await attemptProviderAuth(current, action, deps);
+        }
+        else if (isConfigError(current)) {
+            deps.writeStdout(renderManualRepairHint(current.agent, current.fixHint));
+            return { attempted: false };
+        }
+        else {
+            deps.writeStdout(renderUnknownRepair(current.agent, current.errorReason));
+            return { attempted: false };
+        }
+        if (!outcome.succeeded || !deps.recheckAgent) {
+            return { attempted: outcome.attempted };
+        }
+        // Re-evaluate the agent after successful repair
+        const recheckResult = await deps.recheckAgent(current.agent);
+        if (recheckResult === null) {
+            deps.writeStdout(`${current.agent} recovered.`);
+            return { attempted: true };
+        }
+        // Agent still degraded with a new error -- loop to present the new action
+        current = recheckResult;
+    }
+    /* v8 ignore next -- unreachable: loop always returns from within @preserve */
+    return { attempted: false };
+}
+async function runInteractiveRepair(degraded, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.interactive_repair_start",
+        message: "interactive repair flow started",
+        meta: { degradedCount: degraded.length },
+    });
+    if (degraded.length === 0) {
+        return { repairsAttempted: false };
+    }
+    let repairsAttempted = false;
+    if (!deps.skipQueueSummary) {
+        writeRepairQueueSummary(degraded, deps);
+    }
+    for (const entry of degraded) {
+        const result = await processEntry(entry, deps);
+        if (result.attempted)
+            repairsAttempted = true;
+    }
+    if (repairsAttempted) {
+        deps.writeStdout("Repair flow complete.");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.interactive_repair_end",
+        message: "interactive repair flow completed",
+        meta: { repairsAttempted },
+    });
+    return { repairsAttempted };
+}

package/dist/heart/daemon/launchd.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DAEMON_PLIST_LABEL = void 0;
+exports.bootoutLaunchAgentByLabel = bootoutLaunchAgentByLabel;
 exports.generateDaemonPlist = generateDaemonPlist;
 exports.writeLaunchAgentPlist = writeLaunchAgentPlist;
 exports.installLaunchAgent = installLaunchAgent;
@@ -48,6 +49,26 @@ function plistFilePath(homeDir) {
 function userLaunchDomain(userUid) {
     return `gui/${userUid}`;
 }
+function bootoutLaunchAgentByLabel(deps) {
+    const domain = userLaunchDomain(deps.userUid);
+    try {
+        deps.exec(`launchctl bootout ${domain}/${exports.DAEMON_PLIST_LABEL}`);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.launchd_label_bootout",
+            message: "booted out daemon launch agent by label",
+            meta: { label: exports.DAEMON_PLIST_LABEL, domain },
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.launchd_label_bootout_skipped",
+            message: "daemon launch agent label bootout skipped",
+            meta: { label: exports.DAEMON_PLIST_LABEL, domain, reason: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}
 function generateDaemonPlist(options) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -78,7 +99,13 @@ function generateDaemonPlist(options) {
         lines.push(`  <key>EnvironmentVariables</key>`, `  <dict>`, `    <key>PATH</key>`, `    <string>${options.envPath}</string>`, `  </dict>`);
     }
     if (options.logDir) {
-        lines.push(`  <key>StandardOutPath</key>`, `  <string>${path.join(options.logDir, "ouro-daemon-stdout.log")}</string>`, `  <key>StandardErrorPath</key>`, `  <string>${path.join(options.logDir, "ouro-daemon-stderr.log")}</string>`);
+        // PR 1 decision: we no longer emit `StandardErrorPath` for the daemon.
+        // The daemon's structured nerves ndjson pipeline (rotated + gzipped via
+        // createNdjsonFileSink) is the source of truth for diagnostics. Writing
+        // raw process stderr to an unrotated file grew to 366 MB in the wild;
+        // dropping the key lets launchd forward stray stderr to the system log
+        // where it gets rotated by the OS.
+        lines.push(`  <key>StandardOutPath</key>`, `  <string>${path.join(options.logDir, "ouro-daemon-stdout.log")}</string>`);
     }
     lines.push(`</dict>`, `</plist>`, ``);
     return lines.join("\n");
@@ -117,11 +144,17 @@ function installLaunchAgent(deps, options) {
         catch { /* best effort */ }
     }
     writeLaunchAgentPlist(deps, options);
-    deps.exec(`launchctl bootstrap ${domain} "${fullPath}"`);
+    // Bootstrap the plist so launchd manages crash recovery via KeepAlive.
+    // This is safe because ouro up calls this AFTER the daemon is already running,
+    // so launchd sees the existing process and just registers for KeepAlive.
+    try {
+        deps.exec(`launchctl bootstrap ${domain} "${fullPath}"`);
+    }
+    catch { /* already loaded */ }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.launchd_installed",
-        message: "launch agent installed",
+        message: "launch agent installed with KeepAlive",
         meta: { plistPath: fullPath },
     });
 }
@@ -133,12 +166,8 @@ function uninstallLaunchAgent(deps) {
         meta: {},
     });
     const fullPath = plistFilePath(deps.homeDir);
-    const domain = userLaunchDomain(deps.userUid);
+    bootoutLaunchAgentByLabel(deps);
     if (deps.existsFile(fullPath)) {
-        try {
-            deps.exec(`launchctl bootout ${domain} "${fullPath}"`);
-        }
-        catch { /* best effort */ }
         deps.removeFile(fullPath);
     }
     (0, runtime_1.emitNervesEvent)({

package/dist/heart/daemon/log-tailer.js

@@ -38,6 +38,7 @@ exports.readLastLines = readLastLines;
 exports.formatLogLine = formatLogLine;
 exports.tailLogs = tailLogs;
 const path = __importStar(require("path"));
+const zlib = __importStar(require("zlib"));
 const nerves_1 = require("../../nerves");
 const runtime_1 = require("../../nerves/runtime");
 const identity_1 = require("../identity");
@@ -47,30 +48,92 @@ const LEVEL_COLORS = {
     warn: "\x1b[33m",
     error: "\x1b[31m",
 };
+/**
+ * Parse a log filename into a (streamBase, generationRank) tuple.
+ *
+ * - `daemon.ndjson`          → { streamBase: "daemon", rank: 0 }   (active, newest)
+ * - `daemon.1.ndjson.gz`     → { streamBase: "daemon", rank: 1 }
+ * - `daemon.5.ndjson.gz`     → { streamBase: "daemon", rank: 5 }   (oldest)
+ * - Anything else            → null (not a log file).
+ *
+ * Higher rank = older. Used to sort so the oldest generation is read first
+ * and the active stream is read last, producing chronological output.
+ */
+function parseLogFilename(name) {
+    if (name.endsWith(".ndjson.gz")) {
+        // e.g. daemon.1.ndjson.gz → base "daemon.1", strip ".gz" then ".ndjson" then ".<n>"
+        const withoutGz = name.slice(0, -".gz".length); // daemon.1.ndjson
+        const withoutNdjson = withoutGz.slice(0, -".ndjson".length); // daemon.1
+        const genMatch = withoutNdjson.match(/^(.+)\.(\d+)$/);
+        if (!genMatch)
+            return null;
+        return { streamBase: genMatch[1], rank: parseInt(genMatch[2], 10) };
+    }
+    if (name.endsWith(".ndjson")) {
+        const withoutNdjson = name.slice(0, -".ndjson".length);
+        // Active file: daemon.ndjson → base "daemon", rank 0
+        // Legacy numeric gen: daemon.1.ndjson → base "daemon", rank 1 (treat same as gzipped)
+        const legacyMatch = withoutNdjson.match(/^(.+)\.(\d+)$/);
+        if (legacyMatch) {
+            return { streamBase: legacyMatch[1], rank: parseInt(legacyMatch[2], 10) };
+        }
+        return { streamBase: withoutNdjson, rank: 0 };
+    }
+    return null;
+}
 function discoverLogFiles(options) {
     /* v8 ignore start -- integration: default DI stubs for real OS @preserve */
     const existsSync = options.existsSync ?? (() => false);
     const readdirSync = options.readdirSync ?? (() => []);
     /* v8 ignore stop */
     const logDir = options.homeDir
-        ? path.join(options.homeDir, "AgentBundles", `${options.agentName ?? "slugger"}.ouro`, "state", "daemon", "logs")
+        ? path.join(options.homeDir, "AgentBundles", `${options.agentName ?? "default"}.ouro`, "state", "daemon", "logs")
         : (0, identity_1.getAgentDaemonLogsDir)(options.agentName);
-    const files = [];
+    const entries = [];
     if (existsSync(logDir)) {
         for (const name of readdirSync(logDir)) {
-            if (!name.endsWith(".ndjson"))
+            const parsed = parseLogFilename(name);
+            if (!parsed)
                 continue;
             if (options.agentFilter && !name.includes(options.agentFilter))
                 continue;
-            files.push(path.join(logDir, name));
+            entries.push({ name, parsed });
         }
     }
-    return files.sort();
+    // Sort chronologically: for each stream, oldest generation first, active last.
+    // Across streams, sort alphabetically by streamBase so output is stable.
+    entries.sort((a, b) => {
+        if (a.parsed.streamBase !== b.parsed.streamBase) {
+            return a.parsed.streamBase < b.parsed.streamBase ? -1 : 1;
+        }
+        // Same stream: higher rank = older = read first.
+        return b.parsed.rank - a.parsed.rank;
+    });
+    return entries.map((e) => path.join(logDir, e.name));
+}
+/**
+ * Read a log file as a string, transparently handling gzipped rotations.
+ *
+ * For `.ndjson.gz` files we read the raw bytes via `fs.readFileSync` (ignoring
+ * any caller-supplied DI `readFileSync`, since that stub returns a `string`
+ * and would corrupt gzip bytes) and then `zlib.gunzipSync` to recover the
+ * original text. For plain `.ndjson` files we defer to the DI stub so tests
+ * can keep mocking fs.
+ */
+function readNdjsonFileContents(filePath, readFileSync) {
+    if (filePath.endsWith(".gz")) {
+        // Binary path: tests can mock readFileSync to return a Buffer (typed as
+        // string) via `as unknown as string` — we accept both Buffer and Uint8Array.
+        const raw = readFileSync(filePath);
+        const buf = typeof raw === "string" ? Buffer.from(raw, "binary") : Buffer.from(raw);
+        return zlib.gunzipSync(buf).toString("utf-8");
+    }
+    return readFileSync(filePath, "utf-8");
 }
 function readLastLines(filePath, count, readFileSync) {
     let content;
     try {
-        content = readFileSync(filePath, "utf-8");
+        content = readNdjsonFileContents(filePath, readFileSync);
     }
     catch {
         return [];
@@ -100,12 +163,17 @@ function tailLogs(options = {}) {
     const files = discoverLogFiles(options);
     (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.log_tailer_started", message: "log tailer started", meta: { fileCount: files.length, follow: !!options.follow } });
     const fileSizes = new Map();
-    // Read initial lines
+    // Read initial lines from each discovered file (oldest gz → newest gz → active).
+    // Gzipped files are historical and never tailed in follow mode.
     for (const file of files) {
         const lines = readLastLines(file, lineCount, readFileSync);
         for (const line of lines) {
             writer(`${formatLogLine(line)}\n`);
         }
+        if (file.endsWith(".gz")) {
+            // Historical rotation — skip size tracking, never followed.
+            continue;
+        }
         try {
             const content = readFileSync(file, "utf-8");
             fileSizes.set(file, content.length);
@@ -114,9 +182,10 @@ function tailLogs(options = {}) {
             fileSizes.set(file, 0);
         }
     }
-    // Follow mode
+    // Follow mode: only the active (non-gzipped) stream is watched.
     if (options.follow && watchFile && unwatchFile) {
-        for (const file of files) {
+        const activeFiles = files.filter((f) => !f.endsWith(".gz"));
+        for (const file of activeFiles) {
             watchFile(file, () => {
                 let content;
                 try {
@@ -138,7 +207,7 @@ function tailLogs(options = {}) {
             });
         }
         return () => {
-            for (const file of files) {
+            for (const file of activeFiles) {
                 unwatchFile(file);
             }
         };