lazycodex-ai 5.0.0-beta.62 → 5.0.0-beta.64

package/packages/omo-codex/plugin/components/ulw-loop/dist/sdk/factory.js

@@ -1,9 +1,10 @@
 import { checkpointUlwLoop } from "../checkpoint.js";
 import { checkpointTemplate } from "../checkpoint-template.js";
 import { recordEvidence } from "../evidence.js";
-import { ulwLoopAttemptEvidenceDir } from "../paths.js";
+import { normalizeUlwLoopSessionId, ulwLoopAttemptEvidenceDir, ulwLoopEvidenceRoot, ulwLoopGoalsRelativePath, } from "../paths.js";
 import { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPlan } from "../plan-crud.js";
-import { readUlwLoopPlan } from "../plan-io.js";
+import { listUlwLoopSessionIds, readUlwLoopPlan } from "../plan-io.js";
+import { planMissingError } from "../plan-missing-recovery.js";
 import { recordFinalReviewBlockers } from "../review-blockers.js";
 import { UlwLoopError } from "../runtime.js";
 import { statusNextActions } from "../status-next-actions.js";
@@ -24,8 +25,12 @@ function validateCodexGoalJson(raw) {
 function validateContext(context) {
     if (!context.cwd.trim())
         throw new UlwLoopError("cwd is required.", "ULW_LOOP_CWD_REQUIRED");
-    if (!context.sessionId.trim())
+    const sessionId = context.sessionId.trim();
+    if (!sessionId)
         throw new UlwLoopError("ULW_LOOP_SESSION_ID_REQUIRED: sessionId is required.", "ULW_LOOP_SESSION_ID_REQUIRED");
+    const normalizedSessionId = normalizeUlwLoopSessionId(sessionId);
+    if (normalizedSessionId === null || /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(sessionId))
+        throw new UlwLoopError("ULW_LOOP_SESSION_ID_INVALID: sessionId normalizes to null.", "ULW_LOOP_SESSION_ID_INVALID");
     if (context.surface !== "omo-senpi" && context.surface !== "lazycodex")
         throw new UlwLoopError("surface must be omo-senpi or lazycodex.", "ULW_LOOP_SURFACE_INVALID");
 }
@@ -49,10 +54,11 @@ function isKnownRequest(request) {
 function unreachable(value) {
     throw new UlwLoopError(`Unhandled operation: ${String(value)}`, "ULW_LOOP_OPERATION_UNHANDLED");
 }
-function nextActionsFrom(result) {
-    if (!("nextActions" in result) || !Array.isArray(result.nextActions))
+function stringsFrom(result, key) {
+    if (!(key in result))
         return [];
-    return result.nextActions.filter((action) => typeof action === "string").slice(0, 8);
+    const value = Object.entries(result).find(([name]) => name === key)?.[1];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string").slice(0, 8) : [];
 }
 function checkpointWithValidatedSnapshot(context, scope, args) {
     validateCodexGoalJson(args.codexGoalJson);
@@ -69,10 +75,19 @@ export function createAgentToolkit(context, deps = {}) {
     const invoke = async (operation, fn) => {
         try {
             const result = await fn();
-            const nextActions = typeof result === "object" && result !== null ? nextActionsFrom(result) : [];
-            return await notify(operation, { ok: true, operation, result, nextActions });
+            const nextActions = typeof result === "object" && result !== null ? stringsFrom(result, "nextActions") : [];
+            const warnings = typeof result === "object" && result !== null ? stringsFrom(result, "warnings") : [];
+            return await notify(operation, {
+                ok: true,
+                operation,
+                result,
+                nextActions,
+                ...(warnings.length === 0 ? {} : { warnings }),
+            });
         }
         catch (error) {
+            if (error instanceof UlwLoopError && error.code === "ULW_LOOP_PLAN_MISSING" && context.surface === "omo-senpi")
+                return notify(operation, failure(operation, planMissingError(ulwLoopGoalsRelativePath(scope), listUlwLoopSessionIds(context.cwd), context.surface)));
             const response = caught(operation, error instanceof Error ? error : new Error("ULW_LOOP_ERROR"));
             return notify(operation, response);
         }
@@ -107,14 +122,15 @@ export function createAgentToolkit(context, deps = {}) {
             }
         },
         help: () => invoke("help", async () => ULW_LOOP_MANIFEST),
-        createGoals: (args) => invoke("create-goals", () => createUlwLoopPlan(context.cwd, args, scope)),
+        createGoals: (args) => invoke("create-goals", () => createUlwLoopPlan(context.cwd, args, scope, context.surface)),
         status: () => invoke("status", async () => {
             const plan = await readUlwLoopPlan(context.cwd, scope);
             const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
             return {
                 plan,
                 summary: summarizeUlwLoopPlan(plan),
-                nextActions: statusNextActions(plan),
+                nextActions: statusNextActions(plan, context.surface),
+                evidenceRoot: ulwLoopEvidenceRoot(scope),
                 // Attempt directories are an evidence-layout v2 concept; a v1 plan must not advertise one.
                 ...(active === undefined || plan.evidenceLayoutVersion !== 2
                     ? {}
@@ -125,8 +141,8 @@ export function createAgentToolkit(context, deps = {}) {
         checkpoint: (args) => invoke("checkpoint", () => args.printTemplate === true
             ? checkpointTemplate(context.cwd, scope, args.goalId, { surface: context.surface })
             : checkpointWithValidatedSnapshot(context, scope, args)),
-        steer: (args) => invoke("steer", () => steerUlwLoop(context.cwd, args, scope)),
-        addGoal: (args) => invoke("add-goal", () => addUlwLoopGoal(context.cwd, args, scope)),
+        steer: (args) => invoke("steer", () => steerUlwLoop(context.cwd, args, scope, context.surface)),
+        addGoal: (args) => invoke("add-goal", () => addUlwLoopGoal(context.cwd, args, scope, context.surface)),
         criteria: (args) => invoke("criteria", async () => {
             const plan = await readUlwLoopPlan(context.cwd, scope);
             const goal = plan.goals.find((candidate) => candidate.id === args.goalId);

package/packages/omo-codex/plugin/components/ulw-loop/dist/sdk/manifest.d.ts

@@ -2,7 +2,12 @@ export declare const ULW_LOOP_OPERATIONS: readonly ["help", "create-goals", "sta
 export type UlwLoopOperation = (typeof ULW_LOOP_OPERATIONS)[number];
 export interface ToolkitOperationManifest {
     readonly name: UlwLoopOperation;
+    /** The camelCase method that runs this operation on every SDK surface. */
+    readonly method: string;
     readonly mutating: boolean;
+    readonly description: string;
+    /** Argument field -> type notation; a trailing `?` marks an optional field. */
+    readonly args: Readonly<Record<string, string>>;
 }
 export interface ToolkitManifest {
     readonly version: 1;
@@ -14,33 +19,363 @@ export declare const ULW_LOOP_MANIFEST: {
     name: "ulw-loop";
     operations: ({
         name: "help";
+        method: string;
         mutating: false;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "create-goals";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief: string;
+            codexGoalMode: string;
+            force: string;
+            validationBatchesJson: string;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "status";
+        method: string;
         mutating: false;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "complete-goals";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed: string;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "checkpoint";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            goalId: string;
+            status: string;
+            evidence: string;
+            codexGoalJson: string;
+            qualityGateJson: string;
+            printTemplate: string;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            notes?: never;
+            artifacts?: never;
+            title?: never;
+            objective?: never;
+        };
     } | {
         name: "steer";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind: string;
+            source: string;
+            evidence: string;
+            rationale: string;
+            goalId: string;
+            criterionId: string;
+            scenario: string;
+            expectedEvidence: string;
+            userModel: string;
+            title: string;
+            objective: string;
+            childGoals: string;
+            revisedTitle: string;
+            revisedObjective: string;
+            pendingOrder: string;
+            blockedReason: string;
+            idempotencyKey: string;
+            successCriteria?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "add-goal";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            title: string;
+            objective: string;
+            successCriteria: string;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "criteria";
+        method: string;
         mutating: false;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            goalId: string;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "record-evidence";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            goalId: string;
+            criterionId: string;
+            status: string;
+            evidence: string;
+            notes: string;
+            artifacts: string;
+            title?: never;
+            objective?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "record-review-blockers";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId: string;
+            title: string;
+            objective: string;
+            evidence: string;
+            codexGoalJson: string;
+        };
     })[];
 };

package/packages/omo-codex/plugin/components/ulw-loop/dist/sdk/manifest.js

@@ -10,19 +10,118 @@ export const ULW_LOOP_OPERATIONS = [
     "record-evidence",
     "record-review-blockers",
 ];
+const CRITERION_INPUT = '{ scenario: string, expectedEvidence: string, userModel?: "happy" | "edge" | "regression" | "adversarial", essential?: boolean }';
+const STEER_KINDS = '"add_subgoal" | "split_subgoal" | "reorder_pending" | "revise_pending_wording" | "revise_criterion" | "annotate_ledger" | "mark_blocked_superseded"';
 export const ULW_LOOP_MANIFEST = {
     version: 1,
     name: "ulw-loop",
     operations: [
-        { name: "help", mutating: false },
-        { name: "create-goals", mutating: true },
-        { name: "status", mutating: false },
-        { name: "complete-goals", mutating: true },
-        { name: "checkpoint", mutating: true },
-        { name: "steer", mutating: true },
-        { name: "add-goal", mutating: true },
-        { name: "criteria", mutating: false },
-        { name: "record-evidence", mutating: true },
-        { name: "record-review-blockers", mutating: true },
+        {
+            name: "help",
+            method: "help",
+            mutating: false,
+            description: "Return this manifest: every operation with its method name, argument fields, and what it does.",
+            args: {},
+        },
+        {
+            name: "create-goals",
+            method: "createGoals",
+            mutating: true,
+            description: "Create the session plan from a brief; one goal per bullet, each seeded with placeholder criteria until revised.",
+            args: {
+                brief: "string",
+                codexGoalMode: '"aggregate" | "per_story"?',
+                force: "boolean?",
+                validationBatchesJson: "string?",
+            },
+        },
+        {
+            name: "status",
+            method: "status",
+            mutating: false,
+            description: "Read the plan, its summary, structured nextActions, the stable evidenceRoot, and the active goal's currentAttemptDir.",
+            args: {},
+        },
+        {
+            name: "complete-goals",
+            method: "completeGoals",
+            mutating: true,
+            description: "Acquire the next eligible goal or resume the in-progress one; returns { done: true } once the aggregate is complete.",
+            args: { retryFailed: "boolean?" },
+        },
+        {
+            name: "checkpoint",
+            method: "checkpoint",
+            mutating: true,
+            description: "Close the goal as complete, failed, or blocked with evidence; the final goal also needs the quality gate. printTemplate returns that gate's template instead.",
+            args: {
+                goalId: "string",
+                status: '"complete" | "failed" | "blocked"',
+                evidence: "string",
+                codexGoalJson: "string?",
+                qualityGateJson: "string?",
+                printTemplate: "true? (with goalId? only)",
+            },
+        },
+        {
+            name: "steer",
+            method: "steer",
+            mutating: true,
+            description: "Propose an evidence-backed plan mutation; revise_criterion replaces a criterion's scenario, expectedEvidence, or userModel.",
+            args: {
+                kind: STEER_KINDS,
+                source: '"finding" | "user_prompt_submit" | "cli"',
+                evidence: "string",
+                rationale: "string",
+                goalId: "string?",
+                criterionId: "string? (revise_criterion)",
+                scenario: "string? (revise_criterion)",
+                expectedEvidence: "string? (revise_criterion)",
+                userModel: '"happy" | "edge" | "regression" | "adversarial"? (revise_criterion)',
+                title: "string? (add_subgoal)",
+                objective: "string? (add_subgoal)",
+                childGoals: "{ title: string, objective: string }[]? (split_subgoal)",
+                revisedTitle: "string? (revise_pending_wording)",
+                revisedObjective: "string? (revise_pending_wording)",
+                pendingOrder: "string[]? (reorder_pending)",
+                blockedReason: "string? (mark_blocked_superseded)",
+                idempotencyKey: "string?",
+            },
+        },
+        {
+            name: "add-goal",
+            method: "addGoal",
+            mutating: true,
+            description: "Append a goal; pass successCriteria to define its criteria in the same call, otherwise placeholders name the revise call.",
+            args: { title: "string", objective: "string", successCriteria: `${CRITERION_INPUT}[]?` },
+        },
+        {
+            name: "criteria",
+            method: "criteria",
+            mutating: false,
+            description: "List one goal's success criteria with their status and captured evidence.",
+            args: { goalId: "string" },
+        },
+        {
+            name: "record-evidence",
+            method: "recordEvidence",
+            mutating: true,
+            description: "Record a criterion's pass, fail, or blocked evidence; artifacts must exist (resolved against the session cwd) and are stored with the criterion and the ledger entry.",
+            args: {
+                goalId: "string",
+                criterionId: "string",
+                status: '"pass" | "fail" | "blocked"',
+                evidence: "string",
+                notes: "string?",
+                artifacts: "string[]?",
+            },
+        },
+        {
+            name: "record-review-blockers",
+            method: "recordReviewBlockers",
+            mutating: true,
+            description: "Mark the final goal review_blocked and append the blocker goal the reviewer verdict names.",
+            args: { goalId: "string", title: "string", objective: "string", evidence: "string", codexGoalJson: "string?" },
+        },
     ],
 };

package/packages/omo-codex/plugin/components/ulw-loop/dist/sdk/types.d.ts

@@ -82,11 +82,14 @@ export interface ToolkitFailure<Operation extends string = string> {
     readonly ok: false;
     readonly operation: Operation;
     readonly error: ToolkitError;
+    readonly warnings?: readonly string[];
 }
 type StatusResult = {
     readonly plan: UlwLoopPlan;
     readonly summary: ReturnType<typeof summarizeUlwLoopPlan>;
     readonly nextActions: readonly string[];
+    /** Plan-level evidence directory, stable for the whole run (relative to the session cwd). */
+    readonly evidenceRoot: string;
     readonly currentAttemptDir?: string;
 };
 type ResultFor<Operation extends UlwLoopOperation> = Operation extends "help" ? typeof ULW_LOOP_MANIFEST : Operation extends "create-goals" ? Awaited<ReturnType<typeof createUlwLoopPlan>> : Operation extends "status" ? StatusResult : Operation extends "complete-goals" ? Awaited<ReturnType<typeof startNextUlwLoop>> : Operation extends "checkpoint" ? CheckpointUlwLoopResult | CheckpointTemplate : Operation extends "steer" ? Awaited<ReturnType<typeof steerUlwLoop>> : Operation extends "add-goal" ? Awaited<ReturnType<typeof addUlwLoopGoal>> : Operation extends "criteria" ? {

package/packages/omo-codex/plugin/components/ulw-loop/dist/spawn-budget-io.d.ts

@@ -0,0 +1,5 @@
+export declare function readAdmissionBreaker(sessionId: string): string | null;
+export declare function atomicWriteJson(targetPath: string, data: unknown): void;
+export declare function isNonEmptyFile(path: string): boolean;
+export declare function readCount(counterPath: string): number;
+export declare function readCounts(counterPath: string): Record<string, number>;

package/packages/omo-codex/plugin/components/ulw-loop/dist/spawn-budget-io.js

@@ -0,0 +1,67 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export function readAdmissionBreaker(sessionId) {
+    const dataDir = process.env["PLUGIN_DATA"];
+    if (typeof dataDir !== "string")
+        return null;
+    try {
+        const value = JSON.parse(readFileSync(join(dataDir, "spawn-breaker", `${sessionId}.json`), "utf8"));
+        return typeof value === "object" && value !== null && "reason" in value && typeof value.reason === "string"
+            ? value.reason
+            : "capacity limit";
+    }
+    catch {
+        return null;
+    }
+}
+// These hook budget files are not plan/audit state and remain outside the log.
+export function atomicWriteJson(targetPath, data) {
+    const tmp = join(dirname(targetPath), `.tmp-${randomBytes(6).toString("hex")}`);
+    writeFileSync(tmp, JSON.stringify(data));
+    renameSync(tmp, targetPath);
+}
+export function isNonEmptyFile(path) {
+    try {
+        return existsSync(path) && statSync(path).size > 0;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+export function readCount(counterPath) {
+    try {
+        const parsed = JSON.parse(readFileSync(counterPath, "utf8"));
+        return typeof parsed === "object" &&
+            parsed !== null &&
+            "count" in parsed &&
+            typeof parsed.count === "number" &&
+            parsed.count >= 0
+            ? parsed.count
+            : 0;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return 0;
+        throw error;
+    }
+}
+export function readCounts(counterPath) {
+    try {
+        const parsed = JSON.parse(readFileSync(counterPath, "utf8"));
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+            return {};
+        const counts = {};
+        for (const [key, value] of Object.entries(parsed))
+            if (typeof value === "number" && value >= 0)
+                counts[key] = value;
+        return counts;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return {};
+        throw error;
+    }
+}