@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.10

package/dist/heart/daemon/hatch-flow.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSecretsFile = writeSecretsFile;
+exports.runHatchFlow = runHatchFlow;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const hatch_specialist_1 = require("./hatch-specialist");
+function requiredCredentialKeys(provider) {
+    if (provider === "anthropic")
+        return ["setupToken"];
+    if (provider === "openai-codex")
+        return ["oauthAccessToken"];
+    if (provider === "minimax")
+        return ["apiKey"];
+    return ["apiKey", "endpoint", "deployment"];
+}
+function validateCredentials(provider, credentials) {
+    const missing = requiredCredentialKeys(provider).filter((key) => {
+        const value = credentials[key];
+        return typeof value !== "string" || value.trim().length === 0;
+    });
+    if (missing.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.hatch_credentials_error",
+            message: "hatch flow credentials validation failed",
+            meta: { provider, missing },
+        });
+        throw new Error(`Missing required credentials for ${provider}: ${missing.join(", ")}`);
+    }
+}
+function buildSecretsTemplate() {
+    return {
+        providers: {
+            azure: {
+                modelName: "gpt-4o-mini",
+                apiKey: "",
+                endpoint: "",
+                deployment: "",
+                apiVersion: "2025-04-01-preview",
+            },
+            minimax: {
+                model: "minimax-text-01",
+                apiKey: "",
+            },
+            anthropic: {
+                model: "claude-opus-4-6",
+                setupToken: "",
+            },
+            "openai-codex": {
+                model: "gpt-5.2",
+                oauthAccessToken: "",
+            },
+        },
+        teams: {
+            clientId: "",
+            clientSecret: "",
+            tenantId: "",
+        },
+        oauth: {
+            graphConnectionName: "graph",
+            adoConnectionName: "ado",
+            githubConnectionName: "",
+        },
+        teamsChannel: {
+            skipConfirmation: true,
+            port: 3978,
+        },
+        integrations: {
+            perplexityApiKey: "",
+            openaiEmbeddingsApiKey: "",
+        },
+    };
+}
+function writeSecretsFile(agentName, provider, credentials, secretsRoot) {
+    const secrets = buildSecretsTemplate();
+    if (provider === "anthropic") {
+        secrets.providers.anthropic.setupToken = credentials.setupToken.trim();
+    }
+    else if (provider === "openai-codex") {
+        secrets.providers["openai-codex"].oauthAccessToken = credentials.oauthAccessToken.trim();
+    }
+    else if (provider === "minimax") {
+        secrets.providers.minimax.apiKey = credentials.apiKey.trim();
+    }
+    else {
+        secrets.providers.azure.apiKey = credentials.apiKey.trim();
+        secrets.providers.azure.endpoint = credentials.endpoint.trim();
+        secrets.providers.azure.deployment = credentials.deployment.trim();
+    }
+    const secretsDir = path.join(secretsRoot, agentName);
+    fs.mkdirSync(secretsDir, { recursive: true });
+    const secretsPath = path.join(secretsDir, "secrets.json");
+    fs.writeFileSync(secretsPath, `${JSON.stringify(secrets, null, 2)}\n`, "utf-8");
+    return secretsPath;
+}
+function writeReadme(dir, purpose) {
+    fs.mkdirSync(dir, { recursive: true });
+    const readmePath = path.join(dir, "README.md");
+    if (!fs.existsSync(readmePath)) {
+        fs.writeFileSync(readmePath, `# ${path.basename(dir)}\n\n${purpose}\n`, "utf-8");
+    }
+}
+function slugify(value) {
+    const trimmed = value.trim().toLowerCase();
+    const slug = trimmed
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+    return slug || "friend";
+}
+function pad(value) {
+    return String(value).padStart(2, "0");
+}
+function formatTaskStem(now) {
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
+}
+function writeHeartbeatTask(bundleRoot, now) {
+    const habitsDir = path.join(bundleRoot, "tasks", "habits");
+    fs.mkdirSync(habitsDir, { recursive: true });
+    const stem = formatTaskStem(now);
+    const filePath = path.join(habitsDir, `${stem}-heartbeat.md`);
+    const iso = now.toISOString();
+    const content = [
+        "---",
+        "type: habit",
+        "category: runtime",
+        "title: Heartbeat check-in",
+        "status: processing",
+        `created: ${iso}`,
+        `updated: ${iso}`,
+        "requester: system",
+        "validator: null",
+        "cadence: \"30m\"",
+        "scheduledAt: null",
+        "lastRun: null",
+        "---",
+        "",
+        "Run a lightweight heartbeat cycle. Review task board and inbox.",
+        "",
+    ].join("\n");
+    fs.writeFileSync(filePath, content, "utf-8");
+}
+function writeFriendImprint(bundleRoot, humanName, now) {
+    const friendsDir = path.join(bundleRoot, "friends");
+    fs.mkdirSync(friendsDir, { recursive: true });
+    const nowIso = now.toISOString();
+    const id = `friend-${slugify(humanName)}`;
+    const localExternalId = `${os.userInfo().username}@${os.hostname()}`;
+    const record = {
+        id,
+        name: humanName,
+        role: "primary",
+        trustLevel: "family",
+        connections: [],
+        externalIds: [
+            {
+                provider: "local",
+                externalId: localExternalId,
+                linkedAt: nowIso,
+            },
+        ],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: {},
+        totalTokens: 0,
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        schemaVersion: 1,
+    };
+    fs.writeFileSync(path.join(friendsDir, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+}
+function writeHatchlingPsyche(bundleRoot, input, identityFileName) {
+    const psycheDir = path.join(bundleRoot, "psyche");
+    fs.mkdirSync(psycheDir, { recursive: true });
+    fs.writeFileSync(path.join(psycheDir, "SOUL.md"), "# SOUL\n\nI am a practical, collaborative agent. I keep commitments and communicate clearly.\n", "utf-8");
+    fs.writeFileSync(path.join(psycheDir, "IDENTITY.md"), `# IDENTITY\n\nI'm ${input.agentName}, newly hatched and ready to help ${input.humanName}.`, "utf-8");
+    fs.writeFileSync(path.join(psycheDir, "LORE.md"), `# LORE\n\nHatched with specialist identity seed: ${identityFileName}.`, "utf-8");
+    fs.writeFileSync(path.join(psycheDir, "TACIT.md"), "# TACIT\n\n- Save what I learn.\n- Keep tasks current.\n", "utf-8");
+    fs.writeFileSync(path.join(psycheDir, "ASPIRATIONS.md"), "# ASPIRATIONS\n\n- Become a reliable partner for my primary friend.\n", "utf-8");
+}
+function writeMemoryScaffold(bundleRoot) {
+    const memoryRoot = path.join(bundleRoot, "psyche", "memory");
+    fs.mkdirSync(path.join(memoryRoot, "daily"), { recursive: true });
+    fs.mkdirSync(path.join(memoryRoot, "archive"), { recursive: true });
+    fs.writeFileSync(path.join(memoryRoot, "facts.jsonl"), "", "utf-8");
+    fs.writeFileSync(path.join(memoryRoot, "entities.json"), "{}\n", "utf-8");
+}
+function writeHatchlingAgentConfig(bundleRoot, input) {
+    const template = (0, identity_1.buildDefaultAgentTemplate)(input.agentName);
+    template.provider = input.provider;
+    template.enabled = true;
+    fs.writeFileSync(path.join(bundleRoot, "agent.json"), `${JSON.stringify(template, null, 2)}\n`, "utf-8");
+}
+async function runHatchFlow(input, deps = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_flow_start",
+        message: "starting hatch flow",
+        meta: { agentName: input.agentName, provider: input.provider },
+    });
+    validateCredentials(input.provider, input.credentials);
+    const bundlesRoot = deps.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
+    const secretsRoot = deps.secretsRoot ?? path.join(os.homedir(), ".agentsecrets");
+    const sourceIdentities = deps.specialistIdentitySourceDir ?? (0, hatch_specialist_1.getSpecialistIdentitySourceDir)();
+    const targetIdentities = deps.specialistIdentityTargetDir ?? (0, hatch_specialist_1.getRepoSpecialistIdentitiesDir)();
+    const now = deps.now ? deps.now() : new Date();
+    const random = deps.random ?? Math.random;
+    (0, hatch_specialist_1.syncSpecialistIdentities)({
+        sourceDir: sourceIdentities,
+        targetDir: targetIdentities,
+    });
+    const selected = (0, hatch_specialist_1.pickRandomSpecialistIdentity)({
+        identitiesDir: targetIdentities,
+        random,
+    });
+    const specialistSecretsPath = writeSecretsFile("AdoptionSpecialist", input.provider, input.credentials, secretsRoot);
+    const hatchlingSecretsPath = writeSecretsFile(input.agentName, input.provider, input.credentials, secretsRoot);
+    const bundleRoot = path.join(bundlesRoot, `${input.agentName}.ouro`);
+    fs.mkdirSync(bundleRoot, { recursive: true });
+    writeReadme(bundleRoot, "Root of this agent bundle.");
+    writeReadme(path.join(bundleRoot, "psyche"), "Identity and behavior files.");
+    writeReadme(path.join(bundleRoot, "psyche", "memory"), "Persistent memory store.");
+    writeReadme(path.join(bundleRoot, "friends"), "Known friend records.");
+    writeReadme(path.join(bundleRoot, "tasks"), "Task files.");
+    writeReadme(path.join(bundleRoot, "tasks", "habits"), "Recurring tasks.");
+    writeReadme(path.join(bundleRoot, "tasks", "one-shots"), "One-shot tasks.");
+    writeReadme(path.join(bundleRoot, "tasks", "ongoing"), "Ongoing tasks.");
+    writeReadme(path.join(bundleRoot, "skills"), "Local skill files.");
+    writeReadme(path.join(bundleRoot, "senses"), "Sense-specific config.");
+    writeReadme(path.join(bundleRoot, "senses", "teams"), "Teams sense config.");
+    writeHatchlingAgentConfig(bundleRoot, input);
+    writeHatchlingPsyche(bundleRoot, input, selected.fileName);
+    writeMemoryScaffold(bundleRoot);
+    writeFriendImprint(bundleRoot, input.humanName, now);
+    writeHeartbeatTask(bundleRoot, now);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_flow_end",
+        message: "completed hatch flow",
+        meta: { bundleRoot, identity: selected.fileName },
+    });
+    return {
+        bundleRoot,
+        selectedIdentity: selected.fileName,
+        specialistSecretsPath,
+        hatchlingSecretsPath,
+    };
+}

package/dist/heart/daemon/hatch-specialist.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecialistIdentitySourceDir = getSpecialistIdentitySourceDir;
+exports.getRepoSpecialistIdentitiesDir = getRepoSpecialistIdentitiesDir;
+exports.syncSpecialistIdentities = syncSpecialistIdentities;
+exports.pickRandomSpecialistIdentity = pickRandomSpecialistIdentity;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function getSpecialistIdentitySourceDir() {
+    // Prefer ~/AgentBundles/ if it exists (user may have customized identities)
+    const userSource = path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    if (fs.existsSync(userSource))
+        return userSource;
+    // Fall back to the bundled copy shipped with the npm package
+    return path.join(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro", "psyche", "identities");
+}
+function getRepoSpecialistIdentitiesDir() {
+    return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");
+}
+function listMarkdownIdentityFiles(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.endsWith(".md"))
+        .sort((left, right) => left.localeCompare(right));
+}
+function syncSpecialistIdentities(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_sync_start",
+        message: "syncing specialist identity files",
+        meta: { sourceDir: input.sourceDir, targetDir: input.targetDir },
+    });
+    const files = listMarkdownIdentityFiles(input.sourceDir);
+    fs.mkdirSync(input.targetDir, { recursive: true });
+    for (const fileName of files) {
+        const sourcePath = path.join(input.sourceDir, fileName);
+        const targetPath = path.join(input.targetDir, fileName);
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_sync_end",
+        message: "synced specialist identity files",
+        meta: { copiedCount: files.length },
+    });
+    return files;
+}
+function pickRandomSpecialistIdentity(input) {
+    const files = listMarkdownIdentityFiles(input.identitiesDir);
+    if (files.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.hatch_identity_pick_error",
+            message: "no specialist identities were found",
+            meta: { identitiesDir: input.identitiesDir },
+        });
+        throw new Error(`No specialist identities found in ${input.identitiesDir}`);
+    }
+    const random = input.random ?? Math.random;
+    const index = Math.min(files.length - 1, Math.floor(random() * files.length));
+    const fileName = files[index];
+    const content = fs.readFileSync(path.join(input.identitiesDir, fileName), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_pick",
+        message: "picked specialist identity",
+        meta: { fileName },
+    });
+    return { fileName, content };
+}

package/dist/heart/daemon/health-monitor.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthMonitor = void 0;
+const runtime_1 = require("../../nerves/runtime");
+class HealthMonitor {
+    processManager;
+    scheduler;
+    alertSink;
+    diskUsagePercent;
+    constructor(options) {
+        this.processManager = options.processManager;
+        this.scheduler = options.scheduler;
+        this.alertSink = options.alertSink ?? (() => undefined);
+        this.diskUsagePercent = options.diskUsagePercent ?? (() => 0);
+    }
+    async runChecks() {
+        const results = [];
+        const snapshots = this.processManager.listAgentSnapshots();
+        const unhealthy = snapshots.filter((snapshot) => snapshot.status !== "running");
+        if (unhealthy.length > 0) {
+            results.push({
+                name: "agent-processes",
+                status: "critical",
+                message: `non-running agents: ${unhealthy.map((item) => item.name).join(", ")}`,
+            });
+        }
+        else {
+            results.push({ name: "agent-processes", status: "ok", message: "all managed agents running" });
+        }
+        const jobs = this.scheduler.listJobs();
+        const neverRan = jobs.filter((job) => !job.lastRun);
+        if (neverRan.length > 0) {
+            results.push({
+                name: "cron-health",
+                status: "warn",
+                message: `jobs never run: ${neverRan.map((job) => job.id).join(", ")}`,
+            });
+        }
+        else {
+            results.push({ name: "cron-health", status: "ok", message: "cron jobs are healthy" });
+        }
+        const diskPercent = this.diskUsagePercent();
+        if (diskPercent >= 90) {
+            results.push({
+                name: "disk-space",
+                status: "critical",
+                message: `disk usage critical (${diskPercent}%)`,
+            });
+        }
+        else if (diskPercent >= 80) {
+            results.push({
+                name: "disk-space",
+                status: "warn",
+                message: `disk usage high (${diskPercent}%)`,
+            });
+        }
+        else {
+            results.push({
+                name: "disk-space",
+                status: "ok",
+                message: `disk usage healthy (${diskPercent}%)`,
+            });
+        }
+        for (const result of results) {
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "critical" ? "error" : result.status === "warn" ? "warn" : "info",
+                component: "daemon",
+                event: "daemon.health_result",
+                message: "daemon health check result",
+                meta: { name: result.name, status: result.status },
+            });
+            if (result.status === "critical") {
+                await this.alertSink(`[critical] ${result.name}: ${result.message}`);
+            }
+        }
+        return results;
+    }
+}
+exports.HealthMonitor = HealthMonitor;

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

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverLogFiles = discoverLogFiles;
+exports.readLastLines = readLastLines;
+exports.formatLogLine = formatLogLine;
+exports.tailLogs = tailLogs;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const nerves_1 = require("../../nerves");
+const runtime_1 = require("../../nerves/runtime");
+const LEVEL_COLORS = {
+    debug: "\x1b[2m",
+    info: "\x1b[36m",
+    warn: "\x1b[33m",
+    error: "\x1b[31m",
+};
+function discoverLogFiles(options) {
+    /* v8 ignore start -- integration: default DI stubs for real OS @preserve */
+    const homeDir = options.homeDir ?? os.homedir();
+    const existsSync = options.existsSync ?? (() => false);
+    const readdirSync = options.readdirSync ?? (() => []);
+    /* v8 ignore stop */
+    const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
+    const files = [];
+    if (existsSync(logDir)) {
+        for (const name of readdirSync(logDir)) {
+            if (!name.endsWith(".ndjson"))
+                continue;
+            if (options.agentFilter && !name.includes(options.agentFilter))
+                continue;
+            files.push(path.join(logDir, name));
+        }
+    }
+    return files.sort();
+}
+function readLastLines(filePath, count, readFileSync) {
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    return lines.slice(-count);
+}
+function formatLogLine(ndjsonLine) {
+    try {
+        const entry = JSON.parse(ndjsonLine);
+        const formatted = (0, nerves_1.formatTerminalEntry)(entry);
+        const color = LEVEL_COLORS[entry.level] ?? "";
+        return `${color}${formatted}\x1b[0m`;
+    }
+    catch {
+        return ndjsonLine;
+    }
+}
+function tailLogs(options = {}) {
+    /* v8 ignore start -- integration: default DI stubs for real OS @preserve */
+    const writer = options.writer ?? ((text) => process.stdout.write(text));
+    const lineCount = options.lines ?? 20;
+    const readFileSync = options.readFileSync ?? (() => "");
+    /* v8 ignore stop */
+    const watchFile = options.watchFile;
+    const unwatchFile = options.unwatchFile;
+    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
+    for (const file of files) {
+        const lines = readLastLines(file, lineCount, readFileSync);
+        for (const line of lines) {
+            writer(`${formatLogLine(line)}\n`);
+        }
+        try {
+            const content = readFileSync(file, "utf-8");
+            fileSizes.set(file, content.length);
+        }
+        catch {
+            fileSizes.set(file, 0);
+        }
+    }
+    // Follow mode
+    if (options.follow && watchFile && unwatchFile) {
+        for (const file of files) {
+            watchFile(file, () => {
+                let content;
+                try {
+                    content = readFileSync(file, "utf-8");
+                }
+                catch {
+                    return;
+                }
+                /* v8 ignore next -- defensive: fileSizes always populated above @preserve */
+                const prevSize = fileSizes.get(file) ?? 0;
+                if (content.length <= prevSize)
+                    return;
+                fileSizes.set(file, content.length);
+                const newContent = content.slice(prevSize);
+                const newLines = newContent.split("\n").filter((l) => l.trim().length > 0);
+                for (const line of newLines) {
+                    writer(`${formatLogLine(line)}\n`);
+                }
+            });
+        }
+        return () => {
+            for (const file of files) {
+                unwatchFile(file);
+            }
+        };
+    }
+    return () => { };
+}