@a5c-ai/genty-runtime 5.1.1-staging.5e92128884d3

package/dist/daemon/automationExecutor.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Shared automation-rule execution path for daemon timer and webhook triggers.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAutomationTrigger = executeAutomationTrigger;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const DEFAULT_BACKLOG_FILE_PATH = process.env.KANBAN_BACKLOG_FILE
+    ?? node_path_1.default.join(node_os_1.default.homedir(), ".a5c", "kanban-backlog.json");
+function cloneRecord(value) {
+    return value ? { ...value } : undefined;
+}
+async function readAutomationStorage(backlogFilePath) {
+    try {
+        const raw = await node_fs_1.promises.readFile(backlogFilePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+async function writeAutomationStorage(backlogFilePath, payload) {
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(backlogFilePath), { recursive: true });
+    await node_fs_1.promises.writeFile(backlogFilePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+function createTriggerMetadata(rule) {
+    if (rule.trigger.type === "timer") {
+        return {
+            triggerType: "timer",
+            cron: rule.trigger.cron,
+            timezone: rule.trigger.timezone,
+        };
+    }
+    return {
+        triggerType: "webhook",
+        port: rule.trigger.port,
+        path: rule.trigger.path ?? "/trigger",
+        method: rule.trigger.method ?? "POST",
+        sourceEvent: rule.trigger.sourceEvent,
+    };
+}
+function nextIssueNumber(project, issues) {
+    const prefix = `${project.key}-AUTO-`;
+    return issues.reduce((max, issue) => {
+        if (!issue.key.startsWith(prefix)) {
+            return max;
+        }
+        const rawNumber = issue.key.slice(prefix.length);
+        const parsed = Number.parseInt(rawNumber, 10);
+        return Number.isFinite(parsed) ? Math.max(max, parsed) : max;
+    }, 0) + 1;
+}
+function resolveProjectCollections(project, template) {
+    const labelsById = new Map(project.labels.map((label) => [label.id, label]));
+    const assigneesById = new Map(project.assignees.map((assignee) => [assignee.id, assignee]));
+    return {
+        labels: (template.labelIds ?? [])
+            .map((labelId) => labelsById.get(labelId))
+            .filter((label) => Boolean(label)),
+        assignees: (template.assigneeIds ?? [])
+            .map((assigneeId) => assigneesById.get(assigneeId))
+            .filter((assignee) => Boolean(assignee)),
+    };
+}
+function resolveIssueSource(rule) {
+    if (rule.template.issueSource) {
+        return { ...rule.template.issueSource };
+    }
+    if (rule.source.kind === "config-file") {
+        return {
+            kind: "file",
+            path: rule.source.path,
+            externalId: rule.source.externalId ?? rule.id,
+        };
+    }
+    return {
+        kind: "run-derived",
+        externalId: rule.source.externalId ?? rule.id,
+    };
+}
+function createAcceptanceCriteria(issueId, criteria) {
+    return (criteria ?? []).map((title, index) => ({
+        id: `${issueId}-ac-${index + 1}`,
+        title,
+        satisfied: false,
+    }));
+}
+function createDecomposition(issueId, items) {
+    return (items ?? []).map((item, index) => ({
+        id: `${issueId}-decomp-${index + 1}`,
+        title: item.title,
+        kind: item.kind,
+        status: item.status,
+        issueId: undefined,
+    }));
+}
+function createAutomationIssue(rule, project, issues, now) {
+    const sequence = nextIssueNumber(project, issues);
+    const issueKey = `${project.key}-AUTO-${String(sequence).padStart(3, "0")}`;
+    const issueId = issueKey;
+    const { labels, assignees } = resolveProjectCollections(project, rule.template);
+    return {
+        id: issueId,
+        key: issueKey,
+        projectId: rule.target.projectId,
+        title: rule.template.title,
+        summary: rule.template.summary,
+        description: rule.template.description,
+        status: rule.template.status ?? "backlog",
+        priority: rule.template.priority ?? "medium",
+        labels,
+        assignees,
+        dependencies: [],
+        acceptanceCriteria: createAcceptanceCriteria(issueId, rule.template.acceptanceCriteria),
+        decomposition: createDecomposition(issueId, rule.template.decomposition),
+        childIssueIds: [],
+        createdAt: now,
+        updatedAt: now,
+        source: resolveIssueSource(rule),
+    };
+}
+function createExecutionRecord(rule, event, now, overrides) {
+    return {
+        id: `automation-exec-${(0, node_crypto_1.randomUUID)().toLowerCase()}`,
+        ruleId: rule.id,
+        ruleName: rule.name,
+        triggerType: rule.trigger.type,
+        status: overrides.status,
+        triggeredAt: now,
+        triggeredBy: `daemon-${rule.trigger.type}`,
+        source: {
+            ...rule.source,
+            metadata: cloneRecord(rule.source.metadata),
+        },
+        projectId: rule.target.projectId,
+        boardProjectId: rule.target.boardProjectId,
+        issueId: overrides.issue?.id,
+        issueKey: overrides.issue?.key,
+        issueSource: overrides.issue?.source,
+        stateAtExecution: rule.state,
+        skipReason: overrides.skipReason,
+        inputs: event.inputs ? { ...event.inputs } : undefined,
+        metadata: createTriggerMetadata(rule),
+    };
+}
+async function executeAutomationTrigger(event, options = {}) {
+    const backlogFilePath = options.backlogFilePath ?? DEFAULT_BACKLOG_FILE_PATH;
+    const now = options.now?.() ?? new Date().toISOString();
+    const storage = await readAutomationStorage(backlogFilePath);
+    const rules = [...(storage.automationRules ?? [])];
+    const rule = rules.find((candidate) => candidate.id === event.rule.id) ?? event.rule;
+    if (rule.state !== "active") {
+        const execution = createExecutionRecord(rule, event, now, {
+            status: "skipped",
+            skipReason: `Rule ${rule.id} is ${rule.state}.`,
+        });
+        await writeAutomationStorage(backlogFilePath, {
+            ...storage,
+            automationExecutions: [...(storage.automationExecutions ?? []), execution],
+        });
+        return execution;
+    }
+    const projects = [...(storage.projects ?? [])];
+    const issueProject = projects.find((candidate) => candidate.id === rule.target.projectId);
+    const boardProject = projects.find((candidate) => candidate.id === rule.target.boardProjectId);
+    if (!issueProject || !boardProject) {
+        const missingTarget = !issueProject
+            ? `Project ${rule.target.projectId}`
+            : `Board project ${rule.target.boardProjectId}`;
+        const execution = createExecutionRecord(rule, event, now, {
+            status: "skipped",
+            skipReason: `${missingTarget} not found.`,
+        });
+        await writeAutomationStorage(backlogFilePath, {
+            ...storage,
+            automationExecutions: [...(storage.automationExecutions ?? []), execution],
+        });
+        return execution;
+    }
+    const issues = [...(storage.issues ?? [])];
+    const issue = createAutomationIssue(rule, issueProject, issues, now);
+    const execution = createExecutionRecord(rule, event, now, {
+        status: "created",
+        issue,
+    });
+    const nextRules = rules.length > 0
+        ? rules.map((candidate) => (candidate.id === rule.id
+            ? {
+                ...candidate,
+                audit: {
+                    ...candidate.audit,
+                    lastTriggeredAt: now,
+                    lastTriggeredBy: execution.triggeredBy,
+                },
+            }
+            : candidate))
+        : storage.automationRules;
+    const nextProjects = projects.map((candidate) => (candidate.id === issueProject.id || candidate.id === boardProject.id
+        ? {
+            ...candidate,
+            issueIds: Array.from(new Set([...candidate.issueIds, issue.id])),
+        }
+        : candidate));
+    await writeAutomationStorage(backlogFilePath, {
+        ...storage,
+        projects: nextProjects,
+        issues: [...issues, issue],
+        automationRules: nextRules,
+        automationExecutions: [...(storage.automationExecutions ?? []), execution],
+    });
+    return execution;
+}

package/dist/daemon/config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GAP-REMOTE-001: Daemon Config — load/validate/write daemon configuration.
+ */
+import type { ApiResult } from "../apiResult";
+import type { DaemonConfig } from "./types";
+export declare function loadDaemonConfig(configPath: string): Promise<ApiResult<DaemonConfig>>;
+export declare function writeDaemonConfig(config: DaemonConfig, configPath: string): Promise<ApiResult<void>>;
+//# sourceMappingURL=config.d.ts.map

package/dist/daemon/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/daemon/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AA+L5C,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CA0BlC;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAgB1B"}

package/dist/daemon/config.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon Config — load/validate/write daemon configuration.
+ */
+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.loadDaemonConfig = loadDaemonConfig;
+exports.writeDaemonConfig = writeDaemonConfig;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const apiResult_1 = require("../apiResult");
+const VALID_TRIGGER_TYPES = new Set(["file", "webhook", "timer"]);
+const VALID_AUTOMATION_STATES = new Set(["draft", "active", "paused", "disabled", "archived"]);
+const DEFAULT_MAX_CONCURRENT_RUNS = 4;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray(value) {
+    return Array.isArray(value);
+}
+function validateFileTrigger(raw, index) {
+    if (!isRecord(raw)) {
+        return `Trigger at index ${index} must be an object`;
+    }
+    if (raw.type !== "file") {
+        return `Invalid trigger type at index ${index}: ${String(raw.type)}. Must be one of: file, webhook, timer`;
+    }
+    if (typeof raw.processId !== "string" || !raw.processId) {
+        return `Missing processId at trigger index ${index}`;
+    }
+    if (typeof raw.entrypoint !== "string" || !raw.entrypoint) {
+        return `Missing entrypoint at trigger index ${index}`;
+    }
+    if (typeof raw.pattern !== "string" || !raw.pattern) {
+        return `Missing pattern at trigger index ${index}`;
+    }
+    return null;
+}
+function validateAutomationRule(raw, index) {
+    if (!isRecord(raw)) {
+        return `Trigger at index ${index} must be an object`;
+    }
+    if (typeof raw.id !== "string" || !raw.id) {
+        return `Missing automation rule id at trigger index ${index}`;
+    }
+    if (typeof raw.name !== "string" || !raw.name) {
+        return `Missing automation rule name at trigger index ${index}`;
+    }
+    if (typeof raw.state !== "string" || !VALID_AUTOMATION_STATES.has(raw.state)) {
+        return `Invalid automation state at trigger index ${index}: ${String(raw.state)}`;
+    }
+    const trigger = raw.trigger;
+    if (!isRecord(trigger) || typeof trigger.type !== "string" || !VALID_TRIGGER_TYPES.has(trigger.type)) {
+        return `Invalid automation trigger type at index ${index}: ${String(isRecord(trigger) ? trigger.type : trigger)}`;
+    }
+    if (trigger.type === "file") {
+        return `Automation rules do not support file triggers at index ${index}`;
+    }
+    if (trigger.type === "timer" && (typeof trigger.cron !== "string" || !trigger.cron)) {
+        return `Missing cron for timer automation at trigger index ${index}`;
+    }
+    if (trigger.type === "webhook") {
+        if (typeof trigger.port !== "number" || trigger.port <= 0) {
+            return `Missing port for webhook automation at trigger index ${index}`;
+        }
+        if (trigger.path !== undefined && (typeof trigger.path !== "string" || !trigger.path)) {
+            return `Invalid webhook path at trigger index ${index}`;
+        }
+    }
+    const target = raw.target;
+    if (!isRecord(target) || typeof target.projectId !== "string" || !target.projectId) {
+        return `Missing target.projectId at trigger index ${index}`;
+    }
+    if (typeof target.boardProjectId !== "string" || !target.boardProjectId) {
+        return `Missing target.boardProjectId at trigger index ${index}`;
+    }
+    const template = raw.template;
+    if (!isRecord(template) || typeof template.title !== "string" || !template.title) {
+        return `Missing template.title at trigger index ${index}`;
+    }
+    const routing = raw.routing;
+    if (!isRecord(routing)) {
+        return `Missing routing block at trigger index ${index}`;
+    }
+    if (!isRecord(routing.issue) || routing.issue.action !== "canonical-issue-create") {
+        return `Invalid routing.issue action at trigger index ${index}`;
+    }
+    if (!isRecord(routing.board) || routing.board.action !== "shared-board-derive") {
+        return `Invalid routing.board action at trigger index ${index}`;
+    }
+    if (routing.mutateBoardDirectly !== false) {
+        return `Automation routing must disable direct board mutation at trigger index ${index}`;
+    }
+    const source = raw.source;
+    if (!isRecord(source) || typeof source.kind !== "string" || !source.kind) {
+        return `Missing source.kind at trigger index ${index}`;
+    }
+    const audit = raw.audit;
+    if (!isRecord(audit) || typeof audit.createdAt !== "string" || !audit.createdAt) {
+        return `Missing audit.createdAt at trigger index ${index}`;
+    }
+    return null;
+}
+function validateAdmission(raw) {
+    if (raw === undefined)
+        return null;
+    if (!isRecord(raw)) {
+        return "triggerAdmission must be an object";
+    }
+    if (raw.maxPendingRuns !== undefined
+        && (typeof raw.maxPendingRuns !== "number" || !Number.isInteger(raw.maxPendingRuns) || raw.maxPendingRuns < 0)) {
+        return "triggerAdmission.maxPendingRuns must be a non-negative integer";
+    }
+    if (raw.dedupeWindowMs !== undefined
+        && (typeof raw.dedupeWindowMs !== "number" || !Number.isInteger(raw.dedupeWindowMs) || raw.dedupeWindowMs < 0)) {
+        return "triggerAdmission.dedupeWindowMs must be a non-negative integer";
+    }
+    if (raw.rateLimit !== undefined) {
+        if (!isRecord(raw.rateLimit)) {
+            return "triggerAdmission.rateLimit must be an object";
+        }
+        if (typeof raw.rateLimit.maxTriggers !== "number"
+            || !Number.isInteger(raw.rateLimit.maxTriggers)
+            || raw.rateLimit.maxTriggers <= 0) {
+            return "triggerAdmission.rateLimit.maxTriggers must be a positive integer";
+        }
+        if (typeof raw.rateLimit.windowMs !== "number"
+            || !Number.isInteger(raw.rateLimit.windowMs)
+            || raw.rateLimit.windowMs <= 0) {
+            return "triggerAdmission.rateLimit.windowMs must be a positive integer";
+        }
+    }
+    return null;
+}
+function validateConfig(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return { valid: false, error: "Config must be a JSON object" };
+    }
+    const obj = raw;
+    if (typeof obj.workspace !== "string" || !obj.workspace) {
+        return { valid: false, error: "Missing required field: workspace" };
+    }
+    if (!isUnknownArray(obj.triggers)) {
+        return { valid: false, error: "Missing required field: triggers (must be an array)" };
+    }
+    for (let i = 0; i < obj.triggers.length; i++) {
+        const trigger = obj.triggers[i];
+        const error = isRecord(trigger) && trigger.type === "file"
+            ? validateFileTrigger(trigger, i)
+            : validateAutomationRule(trigger, i);
+        if (error) {
+            return { valid: false, error };
+        }
+    }
+    const maxConcurrent = typeof obj.maxConcurrentRuns === "number"
+        ? obj.maxConcurrentRuns
+        : DEFAULT_MAX_CONCURRENT_RUNS;
+    const admissionError = validateAdmission(obj.triggerAdmission);
+    if (admissionError) {
+        return { valid: false, error: admissionError };
+    }
+    return {
+        valid: true,
+        config: {
+            workspace: obj.workspace,
+            triggers: obj.triggers,
+            maxConcurrentRuns: maxConcurrent,
+            triggerAdmission: obj.triggerAdmission,
+        },
+    };
+}
+async function loadDaemonConfig(configPath) {
+    try {
+        let raw;
+        try {
+            raw = await node_fs_1.promises.readFile(configPath, "utf-8");
+        }
+        catch {
+            return (0, apiResult_1.fail)("CONFIG_NOT_FOUND", `Config file not found: ${configPath}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return (0, apiResult_1.fail)("INVALID_CONFIG", `Failed to parse config as JSON: ${configPath}`);
+        }
+        const result = validateConfig(parsed);
+        if (!result.valid) {
+            return (0, apiResult_1.fail)("INVALID_CONFIG", result.error);
+        }
+        return (0, apiResult_1.ok)(result.config);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, apiResult_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function writeDaemonConfig(config, configPath) {
+    try {
+        const dir = path.dirname(configPath);
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        const content = JSON.stringify(config, null, 2);
+        const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+        await node_fs_1.promises.writeFile(tmpPath, content, "utf-8");
+        await node_fs_1.promises.rename(tmpPath, configPath);
+        return (0, apiResult_1.ok)(undefined);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, apiResult_1.fail)("INTERNAL_ERROR", msg);
+    }
+}

package/dist/daemon/daemonLog.d.ts

@@ -0,0 +1,30 @@
+/**
+ * GAP-REMOTE-001: Daemon JSONL logging.
+ *
+ * Appends structured JSON lines to a daemon activation log file.
+ */
+export type DaemonLogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export interface DaemonLogEntry {
+    timestamp: string;
+    event: string;
+    level?: DaemonLogLevel;
+    schemaVersion?: string;
+    sampled?: boolean;
+    sequence?: number;
+    correlationId?: string;
+    traceId?: string;
+    spanId?: string;
+    data?: Record<string, unknown>;
+}
+export interface DaemonLogPolicy {
+    minLevel?: DaemonLogLevel;
+    eventAllowList?: readonly string[];
+    eventDenyList?: readonly string[];
+    sampleRate?: number;
+    maxBytes?: number;
+    maxFiles?: number;
+    schemaVersion?: string;
+}
+export declare function appendDaemonLog(logDir: string, entry: DaemonLogEntry, policy?: DaemonLogPolicy): Promise<void>;
+export declare function readDaemonLog(logDir: string): Promise<DaemonLogEntry[]>;
+//# sourceMappingURL=daemonLog.d.ts.map

package/dist/daemon/daemonLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemonLog.d.ts","sourceRoot":"","sources":["../../src/daemon/daemonLog.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAE3E,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAsED,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,cAAc,EACrB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,EAAE,CAAC,CAY3B"}

package/dist/daemon/daemonLog.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon JSONL logging.
+ *
+ * Appends structured JSON lines to a daemon activation log file.
+ */
+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.appendDaemonLog = appendDaemonLog;
+exports.readDaemonLog = readDaemonLog;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const DEFAULT_SCHEMA_VERSION = "2026.05.daemon-log-v1";
+const LEVEL_RANK = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    fatal: 50,
+};
+function shouldWriteEntry(entry, policy) {
+    if (!policy)
+        return true;
+    if (policy.eventAllowList && !policy.eventAllowList.includes(entry.event)) {
+        return false;
+    }
+    if (policy.eventDenyList?.includes(entry.event)) {
+        return false;
+    }
+    const minLevel = policy.minLevel;
+    if (minLevel) {
+        const entryLevel = entry.level ?? "info";
+        if (LEVEL_RANK[entryLevel] < LEVEL_RANK[minLevel]) {
+            return false;
+        }
+    }
+    const sampleRate = policy.sampleRate;
+    if (sampleRate !== undefined) {
+        if (sampleRate <= 0)
+            return false;
+        if (sampleRate < 1 && deterministicSample(entry, sampleRate) === false) {
+            return false;
+        }
+    }
+    return true;
+}
+function deterministicSample(entry, sampleRate) {
+    const key = `${entry.timestamp}:${entry.event}:${entry.correlationId ?? ""}:${entry.traceId ?? ""}`;
+    let hash = 0;
+    for (let i = 0; i < key.length; i++) {
+        hash = (hash * 31 + key.charCodeAt(i)) >>> 0;
+    }
+    return hash / 0xffffffff < sampleRate;
+}
+async function rotateIfNeeded(logPath, nextLineBytes, policy) {
+    const maxBytes = policy?.maxBytes ?? 0;
+    if (maxBytes <= 0)
+        return;
+    let currentSize = 0;
+    try {
+        currentSize = (await node_fs_1.promises.stat(logPath)).size;
+    }
+    catch {
+        return;
+    }
+    if (currentSize + nextLineBytes <= maxBytes)
+        return;
+    const maxFiles = Math.max(1, policy?.maxFiles ?? 1);
+    for (let index = maxFiles - 1; index >= 1; index--) {
+        const from = `${logPath}.${index}`;
+        const to = `${logPath}.${index + 1}`;
+        await node_fs_1.promises.rename(from, to).catch(() => { });
+    }
+    await node_fs_1.promises.rename(logPath, `${logPath}.1`).catch(() => { });
+}
+async function appendDaemonLog(logDir, entry, policy) {
+    if (!shouldWriteEntry(entry, policy))
+        return;
+    await node_fs_1.promises.mkdir(logDir, { recursive: true });
+    const logPath = path.join(logDir, "daemon.jsonl");
+    const serializedEntry = {
+        ...entry,
+        ...(policy?.schemaVersion && !entry.schemaVersion
+            ? { schemaVersion: policy.schemaVersion }
+            : {}),
+        ...(policy?.sampleRate !== undefined ? { sampled: true } : {}),
+    };
+    if (policy && !serializedEntry.schemaVersion) {
+        serializedEntry.schemaVersion = DEFAULT_SCHEMA_VERSION;
+    }
+    const line = JSON.stringify(serializedEntry) + "\n";
+    await rotateIfNeeded(logPath, Buffer.byteLength(line), policy);
+    await node_fs_1.promises.appendFile(logPath, line, "utf-8");
+}
+async function readDaemonLog(logDir) {
+    const logPath = path.join(logDir, "daemon.jsonl");
+    try {
+        const content = await node_fs_1.promises.readFile(logPath, "utf-8");
+        return content
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim())
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}