@cavi-ai/api-client 0.1.0

package/dist/extensions/cavi/project-board/mutations.js

@@ -0,0 +1,210 @@
+import { GatewayHttpError } from "../../../core/http/gateway-error.js";
+import { withMutationResult, } from "../../../core/gateway/envelope/index.js";
+import { describeHttpContract } from "../../../core/http/contracts.js";
+import { PROJECT_BOARD_API, projectBoardBacklogItemPath, } from "../contracts/paths.js";
+import { PROJECT_BOARD_FALLBACK_LIMITATIONS, } from "./constants.js";
+import { normalizeProjectBoardBacklogItem, normalizeEmailAddress, parseProjectBoardCallAck, } from "./normalize.js";
+import { createTraceId } from "./trace-id.js";
+export function createProjectBoardMutations(requestJson, projectBoardLive) {
+    const { loadProjectBoardProfileForEmailMutation, persistProjectBoardEmails, toBacklogMutationPayload, } = projectBoardLive;
+    return {
+        createProjectBoardEmail: async (draft) => withMutationResult({
+            area: "project-board-email-create",
+            expectedContract: describeHttpContract("PUT", PROJECT_BOARD_API.profile, "{ emails: string[] }"),
+            note: "Project Board profile email mutation failed",
+            fallback: () => ({
+                id: normalizeEmailAddress(draft.email) ?? `mock-email-${Date.now()}`,
+                email: normalizeEmailAddress(draft.email) ??
+                    draft.email.trim().toLowerCase(),
+            }),
+            run: async () => {
+                const email = normalizeEmailAddress(draft.email);
+                if (!email) {
+                    throw new Error("Valid email address required.");
+                }
+                const profile = await loadProjectBoardProfileForEmailMutation();
+                if (profile.emails.includes(email)) {
+                    return { id: email, email };
+                }
+                const updatedProfile = await persistProjectBoardEmails([
+                    ...profile.emails,
+                    email,
+                ]);
+                const persistedEmail = updatedProfile.emails.find((entry) => entry === email) ?? email;
+                return {
+                    id: persistedEmail,
+                    email: persistedEmail,
+                };
+            },
+        }),
+        updateProjectBoardEmail: async (emailId, draft) => withMutationResult({
+            area: "project-board-email-update",
+            expectedContract: describeHttpContract("PUT", PROJECT_BOARD_API.profile, "{ emails: string[] }"),
+            note: "Project Board profile email update failed",
+            fallback: () => ({
+                id: normalizeEmailAddress(draft.email) ?? emailId,
+                email: normalizeEmailAddress(draft.email) ??
+                    draft.email.trim().toLowerCase(),
+            }),
+            run: async () => {
+                const nextEmail = normalizeEmailAddress(draft.email);
+                if (!nextEmail) {
+                    throw new Error("Valid email address required.");
+                }
+                const profile = await loadProjectBoardProfileForEmailMutation();
+                const currentId = normalizeEmailAddress(emailId);
+                if (!currentId || !profile.emails.includes(currentId)) {
+                    throw new Error("Email recipient not found.");
+                }
+                const nextEmails = profile.emails.map((email) => email === currentId ? nextEmail : email);
+                const updatedProfile = await persistProjectBoardEmails(nextEmails);
+                const persistedEmail = updatedProfile.emails.find((email) => email === nextEmail) ??
+                    nextEmail;
+                return {
+                    id: persistedEmail,
+                    email: persistedEmail,
+                };
+            },
+        }),
+        removeProjectBoardEmail: async (emailId) => withMutationResult({
+            area: "project-board-email-delete",
+            expectedContract: describeHttpContract("PUT", PROJECT_BOARD_API.profile, "{ emails: string[] }"),
+            note: "Project Board profile email delete failed",
+            fallback: () => ({ id: emailId }),
+            run: async () => {
+                const normalizedEmailId = normalizeEmailAddress(emailId);
+                if (!normalizedEmailId) {
+                    throw new Error("Email recipient id is invalid.");
+                }
+                const profile = await loadProjectBoardProfileForEmailMutation();
+                const nextEmails = profile.emails.filter((email) => email !== normalizedEmailId);
+                if (nextEmails.length === profile.emails.length) {
+                    throw new Error("Email recipient not found.");
+                }
+                await persistProjectBoardEmails(nextEmails);
+                return { id: normalizedEmailId };
+            },
+        }),
+        createProjectBoardBacklogItem: async (draft) => withMutationResult({
+            area: "project-board-backlog-create",
+            expectedContract: describeHttpContract("POST", PROJECT_BOARD_API.backlog),
+            note: "Project Board backlog create failed",
+            fallback: () => ({
+                id: `mock-backlog-${Date.now()}`,
+                title: draft.title.trim(),
+                description: draft.description.trim() || null,
+                section: draft.section.trim().toLowerCase() || "inbox",
+                priority: draft.priority,
+                status: draft.status,
+                tags: draft.tags,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            }),
+            run: async () => {
+                const payload = toBacklogMutationPayload(draft);
+                const response = await requestJson(PROJECT_BOARD_API.backlog, {
+                    method: "POST",
+                    body: payload,
+                });
+                const item = normalizeProjectBoardBacklogItem(response);
+                if (!item) {
+                    throw new Error("Gateway returned invalid backlog item payload.");
+                }
+                return item;
+            },
+        }),
+        updateProjectBoardBacklogItem: async (itemId, draft) => withMutationResult({
+            area: "project-board-backlog-update",
+            expectedContract: describeHttpContract("PATCH", `${PROJECT_BOARD_API.backlog}/:id`),
+            note: "Project Board backlog update failed",
+            fallback: () => ({
+                id: itemId,
+                title: draft.title.trim(),
+                description: draft.description.trim() || null,
+                section: draft.section.trim().toLowerCase() || "inbox",
+                priority: draft.priority,
+                status: draft.status,
+                tags: draft.tags,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            }),
+            run: async () => {
+                const payload = toBacklogMutationPayload(draft);
+                const response = await requestJson(projectBoardBacklogItemPath(itemId), {
+                    method: "PATCH",
+                    body: payload,
+                });
+                const item = normalizeProjectBoardBacklogItem(response);
+                if (!item) {
+                    throw new Error("Gateway returned invalid backlog item payload.");
+                }
+                return item;
+            },
+        }),
+        callProjectBoard: async (request) => withMutationResult({
+            area: "project-board-call",
+            expectedContract: describeHttpContract("POST", PROJECT_BOARD_API.call, "{ action, requestedBy, metadata }"),
+            note: "Project Board call endpoint failed",
+            fallback: () => {
+                const traceId = createTraceId();
+                return {
+                    ackId: `project-board-call-${traceId}`,
+                    status: "queued",
+                    action: request.action,
+                    requestedBy: request.requestedBy,
+                    queuedAt: Date.now(),
+                    queueDepth: 0,
+                    note: "Project Board call endpoint unavailable. Action stored as local fallback only.",
+                    storage: "json-file",
+                    limitations: PROJECT_BOARD_FALLBACK_LIMITATIONS,
+                    traceId,
+                };
+            },
+            run: async () => {
+                const traceId = createTraceId();
+                const action = request.action.trim();
+                const requestedBy = request.requestedBy.trim() || "cavi-control-ui";
+                if (!action) {
+                    throw new Error("Project Board action is required.");
+                }
+                const payload = {
+                    action,
+                    requestedBy,
+                    metadata: {
+                        ...request.metadata,
+                        source: "cavi-control-ui",
+                        traceId,
+                    },
+                };
+                try {
+                    const response = await requestJson(PROJECT_BOARD_API.call, {
+                        method: "POST",
+                        body: payload,
+                    });
+                    return parseProjectBoardCallAck(response, {
+                        action,
+                        requestedBy,
+                        traceId,
+                    });
+                }
+                catch (error) {
+                    if (!(error instanceof GatewayHttpError) ||
+                        (error.status !== 422 && error.status !== 404)) {
+                        throw error;
+                    }
+                    const compatResponse = await requestJson(PROJECT_BOARD_API.call, {
+                        method: "POST",
+                        body: {
+                            instruction: action,
+                        },
+                    });
+                    return parseProjectBoardCallAck(compatResponse, {
+                        action,
+                        requestedBy,
+                        traceId,
+                    });
+                }
+            },
+        }),
+    };
+}

package/dist/extensions/cavi/project-board/normalize.d.ts

@@ -0,0 +1,23 @@
+import type { ProjectBoardBacklogPriority, ProjectBoardBacklogStatus, ProjectBoardCallResult, ProjectBoardProfile, ProjectBoardWorkspaceSnapshot } from "../domain/index.js";
+import type { ProjectBoardBacklogApiItemResponse } from "./constants.js";
+export declare function normalizeProjectBoardPriority(value: unknown): ProjectBoardBacklogPriority;
+export declare function normalizeProjectBoardStatus(value: unknown): ProjectBoardBacklogStatus;
+export declare function normalizeEmailAddress(value: unknown): string | null;
+export declare function normalizeEmailList(emails: string[]): string[];
+export declare function normalizeLimitations(value: unknown): readonly string[];
+export declare function normalizeSection(value: unknown): string;
+export declare function sortBacklogItems(items: ProjectBoardBacklogApiItemResponse[]): ProjectBoardBacklogApiItemResponse[];
+export declare function toProjectBoardProfile(raw: unknown): ProjectBoardProfile;
+export declare function normalizeProjectBoardBacklogItem(raw: unknown): ProjectBoardBacklogApiItemResponse | null;
+export declare function toProjectBoardWorkspaceSnapshot(params: {
+    profilePayload: unknown;
+    sprintPayload: unknown;
+    backlogPayload: unknown;
+}): ProjectBoardWorkspaceSnapshot;
+export declare function toProjectBoardWorkspaceFromCompatPayload(raw: unknown): ProjectBoardWorkspaceSnapshot;
+export declare function parseProjectBoardCallAck(raw: unknown, fallback: {
+    action: string;
+    requestedBy: string;
+    traceId: string;
+}): ProjectBoardCallResult;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/extensions/cavi/project-board/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cavi/project-board/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAE3B,yBAAyB,EACzB,sBAAsB,EAEtB,mBAAmB,EAEnB,6BAA6B,EAC9B,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EACV,kCAAkC,EAInC,MAAM,gBAAgB,CAAC;AAWxB,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,2BAA2B,CAWzF;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAWrF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAMnE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ7D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CAGtE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEvD;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,kCAAkC,EAAE,GAC1C,kCAAkC,EAAE,CAgBtC;AA2ED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,mBAAmB,CASvE;AAED,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,OAAO,GACX,kCAAkC,GAAG,IAAI,CA6B3C;AA4ID,wBAAgB,+BAA+B,CAAC,MAAM,EAAE;IACtD,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;CACzB,GAAG,6BAA6B,CAQhC;AAED,wBAAgB,wCAAwC,CACtD,GAAG,EAAE,OAAO,GACX,6BAA6B,CA0I/B;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACjE,sBAAsB,CAgCxB"}

package/dist/extensions/cavi/project-board/normalize.js

@@ -0,0 +1,410 @@
+import { asNumber, asString, asStringArray, isRecord, } from "../../../core/data/guards.js";
+import { CAVI_CONTROL_BASE_PATH } from "../contracts/paths.js";
+import { PROJECT_BOARD_CANONICAL_AVATAR_CANDIDATES, PROJECT_BOARD_FALLBACK_LIMITATIONS, } from "./constants.js";
+import { resolveProjectBoardAssetPath, withRuntimeBasePath, } from "../runtime/paths.js";
+export function normalizeProjectBoardPriority(value) {
+    const normalized = asString(value)?.toLowerCase();
+    if (normalized === "p0" ||
+        normalized === "p1" ||
+        normalized === "p2" ||
+        normalized === "p3") {
+        return normalized;
+    }
+    return "p2";
+}
+export function normalizeProjectBoardStatus(value) {
+    const normalized = asString(value)?.toLowerCase().replace(/-/g, "_");
+    if (normalized === "todo" ||
+        normalized === "in_progress" ||
+        normalized === "blocked" ||
+        normalized === "done") {
+        return normalized;
+    }
+    return "todo";
+}
+export function normalizeEmailAddress(value) {
+    const email = asString(value)?.toLowerCase();
+    if (!email) {
+        return null;
+    }
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) ? email : null;
+}
+export function normalizeEmailList(emails) {
+    return Array.from(new Set(emails
+        .map((email) => normalizeEmailAddress(email))
+        .filter((email) => Boolean(email))));
+}
+export function normalizeLimitations(value) {
+    const limitations = asStringArray(value);
+    return limitations.length > 0 ? limitations : PROJECT_BOARD_FALLBACK_LIMITATIONS;
+}
+export function normalizeSection(value) {
+    return asString(value)?.toLowerCase() ?? "inbox";
+}
+export function sortBacklogItems(items) {
+    const priorityOrder = {
+        p0: 0,
+        p1: 1,
+        p2: 2,
+        p3: 3,
+    };
+    return [...items].sort((left, right) => {
+        const byPriority = priorityOrder[left.priority] - priorityOrder[right.priority];
+        if (byPriority !== 0) {
+            return byPriority;
+        }
+        return right.updatedAt - left.updatedAt;
+    });
+}
+function toProjectBoardAssetPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+        return trimmed;
+    }
+    const normalized = trimmed.replace(/\\/g, "/");
+    const caviControlPrefix = `${CAVI_CONTROL_BASE_PATH}/`;
+    const withoutCanonicalPrefix = normalized.startsWith(caviControlPrefix)
+        ? normalized.slice(CAVI_CONTROL_BASE_PATH.length)
+        : normalized;
+    if (withoutCanonicalPrefix.startsWith("/deb/")) {
+        return withRuntimeBasePath(withoutCanonicalPrefix);
+    }
+    const filename = normalized.split("/").pop() ?? "";
+    if ((filename.startsWith("deb-") || filename.startsWith("project-board-")) &&
+        filename.endsWith(".png")) {
+        return resolveProjectBoardAssetPath(filename);
+    }
+    if (withoutCanonicalPrefix.startsWith("/")) {
+        return withRuntimeBasePath(withoutCanonicalPrefix);
+    }
+    return withRuntimeBasePath(`/${withoutCanonicalPrefix.replace(/^\/+/, "")}`);
+}
+function buildProjectBoardAvatarCandidates(params) {
+    const candidates = [
+        ...PROJECT_BOARD_CANONICAL_AVATAR_CANDIDATES,
+        params.photoPath ? toProjectBoardAssetPath(params.photoPath) : null,
+        params.photoUrl ? toProjectBoardAssetPath(params.photoUrl) : null,
+    ].filter((entry) => Boolean(entry));
+    return Array.from(new Set(candidates));
+}
+function normalizeProjectBoardProfileResponse(raw) {
+    const record = isRecord(raw) ? raw : {};
+    const photoPath = record.photoPath === null ? null : asString(record.photoPath);
+    const photoUrl = record.photoUrl === null ? null : asString(record.photoUrl);
+    const lastUpdated = asNumber(record.lastUpdated) ?? asNumber(record.updatedAt) ?? Date.now();
+    const limitations = record.limitations === undefined
+        ? []
+        : normalizeLimitations(record.limitations);
+    return {
+        name: asString(record.name) ?? "Project Board",
+        role: asString(record.role) ?? "Project Board Operator",
+        photoPath,
+        photoUrl,
+        emails: normalizeEmailList(asStringArray(record.emails)),
+        lastUpdated,
+        storage: "json-file",
+        limitations,
+    };
+}
+export function toProjectBoardProfile(raw) {
+    const normalized = normalizeProjectBoardProfileResponse(raw);
+    return {
+        ...normalized,
+        avatarCandidates: buildProjectBoardAvatarCandidates({
+            photoPath: normalized.photoPath,
+            photoUrl: normalized.photoUrl,
+        }),
+    };
+}
+export function normalizeProjectBoardBacklogItem(raw) {
+    const record = isRecord(raw) ? raw : null;
+    if (!record) {
+        return null;
+    }
+    const id = asString(record.id);
+    const title = asString(record.title);
+    if (!id || !title) {
+        return null;
+    }
+    const createdAt = asNumber(record.createdAt) ?? Date.now();
+    const updatedAt = asNumber(record.updatedAt) ?? createdAt;
+    return {
+        id,
+        title,
+        description: record.description === null ? null : asString(record.description),
+        section: normalizeSection(record.section),
+        priority: normalizeProjectBoardPriority(record.priority),
+        status: normalizeProjectBoardStatus(record.status),
+        tags: Array.from(new Set(asStringArray(record.tags).map((tag) => tag.toLowerCase()))),
+        createdAt,
+        updatedAt,
+    };
+}
+function normalizeProjectBoardBacklogResponse(raw) {
+    const record = isRecord(raw) ? raw : {};
+    const sectionsRaw = Array.isArray(record.sections) ? record.sections : [];
+    const sections = sectionsRaw
+        .map((entry) => {
+        if (!isRecord(entry)) {
+            return null;
+        }
+        const section = normalizeSection(entry.section);
+        const itemsRaw = Array.isArray(entry.items) ? entry.items : [];
+        const items = itemsRaw
+            .map((item) => normalizeProjectBoardBacklogItem(item))
+            .filter((item) => item !== null);
+        return {
+            section,
+            items: sortBacklogItems(items),
+        };
+    })
+        .filter((entry) => entry !== null);
+    const allItems = sections.flatMap((section) => section.items);
+    const priorities = {
+        p0: 0,
+        p1: 0,
+        p2: 0,
+        p3: 0,
+    };
+    const statusCounters = {
+        todo: 0,
+        in_progress: 0,
+        blocked: 0,
+        done: 0,
+    };
+    for (const item of allItems) {
+        priorities[item.priority] += 1;
+        statusCounters[item.status] += 1;
+    }
+    const lastUpdated = asNumber(record.lastUpdated) ??
+        asNumber(record.updatedAt) ??
+        (() => {
+            const latest = allItems.reduce((max, item) => Math.max(max, item.updatedAt), 0);
+            return latest > 0 ? latest : Date.now();
+        })();
+    const limitations = record.limitations === undefined
+        ? []
+        : normalizeLimitations(record.limitations);
+    return {
+        sections,
+        priorities,
+        statusCounters,
+        totalItems: allItems.length,
+        lastUpdated,
+        storage: "json-file",
+        limitations,
+    };
+}
+function toProjectBoardBacklog(raw) {
+    return normalizeProjectBoardBacklogResponse(raw);
+}
+function normalizeProjectBoardSprintResponse(raw) {
+    const record = isRecord(raw) ? raw : {};
+    const sprintRecord = isRecord(record.sprint) ? record.sprint : {};
+    const metricsRecord = isRecord(record.statusMetrics)
+        ? record.statusMetrics
+        : {};
+    const total = asNumber(metricsRecord.total) ?? 0;
+    const todo = asNumber(metricsRecord.todo) ?? 0;
+    const inProgress = asNumber(metricsRecord.inProgress) ?? 0;
+    const blocked = asNumber(metricsRecord.blocked) ?? 0;
+    const done = asNumber(metricsRecord.done) ?? 0;
+    const lastUpdated = asNumber(record.lastUpdated) ?? asNumber(record.updatedAt) ?? Date.now();
+    const limitations = record.limitations === undefined
+        ? []
+        : normalizeLimitations(record.limitations);
+    return {
+        sprint: {
+            id: asString(sprintRecord.id) ?? "current",
+            name: asString(sprintRecord.name) ?? "Current Sprint",
+            goal: asString(sprintRecord.goal) ??
+                "Drive board clarity and delivery throughput.",
+            startsOn: sprintRecord.startsOn === null ? null : asString(sprintRecord.startsOn),
+            endsOn: sprintRecord.endsOn === null ? null : asString(sprintRecord.endsOn),
+        },
+        statusMetrics: {
+            total,
+            todo,
+            inProgress,
+            blocked,
+            done,
+            completionRate: asNumber(metricsRecord.completionRate) ??
+                (total > 0 ? done / total : 0),
+        },
+        lastUpdated,
+        storage: "json-file",
+        limitations,
+    };
+}
+function toProjectBoardSprint(raw) {
+    return normalizeProjectBoardSprintResponse(raw);
+}
+function normalizeProjectBoardEmailRecipients(emails) {
+    return normalizeEmailList(emails).map((email) => ({
+        id: email,
+        email,
+    }));
+}
+export function toProjectBoardWorkspaceSnapshot(params) {
+    const profile = toProjectBoardProfile(params.profilePayload);
+    return {
+        profile,
+        emails: normalizeProjectBoardEmailRecipients(profile.emails),
+        sprint: toProjectBoardSprint(params.sprintPayload),
+        backlog: toProjectBoardBacklog(params.backlogPayload),
+    };
+}
+export function toProjectBoardWorkspaceFromCompatPayload(raw) {
+    const record = isRecord(raw) ? raw : {};
+    if (isRecord(record.profile) &&
+        isRecord(record.sprint) &&
+        isRecord(record.backlog)) {
+        return toProjectBoardWorkspaceSnapshot({
+            profilePayload: record.profile,
+            sprintPayload: record.sprint,
+            backlogPayload: record.backlog,
+        });
+    }
+    const legacyProfile = isRecord(record.profile) ? record.profile : {};
+    const legacyEmails = Array.isArray(record.emails)
+        ? record.emails
+            .map((entry) => isRecord(entry) ? normalizeEmailAddress(entry.email) : null)
+            .filter((email) => Boolean(email))
+        : [];
+    const profilePayload = {
+        name: asString(legacyProfile.name) ?? "Project Board",
+        role: asString(legacyProfile.role) ?? "Project Board Operator",
+        photoPath: asString(legacyProfile.photoPath) ?? null,
+        photoUrl: asString(legacyProfile.photoUrl) ?? null,
+        emails: legacyEmails,
+        lastUpdated: Date.now(),
+        storage: "json-file",
+        limitations: PROJECT_BOARD_FALLBACK_LIMITATIONS,
+    };
+    const legacyBacklog = Array.isArray(record.backlog)
+        ? record.backlog
+            .map((entry) => {
+            if (!isRecord(entry)) {
+                return null;
+            }
+            const item = normalizeProjectBoardBacklogItem({
+                id: entry.id,
+                title: entry.title,
+                description: entry.notes,
+                section: entry.section,
+                priority: entry.priority,
+                status: entry.status,
+                tags: [],
+                createdAt: entry.updatedAt,
+                updatedAt: entry.updatedAt,
+            });
+            return item;
+        })
+            .filter((item) => item !== null)
+        : [];
+    const backlogPayload = {
+        sections: [
+            {
+                section: "inbox",
+                items: sortBacklogItems(legacyBacklog),
+            },
+        ],
+        priorities: {
+            p0: legacyBacklog.filter((item) => item.priority === "p0").length,
+            p1: legacyBacklog.filter((item) => item.priority === "p1").length,
+            p2: legacyBacklog.filter((item) => item.priority === "p2").length,
+            p3: legacyBacklog.filter((item) => item.priority === "p3").length,
+        },
+        statusCounters: {
+            todo: legacyBacklog.filter((item) => item.status === "todo").length,
+            in_progress: legacyBacklog.filter((item) => item.status === "in_progress")
+                .length,
+            blocked: legacyBacklog.filter((item) => item.status === "blocked").length,
+            done: legacyBacklog.filter((item) => item.status === "done").length,
+        },
+        totalItems: legacyBacklog.length,
+        lastUpdated: Date.now(),
+        storage: "json-file",
+        limitations: PROJECT_BOARD_FALLBACK_LIMITATIONS,
+    };
+    const sprintPayload = isRecord(record.sprint)
+        ? {
+            sprint: {
+                id: "current",
+                name: asString(record.sprint.sprintLabel) ?? "Current Sprint",
+                goal: asString(record.sprint.focus) ??
+                    "Keep backlog routing and ownership current.",
+                startsOn: null,
+                endsOn: null,
+            },
+            statusMetrics: {
+                total: legacyBacklog.length,
+                todo: backlogPayload.statusCounters.todo,
+                inProgress: backlogPayload.statusCounters.in_progress,
+                blocked: backlogPayload.statusCounters.blocked,
+                done: backlogPayload.statusCounters.done,
+                completionRate: legacyBacklog.length > 0
+                    ? backlogPayload.statusCounters.done / legacyBacklog.length
+                    : 0,
+            },
+            lastUpdated: asNumber(record.sprint.updatedAt) ?? Date.now(),
+            storage: "json-file",
+            limitations: PROJECT_BOARD_FALLBACK_LIMITATIONS,
+        }
+        : {
+            sprint: {
+                id: "current",
+                name: "Current Sprint",
+                goal: "Keep backlog routing and ownership current.",
+                startsOn: null,
+                endsOn: null,
+            },
+            statusMetrics: {
+                total: legacyBacklog.length,
+                todo: backlogPayload.statusCounters.todo,
+                inProgress: backlogPayload.statusCounters.in_progress,
+                blocked: backlogPayload.statusCounters.blocked,
+                done: backlogPayload.statusCounters.done,
+                completionRate: legacyBacklog.length > 0
+                    ? backlogPayload.statusCounters.done / legacyBacklog.length
+                    : 0,
+            },
+            lastUpdated: Date.now(),
+            storage: "json-file",
+            limitations: PROJECT_BOARD_FALLBACK_LIMITATIONS,
+        };
+    return toProjectBoardWorkspaceSnapshot({
+        profilePayload,
+        sprintPayload,
+        backlogPayload,
+    });
+}
+export function parseProjectBoardCallAck(raw, fallback) {
+    const record = isRecord(raw) ? raw : {};
+    const ackId = asString(record.ackId) ??
+        asString(record.runId) ??
+        `project-board-call-${fallback.traceId}`;
+    const queuedAt = asNumber(record.queuedAt) ?? asNumber(record.calledAt) ?? Date.now();
+    const queueDepth = asNumber(record.queueDepth) ?? 1;
+    const note = asString(record.note) ??
+        asString(record.message) ??
+        "Project Board call acknowledged by Cavi Control compatibility mapper.";
+    const limitations = record.limitations === undefined
+        ? []
+        : normalizeLimitations(record.limitations);
+    return {
+        ackId,
+        status: "queued",
+        action: asString(record.action) ?? fallback.action,
+        requestedBy: asString(record.requestedBy) ?? fallback.requestedBy,
+        queuedAt,
+        queueDepth,
+        note,
+        storage: "json-file",
+        limitations,
+        traceId: fallback.traceId,
+    };
+}

package/dist/extensions/cavi/project-board/trace-id.d.ts

@@ -0,0 +1,2 @@
+export declare function createTraceId(): string;
+//# sourceMappingURL=trace-id.d.ts.map

package/dist/extensions/cavi/project-board/trace-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-id.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cavi/project-board/trace-id.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,IAAI,MAAM,CAQtC"}

package/dist/extensions/cavi/project-board/trace-id.js

@@ -0,0 +1,7 @@
+export function createTraceId() {
+    if (typeof globalThis.crypto !== "undefined" &&
+        typeof globalThis.crypto.randomUUID === "function") {
+        return globalThis.crypto.randomUUID();
+    }
+    return `trace-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}