@suwujs/king-ai 0.2.0

package/dist/src/host-ledger.js

@@ -0,0 +1,554 @@
+import { join, resolve } from "node:path";
+import { appendJsonl, compactJsonl, readJsonl } from "./jsonl.js";
+export function hostTasksPathForOutputDir(outputDir = "deliverables") {
+    return join(resolve(outputDir), "tasks.jsonl");
+}
+export function hostCapsulesPathForOutputDir(outputDir = "deliverables") {
+    return join(resolve(outputDir), "capsules.jsonl");
+}
+export function hostWorkflowPathForOutputDir(outputDir = "deliverables") {
+    return join(resolve(outputDir), "workflow.jsonl");
+}
+export async function createHostTask(input, now = () => new Date()) {
+    const createdAt = now().toISOString();
+    const task = {
+        id: safeId(input.id) ?? buildId("task", createdAt),
+        title: requiredString(input.title, "task title"),
+        status: normalizeTaskStatus(input.status ?? "pending"),
+        createdAt,
+        assignee: cleanString(input.assignee),
+        ownerRole: cleanString(input.ownerRole),
+        reviewerRole: cleanString(input.reviewerRole),
+        priority: cleanString(input.priority),
+        dependsOn: normalizeStringArray(input.dependsOn, "dependsOn"),
+        capsuleId: cleanString(input.capsuleId),
+        acceptance: normalizeStringArray(input.acceptance, "acceptance"),
+        detail: cleanString(input.detail)
+    };
+    await appendJsonl(taskPath(input), task);
+    return task;
+}
+export async function updateHostTask(input, now = () => new Date()) {
+    const id = requiredId(input.id, "task id");
+    const existing = (await listHostTasks({ outputDir: input.outputDir, tasksFile: input.tasksFile })).find((task) => task.id === id);
+    if (!existing)
+        throw new Error(`host task not found: ${id}`);
+    const update = dropUndefined({
+        id,
+        updatedAt: now().toISOString(),
+        status: input.status === undefined ? undefined : normalizeTaskStatus(input.status),
+        assignee: cleanString(input.assignee),
+        ownerRole: cleanString(input.ownerRole),
+        reviewerRole: cleanString(input.reviewerRole),
+        priority: cleanString(input.priority),
+        dependsOn: input.dependsOn === undefined ? undefined : normalizeStringArray(input.dependsOn, "dependsOn"),
+        capsuleId: cleanString(input.capsuleId),
+        acceptance: input.acceptance === undefined ? undefined : normalizeStringArray(input.acceptance, "acceptance"),
+        detail: cleanString(input.detail),
+        result: cleanString(input.result)
+    });
+    await appendJsonl(taskPath(input), update);
+    return applyTaskUpdate(existing, update);
+}
+export async function listHostTasks(input = {}) {
+    const status = input.status === undefined ? undefined : normalizeTaskStatus(input.status);
+    const assignee = cleanString(input.assignee);
+    const limit = normalizeLimit(input.limit);
+    const tasks = await readMergedTasks(taskPath(input));
+    const filtered = tasks.filter((task) => {
+        if (status && task.status !== status)
+            return false;
+        if (assignee && task.assignee !== assignee)
+            return false;
+        return true;
+    });
+    return limit ? filtered.slice(-limit).reverse() : filtered;
+}
+export async function buildHostAgenda(input = {}) {
+    const tasks = await listHostTasks(input);
+    const done = new Set(tasks.filter((task) => task.status === "done" || task.status === "cancelled").map((task) => task.id));
+    const agendaTasks = tasks
+        .filter((task) => task.status !== "done" && task.status !== "cancelled")
+        .map((task) => {
+        const blockedBy = task.dependsOn.filter((id) => !done.has(id));
+        return {
+            ...task,
+            blockedBy,
+            ready: task.status !== "blocked" && blockedBy.length === 0
+        };
+    });
+    const ready = agendaTasks.filter((task) => task.ready);
+    const blocked = agendaTasks.filter((task) => !task.ready);
+    const limit = normalizeLimit(input.limit);
+    const selected = (limit ? agendaTasks.slice(0, limit) : agendaTasks);
+    return {
+        tasks: selected,
+        readyCount: ready.length,
+        blockedCount: blocked.length,
+        summary: formatHostAgenda({ tasks: selected, readyCount: ready.length, blockedCount: blocked.length })
+    };
+}
+export async function createHostCapsule(input, now = () => new Date()) {
+    const createdAt = now().toISOString();
+    const capsule = {
+        id: safeId(input.id) ?? buildId("capsule", createdAt),
+        status: normalizeCapsuleStatus(input.status ?? "open"),
+        createdAt,
+        taskId: cleanString(input.taskId),
+        goal: requiredString(input.goal, "capsule goal"),
+        owner: requiredString(input.owner, "capsule owner"),
+        branchOrWorktree: requiredString(input.branchOrWorktree, "capsule branchOrWorktree"),
+        allowedPaths: requiredStringArray(input.allowedPaths, "allowedPaths"),
+        acceptance: requiredStringArray(input.acceptance, "acceptance"),
+        reviewer: requiredString(input.reviewer, "capsule reviewer"),
+        verificationCommands: requiredStringArray(input.verificationCommands, "verificationCommands")
+    };
+    await appendJsonl(capsulePath(input), capsule);
+    return capsule;
+}
+export async function updateHostCapsule(input, now = () => new Date()) {
+    const id = requiredId(input.id, "capsule id");
+    const existing = (await listHostCapsules({ outputDir: input.outputDir, capsulesFile: input.capsulesFile })).find((capsule) => capsule.id === id);
+    if (!existing)
+        throw new Error(`host capsule not found: ${id}`);
+    const update = dropUndefined({
+        id,
+        updatedAt: now().toISOString(),
+        status: input.status === undefined ? undefined : normalizeCapsuleStatus(input.status),
+        taskId: cleanString(input.taskId),
+        goal: cleanString(input.goal),
+        owner: cleanString(input.owner),
+        branchOrWorktree: cleanString(input.branchOrWorktree),
+        allowedPaths: input.allowedPaths === undefined ? undefined : requiredStringArray(input.allowedPaths, "allowedPaths"),
+        acceptance: input.acceptance === undefined ? undefined : requiredStringArray(input.acceptance, "acceptance"),
+        reviewer: cleanString(input.reviewer),
+        verificationCommands: input.verificationCommands === undefined ? undefined : requiredStringArray(input.verificationCommands, "verificationCommands")
+    });
+    await appendJsonl(capsulePath(input), update);
+    return applyCapsuleUpdate(existing, update);
+}
+export async function listHostCapsules(input = {}) {
+    const status = input.status === undefined ? undefined : normalizeCapsuleStatus(input.status);
+    const owner = cleanString(input.owner);
+    const limit = normalizeLimit(input.limit);
+    const capsules = await readMergedCapsules(capsulePath(input));
+    const filtered = capsules.filter((capsule) => {
+        if (status && capsule.status !== status)
+            return false;
+        if (owner && capsule.owner !== owner)
+            return false;
+        return true;
+    });
+    return limit ? filtered.slice(-limit).reverse() : filtered;
+}
+export async function getHostCapsule(input) {
+    const id = requiredId(input.id, "capsule id");
+    return (await listHostCapsules(input)).find((capsule) => capsule.id === id) ?? null;
+}
+export async function createHostWorkflowCard(input, now = () => new Date()) {
+    const createdAt = now().toISOString();
+    const card = {
+        kind: normalizeWorkflowKind(input.kind),
+        id: safeId(input.id) ?? buildId(input.kind, createdAt),
+        title: requiredString(input.title, "workflow title"),
+        status: normalizeWorkflowStatus(input.status ?? defaultWorkflowStatus(input.kind)),
+        createdAt,
+        ownerRole: cleanString(input.ownerRole),
+        reviewerRole: cleanString(input.reviewerRole),
+        assignee: cleanString(input.assignee),
+        priority: cleanString(input.priority),
+        dependsOn: normalizeStringArray(input.dependsOn, "dependsOn"),
+        acceptance: normalizeStringArray(input.acceptance, "acceptance"),
+        handoffPolicy: input.handoffPolicy,
+        sourceId: cleanString(input.sourceId),
+        targetRole: cleanString(input.targetRole),
+        decisionBy: cleanString(input.decisionBy),
+        artifactPath: cleanString(input.artifactPath),
+        detail: cleanString(input.detail),
+        result: cleanString(input.result),
+        metadata: normalizeMetadata(input.metadata)
+    };
+    await appendJsonl(workflowPath(input), card);
+    return card;
+}
+export async function updateHostWorkflowCard(input, now = () => new Date()) {
+    const id = requiredId(input.id, "workflow id");
+    const cards = await listHostWorkflowCards({ outputDir: input.outputDir, workflowFile: input.workflowFile });
+    const existing = cards.find((card) => card.id === id);
+    if (!existing)
+        throw new Error(`host workflow card not found: ${id}`);
+    const update = dropUndefined({
+        id,
+        updatedAt: now().toISOString(),
+        status: input.status === undefined ? undefined : normalizeWorkflowStatus(input.status),
+        ownerRole: cleanString(input.ownerRole),
+        reviewerRole: cleanString(input.reviewerRole),
+        assignee: cleanString(input.assignee),
+        priority: cleanString(input.priority),
+        dependsOn: input.dependsOn === undefined ? undefined : normalizeStringArray(input.dependsOn, "dependsOn"),
+        acceptance: input.acceptance === undefined ? undefined : normalizeStringArray(input.acceptance, "acceptance"),
+        handoffPolicy: input.handoffPolicy,
+        sourceId: cleanString(input.sourceId),
+        targetRole: cleanString(input.targetRole),
+        decisionBy: cleanString(input.decisionBy),
+        artifactPath: cleanString(input.artifactPath),
+        detail: cleanString(input.detail),
+        result: cleanString(input.result),
+        metadata: normalizeMetadata(input.metadata)
+    });
+    const merged = applyWorkflowUpdate(existing, update);
+    validateWorkflowUpdate(existing, merged, cards);
+    await appendJsonl(workflowPath(input), update);
+    return merged;
+}
+export async function listHostWorkflowCards(input = {}) {
+    const kind = input.kind === undefined ? undefined : normalizeWorkflowKind(input.kind);
+    const status = input.status === undefined ? undefined : normalizeWorkflowStatus(input.status);
+    const ownerRole = cleanString(input.ownerRole);
+    const reviewerRole = cleanString(input.reviewerRole);
+    const assignee = cleanString(input.assignee);
+    const limit = normalizeLimit(input.limit);
+    const cards = await readMergedWorkflowCards(workflowPath(input));
+    const filtered = cards.filter((card) => {
+        if (kind && card.kind !== kind)
+            return false;
+        if (status && card.status !== status)
+            return false;
+        if (ownerRole && card.ownerRole !== ownerRole)
+            return false;
+        if (reviewerRole && card.reviewerRole !== reviewerRole)
+            return false;
+        if (assignee && card.assignee !== assignee)
+            return false;
+        return true;
+    });
+    return limit ? filtered.slice(-limit).reverse() : filtered;
+}
+export function formatHostWorkflowCards(cards) {
+    if (cards.length === 0)
+        return "no host workflow cards";
+    return cards.map((card) => {
+        const owner = card.ownerRole ? ` ownerRole=${card.ownerRole}` : "";
+        const reviewer = card.reviewerRole ? ` reviewerRole=${card.reviewerRole}` : "";
+        const assignee = card.assignee ? ` @${card.assignee}` : "";
+        const deps = card.dependsOn.length ? ` dependsOn=${card.dependsOn.join(",")}` : "";
+        const artifact = card.artifactPath ? ` artifact=${card.artifactPath}` : "";
+        return `${card.id} ${card.kind} ${card.status}${assignee}${owner}${reviewer}${deps}${artifact}: ${card.title}`;
+    }).join("\n");
+}
+export function formatHostTasks(tasks) {
+    if (tasks.length === 0)
+        return "no host tasks";
+    return tasks.map((task) => {
+        const deps = task.dependsOn.length ? ` dependsOn=${task.dependsOn.join(",")}` : "";
+        const capsule = task.capsuleId ? ` capsule=${task.capsuleId}` : "";
+        const owner = task.ownerRole ? ` ownerRole=${task.ownerRole}` : "";
+        const reviewer = task.reviewerRole ? ` reviewerRole=${task.reviewerRole}` : "";
+        return `${task.id} ${task.status}${task.assignee ? ` @${task.assignee}` : ""}${owner}${reviewer}${deps}${capsule}: ${task.title}`;
+    }).join("\n");
+}
+export function formatHostCapsules(capsules) {
+    if (capsules.length === 0)
+        return "no host capsules";
+    return capsules.map((capsule) => {
+        const task = capsule.taskId ? ` task=${capsule.taskId}` : "";
+        return `${capsule.id} ${capsule.status} owner=${capsule.owner} reviewer=${capsule.reviewer}${task}: ${capsule.goal}`;
+    }).join("\n");
+}
+export function formatHostAgenda(agenda) {
+    const lines = [`agenda: ready=${agenda.readyCount} blocked=${agenda.blockedCount}`];
+    if (agenda.tasks.length === 0) {
+        lines.push("no open host tasks");
+        return lines.join("\n");
+    }
+    for (const task of agenda.tasks) {
+        const blockedBy = task.blockedBy.length ? ` blockedBy=${task.blockedBy.join(",")}` : "";
+        lines.push(`${task.ready ? "ready" : "blocked"} ${task.id}${task.assignee ? ` @${task.assignee}` : ""}${blockedBy}: ${task.title}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Rewrite the append-only task, capsule, and workflow logs into their merged latest-state
+ * snapshots. The result is observationally identical to the pre-compaction ledger but drops
+ * superseded update records, bounding unbounded log growth from long multi-role runs.
+ */
+export async function compactHostLedger(input = {}) {
+    const tasks = await compactJsonl(taskPath(input), (records) => mergeTasks(records));
+    const capsules = await compactJsonl(capsulePath(input), (records) => mergeCapsules(records));
+    const workflow = await compactJsonl(workflowPath(input), (records) => mergeWorkflowCards(records));
+    return { tasks, capsules, workflow };
+}
+export function formatHostLedgerCompact(result) {
+    const line = (label, entry) => `${label}: ${entry.records} -> ${entry.written} records (${entry.path})`;
+    return [
+        "ledger compacted",
+        line("tasks", result.tasks),
+        line("capsules", result.capsules),
+        line("workflow", result.workflow)
+    ].join("\n");
+}
+function taskPath(input) {
+    return input.tasksFile ? resolve(input.tasksFile) : hostTasksPathForOutputDir(input.outputDir);
+}
+function capsulePath(input) {
+    return input.capsulesFile ? resolve(input.capsulesFile) : hostCapsulesPathForOutputDir(input.outputDir);
+}
+function workflowPath(input) {
+    return input.workflowFile ? resolve(input.workflowFile) : hostWorkflowPathForOutputDir(input.outputDir);
+}
+function mergeTasks(records) {
+    const byId = new Map();
+    for (const record of records) {
+        if (isTask(record))
+            byId.set(record.id, record);
+        else if (isTaskUpdate(record)) {
+            const existing = byId.get(record.id);
+            if (existing)
+                byId.set(record.id, applyTaskUpdate(existing, record));
+        }
+    }
+    return [...byId.values()];
+}
+function mergeCapsules(records) {
+    const byId = new Map();
+    for (const record of records) {
+        if (isCapsule(record))
+            byId.set(record.id, record);
+        else if (isCapsuleUpdate(record)) {
+            const existing = byId.get(record.id);
+            if (existing)
+                byId.set(record.id, applyCapsuleUpdate(existing, record));
+        }
+    }
+    return [...byId.values()];
+}
+function mergeWorkflowCards(records) {
+    const byId = new Map();
+    for (const record of records) {
+        if (isWorkflowCard(record))
+            byId.set(record.id, record);
+        else if (isWorkflowUpdate(record)) {
+            const existing = byId.get(record.id);
+            if (existing)
+                byId.set(record.id, applyWorkflowUpdate(existing, record));
+        }
+    }
+    return [...byId.values()];
+}
+async function readMergedTasks(path) {
+    return mergeTasks(await readJsonl(path));
+}
+async function readMergedCapsules(path) {
+    return mergeCapsules(await readJsonl(path));
+}
+async function readMergedWorkflowCards(path) {
+    return mergeWorkflowCards(await readJsonl(path));
+}
+function applyTaskUpdate(task, update) {
+    return {
+        ...task,
+        status: update.status ?? task.status,
+        assignee: update.assignee ?? task.assignee,
+        ownerRole: update.ownerRole ?? task.ownerRole,
+        reviewerRole: update.reviewerRole ?? task.reviewerRole,
+        priority: update.priority ?? task.priority,
+        dependsOn: update.dependsOn ?? task.dependsOn,
+        capsuleId: update.capsuleId ?? task.capsuleId,
+        acceptance: update.acceptance ?? task.acceptance,
+        detail: update.detail ?? task.detail,
+        result: update.result ?? task.result,
+        updatedAt: update.updatedAt
+    };
+}
+function applyWorkflowUpdate(card, update) {
+    return {
+        ...card,
+        status: update.status ?? card.status,
+        ownerRole: update.ownerRole ?? card.ownerRole,
+        reviewerRole: update.reviewerRole ?? card.reviewerRole,
+        assignee: update.assignee ?? card.assignee,
+        priority: update.priority ?? card.priority,
+        dependsOn: update.dependsOn ?? card.dependsOn,
+        acceptance: update.acceptance ?? card.acceptance,
+        handoffPolicy: update.handoffPolicy ?? card.handoffPolicy,
+        sourceId: update.sourceId ?? card.sourceId,
+        targetRole: update.targetRole ?? card.targetRole,
+        decisionBy: update.decisionBy ?? card.decisionBy,
+        artifactPath: update.artifactPath ?? card.artifactPath,
+        detail: update.detail ?? card.detail,
+        result: update.result ?? card.result,
+        metadata: update.metadata ?? card.metadata,
+        updatedAt: update.updatedAt
+    };
+}
+function validateWorkflowUpdate(existing, next, cards) {
+    if (next.status !== "done")
+        return;
+    const done = new Set(cards
+        .filter((card) => card.id !== next.id && (card.status === "done" || card.status === "cancelled"))
+        .map((card) => card.id));
+    const blockedBy = next.dependsOn.filter((id) => !done.has(id));
+    if (blockedBy.length > 0) {
+        throw new Error(`workflow card ${next.id} depends on unfinished workflow cards: ${blockedBy.join(", ")}`);
+    }
+    if (next.acceptance.length > 0 && !next.result && !next.artifactPath) {
+        throw new Error(`workflow card ${next.id} requires result or artifactPath before marking done`);
+    }
+    if (next.kind === "review" && !reviewVerdict(next.result)) {
+        throw new Error(`review card ${next.id} requires result=approved or result=changes_requested before marking done`);
+    }
+    void existing;
+}
+function reviewVerdict(result) {
+    const value = result?.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    if (!value)
+        return undefined;
+    if (value === "approved" || value === "approve" || value === "accepted" || value === "pass" || value === "passed")
+        return "approved";
+    if (value === "changes_requested" || value === "change_requested" || value === "rejected" || value === "needs_work" || value === "fail" || value === "failed")
+        return "changes_requested";
+    return undefined;
+}
+function applyCapsuleUpdate(capsule, update) {
+    return {
+        ...capsule,
+        status: update.status ?? capsule.status,
+        taskId: update.taskId ?? capsule.taskId,
+        goal: update.goal ?? capsule.goal,
+        owner: update.owner ?? capsule.owner,
+        branchOrWorktree: update.branchOrWorktree ?? capsule.branchOrWorktree,
+        allowedPaths: update.allowedPaths ?? capsule.allowedPaths,
+        acceptance: update.acceptance ?? capsule.acceptance,
+        reviewer: update.reviewer ?? capsule.reviewer,
+        verificationCommands: update.verificationCommands ?? capsule.verificationCommands,
+        updatedAt: update.updatedAt
+    };
+}
+function isTask(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.id === "string" && typeof record.title === "string" && Array.isArray(record.dependsOn) && Array.isArray(record.acceptance) && isTaskStatus(record.status);
+}
+function isTaskUpdate(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.id === "string" && typeof record.updatedAt === "string" && !("title" in record);
+}
+function isCapsule(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.id === "string" && typeof record.goal === "string" && Array.isArray(record.allowedPaths) && isCapsuleStatus(record.status);
+}
+function isCapsuleUpdate(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.id === "string" && typeof record.updatedAt === "string" && !("createdAt" in record);
+}
+function isWorkflowCard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.id === "string" && typeof record.title === "string" && isWorkflowKind(record.kind) && isWorkflowStatus(record.status) && Array.isArray(record.dependsOn) && Array.isArray(record.acceptance);
+}
+function isWorkflowUpdate(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.id === "string" && typeof record.updatedAt === "string" && !("kind" in record);
+}
+function normalizeTaskStatus(value) {
+    if (isTaskStatus(value))
+        return value;
+    throw new Error(`invalid task status: ${String(value)}`);
+}
+function isTaskStatus(value) {
+    return value === "pending" || value === "in_progress" || value === "blocked" || value === "done" || value === "cancelled";
+}
+function normalizeCapsuleStatus(value) {
+    if (isCapsuleStatus(value))
+        return value;
+    throw new Error(`invalid capsule status: ${String(value)}`);
+}
+function isCapsuleStatus(value) {
+    return value === "open" || value === "in_review" || value === "accepted" || value === "abandoned";
+}
+function normalizeWorkflowKind(value) {
+    if (isWorkflowKind(value))
+        return value;
+    throw new Error(`invalid workflow kind: ${String(value)}`);
+}
+function isWorkflowKind(value) {
+    return value === "initiative" || value === "task" || value === "handoff" || value === "review" || value === "decision" || value === "artifact";
+}
+function normalizeWorkflowStatus(value) {
+    if (isWorkflowStatus(value))
+        return value;
+    throw new Error(`invalid workflow status: ${String(value)}`);
+}
+function isWorkflowStatus(value) {
+    return value === "open" || value === "assigned" || value === "in_progress" || value === "blocked" || value === "review" || value === "waiting_human" || value === "done" || value === "cancelled";
+}
+function defaultWorkflowStatus(kind) {
+    return kind === "decision" ? "waiting_human" : "open";
+}
+function normalizeLimit(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        throw new Error("limit must be a positive integer");
+    return Math.floor(parsed);
+}
+function normalizeStringArray(value, label) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`${label} must be an array`);
+    return value.map((entry) => requiredString(entry, label));
+}
+function requiredStringArray(value, label) {
+    const entries = normalizeStringArray(value, label);
+    if (entries.length === 0)
+        throw new Error(`${label} must include at least one entry`);
+    return entries;
+}
+function requiredString(value, label) {
+    const cleaned = cleanString(value);
+    if (!cleaned)
+        throw new Error(`${label} is required`);
+    return cleaned;
+}
+function requiredId(value, label) {
+    const cleaned = safeId(value);
+    if (!cleaned)
+        throw new Error(`${label} is required`);
+    return cleaned;
+}
+function safeId(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const cleaned = value.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(cleaned))
+        throw new Error(`invalid id: ${cleaned}`);
+    return cleaned;
+}
+function buildId(prefix, iso) {
+    return `${prefix}-${iso.replace(/[:.]/g, "-").slice(0, 19)}`;
+}
+function cleanString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function normalizeMetadata(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("metadata must be an object");
+    return value;
+}
+function dropUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}

package/dist/src/host-loop-events.d.ts

@@ -0,0 +1,69 @@
+export interface HostLoopEvent {
+    type?: string;
+    runId?: string;
+    loop?: number;
+    timestamp?: string;
+    agent?: string;
+    classification?: string;
+    [key: string]: unknown;
+}
+export interface HostLoopEventsInput {
+    file?: string;
+    outputDir?: string;
+    runId?: string;
+    agent?: string;
+    type?: string;
+    classification?: string;
+    tail?: number;
+    resultsFile?: string;
+    writeResults?: boolean;
+}
+export interface HostLoopEventAppendInput {
+    file?: string;
+    outputDir?: string;
+    event: HostLoopEvent;
+}
+export interface HostLoopEventsResult {
+    file: string;
+    events: HostLoopEvent[];
+    totalEvents: number;
+    filteredEvents: number;
+    summary: HostLoopEventsSummary;
+    results: HostLoopResultsTable;
+}
+export interface HostLoopEventsSummary {
+    loops: number;
+    classifications: Record<string, number>;
+    productiveRate: number;
+}
+export interface HostLoopResultsTable {
+    file: string;
+    rows: HostLoopResultsRow[];
+    written: boolean;
+    text?: string;
+}
+export interface HostLoopResultsRow {
+    runId: string;
+    loop: number;
+    timestamp: string;
+    classification: string;
+    tasksCreated: number;
+    tasksDone: number;
+    artifactsCreated: number;
+    pendingMessages: number;
+    completionRate: string;
+    notes: string;
+}
+export interface HostLoopResultsInput {
+    file?: string;
+    outputDir?: string;
+    resultsFile?: string;
+}
+export declare const HOST_LOOP_RESULTS_HEADER: string;
+export declare function appendHostLoopEvent(input: HostLoopEventAppendInput): Promise<string>;
+export declare function readHostLoopEvents(input?: HostLoopEventsInput): Promise<HostLoopEventsResult>;
+export declare function readHostLoopResults(input?: HostLoopResultsInput): Promise<HostLoopResultsTable>;
+export declare function formatHostLoopEvents(result: HostLoopEventsResult): string;
+export declare function buildLoopResultsRows(events: HostLoopEvent[]): HostLoopResultsRow[];
+export declare function formatLoopResultsTable(rows: HostLoopResultsRow[]): string;
+export declare function parseLoopResultsTable(text: string): HostLoopResultsRow[];