@cats-inc/cats-platform 0.1.0

package/build/server/products/code/api/projection.js

@@ -0,0 +1,796 @@
+import { createHash } from 'node:crypto';
+import { buildCoreTaskControlPlaneView, } from '../../../core/taskControlPlane.js';
+import { buildCoreTaskInspectionView, } from '../../../core/taskInspection.js';
+import { buildCoreTaskRecoveryView, } from '../../../core/recovery.js';
+import { queryCoreTaskTimelineView, } from '../../../core/taskTimeline.js';
+import { buildSupervisedRunInspectionProjection, } from '../../../platform/supervision/index.js';
+import { resolveTaskExecutionProduct } from '../../../shared/taskExecutionBridge.js';
+import { readTaskPlanningMetadataFromTask, resolveEffectiveTaskStrategy, } from '../../../shared/taskPlanning.js';
+import { readCodePlanFromTask, } from '../state/planSteps.js';
+import { readCodeWorkspaceSummaryFromTask, } from '../shared/workspaceSummary.js';
+import { CODE_API_ARTIFACT_DETAIL_PATH_TEMPLATE, CODE_API_ARTIFACTS_PATH, CODE_API_BUILDS_PATH, CODE_API_CODESPACE_DETAIL_PATH_TEMPLATE, CODE_API_CODESPACES_PATH, CODE_API_PREVIEWS_PATH, CODE_API_TASK_DETAIL_PATH_TEMPLATE, CODE_API_TASKS_PATH, } from '../shared/apiPaths.js';
+import { createActiveCodeProductRef, createCodeProductRef, } from '../shared/productMetadata.js';
+const CODE_DASHBOARD_TASK_LIMIT = 16;
+const CODE_DASHBOARD_WORK_ITEM_LIMIT = 16;
+const CODE_DASHBOARD_ARTIFACT_LIMIT = 18;
+const CODE_TIMELINE_PREVIEW_LIMIT = 12;
+const CODE_DETAIL_ARTIFACT_LIMIT = 12;
+const CODE_WORKSPACE_LIST_LIMIT = 48;
+function resolveConversationTitle(value) {
+    return value?.title ?? null;
+}
+function resolveConversation(core, conversationId) {
+    if (!conversationId) {
+        return null;
+    }
+    return core.conversations.find((conversation) => conversation.id === conversationId) ?? null;
+}
+function resolveCodeActorName(core, actorId) {
+    if (!actorId) {
+        return 'Unknown owner';
+    }
+    if (actorId === core.ownerProfile.actorId) {
+        return core.ownerProfile.displayName;
+    }
+    return core.actors.find((actor) => actor.id === actorId)?.name ?? actorId;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function normalizeWorkspacePathForComparison(value) {
+    return value.trim().replace(/\\/g, '/');
+}
+function createCodeWorkspaceId(workspacePath) {
+    const digest = createHash('sha256')
+        .update(normalizeWorkspacePathForComparison(workspacePath))
+        .digest('hex')
+        .slice(0, 16);
+    return `codespace-${digest}`;
+}
+function workspacePathMatches(left, right) {
+    return normalizeWorkspacePathForComparison(left) === normalizeWorkspacePathForComparison(right);
+}
+function deriveWorkspaceTitle(workspacePath) {
+    const normalized = normalizeWorkspacePathForComparison(workspacePath);
+    const parts = normalized.split('/').filter(Boolean);
+    return parts.at(-1) ?? normalized;
+}
+function readArtifactDeclarationWorkspacePath(artifact) {
+    const declaration = asRecord(artifact.metadata.codeArtifactDeclaration);
+    const anchors = asRecord(declaration?.anchors);
+    return readNonEmptyString(anchors?.workspacePath);
+}
+function readArtifactDeclarationProducerLabel(artifact) {
+    const declaration = asRecord(artifact.metadata.codeArtifactDeclaration);
+    return readNonEmptyString(declaration?.producerLabel);
+}
+function readArtifactDeclarationDisposition(artifact) {
+    const declaration = asRecord(artifact.metadata.codeArtifactDeclaration);
+    const disposition = declaration?.disposition;
+    return disposition === 'candidate' || disposition === 'record' ? disposition : null;
+}
+function resolveTaskWorkItemRecord(core, taskId) {
+    return [...core.workItems]
+        .filter((candidate) => candidate.taskId === taskId)
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0] ?? null;
+}
+function resolveProjectTitle(core, projectId) {
+    if (!projectId) {
+        return null;
+    }
+    return core.projects.find((project) => project.id === projectId)?.title ?? null;
+}
+function buildWorkItemReference(core, workItem) {
+    if (!workItem) {
+        return null;
+    }
+    return {
+        id: workItem.id,
+        title: workItem.title,
+        status: workItem.status,
+        projectId: workItem.projectId,
+        projectTitle: resolveProjectTitle(core, workItem.projectId),
+        updatedAt: workItem.updatedAt,
+    };
+}
+function isCodeTask(core, task) {
+    if (core.artifacts.some((artifact) => artifact.taskId === task.id && (artifact.kind === 'build' || artifact.kind === 'preview'))) {
+        return true;
+    }
+    return resolveTaskExecutionProduct({ core, task }) === 'code';
+}
+function listCodeTasks(core) {
+    return [...core.tasks]
+        .filter((task) => isCodeTask(core, task))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function buildCodeTaskListItem(core, task) {
+    const planning = readTaskPlanningMetadataFromTask(task);
+    const conversation = resolveConversation(core, task.conversationId);
+    const workItem = resolveTaskWorkItemRecord(core, task.id);
+    return {
+        id: task.id,
+        title: task.title,
+        status: task.status,
+        summary: task.summary,
+        conversationId: task.conversationId,
+        conversationTitle: resolveConversationTitle(conversation),
+        workItemId: workItem?.id ?? null,
+        workItemTitle: workItem?.title ?? null,
+        effectiveStrategy: resolveEffectiveTaskStrategy('code', planning),
+        updatedAt: task.updatedAt,
+    };
+}
+function buildCodeTaskListSummary(allTasks, returnedTasks) {
+    return allTasks.reduce((summary, task) => {
+        if (task.status === 'draft') {
+            summary.draftCount += 1;
+        }
+        if (task.status === 'in_progress') {
+            summary.inProgressCount += 1;
+        }
+        if (task.status === 'blocked') {
+            summary.blockedCount += 1;
+        }
+        if (task.status === 'completed') {
+            summary.completedCount += 1;
+        }
+        return summary;
+    }, {
+        totalAvailable: allTasks.length,
+        returned: returnedTasks.length,
+        draftCount: 0,
+        inProgressCount: 0,
+        blockedCount: 0,
+        completedCount: 0,
+    });
+}
+function readWorkItemProductIntentTargetProduct(workItem) {
+    const productIntentIntake = asRecord(workItem.metadata.productIntentIntake);
+    if (productIntentIntake?.targetProduct === 'work'
+        || productIntentIntake?.targetProduct === 'code') {
+        return productIntentIntake.targetProduct;
+    }
+    const intake = asRecord(workItem.metadata.directSlashModeIntake);
+    return intake?.targetProduct === 'work' || intake?.targetProduct === 'code'
+        ? intake.targetProduct
+        : null;
+}
+function readWorkItemPlanningProductHint(workItem) {
+    const planning = asRecord(workItem.metadata.planning);
+    return planning?.productHint === 'chat'
+        || planning?.productHint === 'work'
+        || planning?.productHint === 'code'
+        ? planning.productHint
+        : null;
+}
+function isCodeWorkItem(core, workItem) {
+    if (readWorkItemProductIntentTargetProduct(workItem) === 'code') {
+        return true;
+    }
+    if (readWorkItemPlanningProductHint(workItem) === 'code') {
+        return true;
+    }
+    const linkedTask = workItem.taskId
+        ? core.tasks.find((task) => task.id === workItem.taskId) ?? null
+        : null;
+    if (linkedTask && isCodeTask(core, linkedTask)) {
+        return true;
+    }
+    return core.artifacts.some((artifact) => artifact.workItemId === workItem.id
+        && (artifact.kind === 'build' || artifact.kind === 'preview'));
+}
+function listCodeWorkItems(core) {
+    return [...core.workItems]
+        .filter((workItem) => isCodeWorkItem(core, workItem))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function buildCodeWorkItemListItem(core, workItem) {
+    const conversation = resolveConversation(core, workItem.conversationId);
+    const linkedTask = workItem.taskId
+        ? core.tasks.find((task) => task.id === workItem.taskId) ?? null
+        : null;
+    return {
+        id: workItem.id,
+        title: workItem.title,
+        status: workItem.status,
+        summary: workItem.summary,
+        targetProduct: 'code',
+        conversationId: workItem.conversationId,
+        conversationTitle: resolveConversationTitle(conversation),
+        conversationSourceChannelId: conversation?.sourceChannelId ?? null,
+        taskId: workItem.taskId,
+        taskTitle: linkedTask?.title ?? null,
+        ownerActorId: workItem.ownerActorId,
+        ownerName: resolveCodeActorName(core, workItem.ownerActorId),
+        assignedActors: workItem.assignedActorIds.map((actorId) => ({
+            actorId,
+            displayName: resolveCodeActorName(core, actorId),
+        })),
+        updatedAt: workItem.updatedAt,
+    };
+}
+function buildCodeWorkItemListSummary(allWorkItems, returnedWorkItems) {
+    return allWorkItems.reduce((summary, workItem) => {
+        if (workItem.status === 'draft') {
+            summary.draftCount += 1;
+        }
+        if (workItem.status === 'ready') {
+            summary.readyCount += 1;
+        }
+        if (workItem.status === 'in_progress') {
+            summary.inProgressCount += 1;
+        }
+        if (workItem.status === 'blocked') {
+            summary.blockedCount += 1;
+        }
+        if (workItem.status === 'completed') {
+            summary.completedCount += 1;
+        }
+        if (workItem.taskId) {
+            summary.linkedTaskCount += 1;
+        }
+        return summary;
+    }, {
+        totalAvailable: allWorkItems.length,
+        returned: returnedWorkItems.length,
+        draftCount: 0,
+        readyCount: 0,
+        inProgressCount: 0,
+        blockedCount: 0,
+        completedCount: 0,
+        linkedTaskCount: 0,
+    });
+}
+function listCodeArtifacts(core, codeTasks, filter = 'all', options = {}) {
+    const allCodeTaskIds = new Set(codeTasks.map((task) => task.id));
+    const allCodeWorkItemIds = new Set(core.workItems
+        .filter((workItem) => workItem.taskId && allCodeTaskIds.has(workItem.taskId))
+        .map((workItem) => workItem.id));
+    return [...core.artifacts]
+        .filter((artifact) => ((artifact.taskId ? allCodeTaskIds.has(artifact.taskId) : false)
+        || (artifact.workItemId ? allCodeWorkItemIds.has(artifact.workItemId) : false)
+        || (options.includeWorkspaceAnchored === true
+            ? readArtifactDeclarationWorkspacePath(artifact) !== null
+            : false))
+        && (filter === 'all' || artifact.kind === filter))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function buildCodeArtifactListItem(core, artifact, taskItemById) {
+    const linkedTask = artifact.taskId ? taskItemById.get(artifact.taskId) ?? null : null;
+    const linkedWorkItem = artifact.workItemId
+        ? core.workItems.find((workItem) => workItem.id === artifact.workItemId) ?? null
+        : null;
+    return {
+        id: artifact.id,
+        title: artifact.title,
+        kind: artifact.kind,
+        status: artifact.status,
+        summary: artifact.summary,
+        path: artifact.path,
+        taskId: artifact.taskId,
+        taskTitle: linkedTask?.title ?? null,
+        workItemId: artifact.workItemId,
+        workItemTitle: linkedWorkItem?.title ?? null,
+        runId: artifact.runId,
+        conversationId: artifact.conversationId,
+        workspacePath: resolveArtifactWorkspacePath(core, artifact),
+        producerLabel: readArtifactDeclarationProducerLabel(artifact),
+        disposition: readArtifactDeclarationDisposition(artifact),
+        updatedAt: artifact.updatedAt,
+    };
+}
+function buildCodeArtifactListSummary(allArtifacts, returnedArtifacts) {
+    return allArtifacts.reduce((summary, artifact) => {
+        if (artifact.kind === 'build') {
+            summary.buildCount += 1;
+        }
+        if (artifact.kind === 'preview') {
+            summary.previewCount += 1;
+        }
+        if (artifact.status === 'ready') {
+            summary.readyCount += 1;
+        }
+        if (artifact.status === 'published') {
+            summary.publishedCount += 1;
+        }
+        return summary;
+    }, {
+        totalAvailable: allArtifacts.length,
+        returned: returnedArtifacts.length,
+        buildCount: 0,
+        previewCount: 0,
+        readyCount: 0,
+        publishedCount: 0,
+    });
+}
+function selectDefaultCodeArtifactId(artifacts) {
+    const latestReadyArtifact = artifacts
+        .filter((artifact) => artifact.status === 'ready')
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0] ?? null;
+    return latestReadyArtifact?.id ?? artifacts[0]?.id ?? null;
+}
+const WORKSPACE_SOURCE_PRIORITY = {
+    task_workspace: 40,
+    conversation_repo: 30,
+    runtime_cwd: 20,
+    artifact_anchor: 10,
+};
+function upsertWorkspaceAccumulator(accumulators, workspacePath, source, updatedAt) {
+    const normalizedPath = normalizeWorkspacePathForComparison(workspacePath);
+    const existing = accumulators.get(normalizedPath);
+    if (existing) {
+        if (WORKSPACE_SOURCE_PRIORITY[source] > WORKSPACE_SOURCE_PRIORITY[existing.source]) {
+            existing.source = source;
+        }
+        if (updatedAt.localeCompare(existing.lastActiveAt) > 0) {
+            existing.lastActiveAt = updatedAt;
+        }
+        return existing;
+    }
+    const accumulator = {
+        path: workspacePath.trim(),
+        source,
+        conversationIds: new Set(),
+        taskIds: new Set(),
+        artifactIds: new Set(),
+        taskStatuses: new Set(),
+        conversationStatuses: new Set(),
+        lastActiveAt: updatedAt,
+    };
+    accumulators.set(normalizedPath, accumulator);
+    return accumulator;
+}
+function resolveArtifactWorkspacePath(core, artifact) {
+    const declaredWorkspace = readArtifactDeclarationWorkspacePath(artifact);
+    if (declaredWorkspace) {
+        return declaredWorkspace;
+    }
+    const task = artifact.taskId
+        ? core.tasks.find((candidate) => candidate.id === artifact.taskId) ?? null
+        : null;
+    const taskWorkspace = task ? readCodeWorkspaceSummaryFromTask(task)?.workspacePath ?? null : null;
+    if (taskWorkspace) {
+        return taskWorkspace;
+    }
+    const conversation = resolveConversation(core, artifact.conversationId);
+    return conversation?.repoPath ?? null;
+}
+function resolveWorkspaceStatus(accumulator) {
+    if ([...accumulator.taskStatuses].some((status) => status === 'in_progress' || status === 'approved' || status === 'pending_approval')) {
+        return 'active';
+    }
+    if (accumulator.taskStatuses.has('draft')) {
+        return 'draft';
+    }
+    const hasTrackedRecords = accumulator.conversationIds.size > 0
+        || accumulator.taskIds.size > 0
+        || accumulator.artifactIds.size > 0;
+    const allTasksTerminal = accumulator.taskStatuses.size === 0
+        || [...accumulator.taskStatuses].every((status) => status === 'completed' || status === 'cancelled' || status === 'archived');
+    const allConversationsArchived = accumulator.conversationStatuses.size === 0
+        || [...accumulator.conversationStatuses].every((status) => status === 'archived');
+    return hasTrackedRecords && allTasksTerminal && allConversationsArchived
+        ? 'archived'
+        : 'ready';
+}
+function buildCodeWorkspaceListItem(accumulator) {
+    return {
+        id: createCodeWorkspaceId(accumulator.path),
+        title: deriveWorkspaceTitle(accumulator.path),
+        summary: null,
+        path: accumulator.path,
+        status: resolveWorkspaceStatus(accumulator),
+        source: accumulator.source,
+        conversationCount: accumulator.conversationIds.size,
+        taskCount: accumulator.taskIds.size,
+        artifactCount: accumulator.artifactIds.size,
+        lastActiveAt: accumulator.lastActiveAt,
+    };
+}
+function buildCodeWorkspaceListSummary(allWorkspaces, returnedWorkspaces) {
+    return allWorkspaces.reduce((summary, workspace) => {
+        if (workspace.status === 'active') {
+            summary.activeCount += 1;
+        }
+        if (workspace.taskCount > 0) {
+            summary.taskBackedCount += 1;
+        }
+        if (workspace.artifactCount > 0) {
+            summary.artifactBackedCount += 1;
+        }
+        return summary;
+    }, {
+        totalAvailable: allWorkspaces.length,
+        returned: returnedWorkspaces.length,
+        activeCount: 0,
+        taskBackedCount: 0,
+        artifactBackedCount: 0,
+    });
+}
+function buildCodeWorkspaceConversationItem(conversation) {
+    return {
+        id: conversation.id,
+        title: conversation.title,
+        kind: conversation.kind,
+        status: conversation.status,
+        repoPath: conversation.repoPath,
+        updatedAt: conversation.updatedAt,
+        lastMessageAt: conversation.lastMessageAt,
+    };
+}
+function buildCodeWorkspaceItems(core) {
+    const codeTasks = listCodeTasks(core);
+    const codeConversationIds = new Set(codeTasks.map((task) => task.conversationId).filter((id) => !!id));
+    const accumulators = new Map();
+    for (const task of codeTasks) {
+        const workspace = readCodeWorkspaceSummaryFromTask(task);
+        if (!workspace) {
+            continue;
+        }
+        const accumulator = upsertWorkspaceAccumulator(accumulators, workspace.workspacePath, 'task_workspace', task.updatedAt);
+        accumulator.taskIds.add(task.id);
+        accumulator.taskStatuses.add(task.status);
+        if (task.conversationId) {
+            accumulator.conversationIds.add(task.conversationId);
+        }
+    }
+    for (const conversation of core.conversations) {
+        if (!conversation.repoPath) {
+            continue;
+        }
+        if (conversation.kind !== 'code_thread' && !codeConversationIds.has(conversation.id)) {
+            continue;
+        }
+        const accumulator = upsertWorkspaceAccumulator(accumulators, conversation.repoPath, 'conversation_repo', conversation.lastMessageAt ?? conversation.updatedAt);
+        accumulator.conversationIds.add(conversation.id);
+        accumulator.conversationStatuses.add(conversation.status);
+    }
+    for (const session of core.sessions) {
+        const leaseCwd = readNonEmptyString(session.metadata.leaseCwd);
+        if (!leaseCwd || !session.conversationId || !codeConversationIds.has(session.conversationId)) {
+            continue;
+        }
+        const accumulator = upsertWorkspaceAccumulator(accumulators, leaseCwd, 'runtime_cwd', session.updatedAt);
+        accumulator.conversationIds.add(session.conversationId);
+    }
+    for (const artifact of listCodeArtifacts(core, codeTasks, 'all', {
+        includeWorkspaceAnchored: true,
+    })) {
+        const workspacePath = resolveArtifactWorkspacePath(core, artifact);
+        if (!workspacePath) {
+            continue;
+        }
+        const accumulator = upsertWorkspaceAccumulator(accumulators, workspacePath, 'artifact_anchor', artifact.updatedAt);
+        accumulator.artifactIds.add(artifact.id);
+    }
+    return [...accumulators.values()]
+        .map((accumulator) => buildCodeWorkspaceListItem(accumulator))
+        .sort((left, right) => right.lastActiveAt.localeCompare(left.lastActiveAt));
+}
+export function buildCodeTaskListProjection(core) {
+    const allTasks = listCodeTasks(core);
+    const tasks = allTasks
+        .slice(0, CODE_DASHBOARD_TASK_LIMIT)
+        .map((task) => buildCodeTaskListItem(core, task));
+    return {
+        tasks,
+        summary: buildCodeTaskListSummary(allTasks, tasks),
+    };
+}
+export function buildCodeWorkItemListProjection(core) {
+    const allWorkItems = listCodeWorkItems(core);
+    const workItems = allWorkItems
+        .slice(0, CODE_DASHBOARD_WORK_ITEM_LIMIT)
+        .map((workItem) => buildCodeWorkItemListItem(core, workItem));
+    return {
+        workItems,
+        summary: buildCodeWorkItemListSummary(allWorkItems, workItems),
+    };
+}
+export function buildCodeWorkspaceListProjection(core) {
+    const allWorkspaces = buildCodeWorkspaceItems(core);
+    const workspaces = allWorkspaces.slice(0, CODE_WORKSPACE_LIST_LIMIT);
+    return {
+        workspaces,
+        summary: buildCodeWorkspaceListSummary(allWorkspaces, workspaces),
+    };
+}
+export function buildCodeWorkspaceDetailProjection(core, workspaceId) {
+    const workspace = buildCodeWorkspaceItems(core)
+        .find((candidate) => candidate.id === workspaceId) ?? null;
+    if (!workspace) {
+        return null;
+    }
+    const codeTasks = listCodeTasks(core);
+    const codeConversationIds = new Set(codeTasks.map((task) => task.conversationId).filter((id) => !!id));
+    const tasks = codeTasks
+        .filter((task) => {
+        const summary = readCodeWorkspaceSummaryFromTask(task);
+        return summary ? workspacePathMatches(summary.workspacePath, workspace.path) : false;
+    })
+        .map((task) => buildCodeTaskListItem(core, task));
+    const taskItemById = new Map(tasks.map((task) => [task.id, task]));
+    const conversations = core.conversations
+        .filter((conversation) => conversation.repoPath
+        && (conversation.kind === 'code_thread' || codeConversationIds.has(conversation.id))
+        ? workspacePathMatches(conversation.repoPath, workspace.path)
+        : false)
+        .sort((left, right) => (right.lastMessageAt ?? right.updatedAt).localeCompare(left.lastMessageAt ?? left.updatedAt))
+        .map((conversation) => buildCodeWorkspaceConversationItem(conversation));
+    const artifacts = listCodeArtifacts(core, codeTasks, 'all', {
+        includeWorkspaceAnchored: true,
+    })
+        .filter((artifact) => {
+        const workspacePath = resolveArtifactWorkspacePath(core, artifact);
+        return workspacePath ? workspacePathMatches(workspacePath, workspace.path) : false;
+    })
+        .map((artifact) => buildCodeArtifactListItem(core, artifact, taskItemById));
+    return {
+        workspace,
+        conversations,
+        tasks,
+        artifacts,
+    };
+}
+function normalizeArtifactFilters(filtersOrLegacy) {
+    if (typeof filtersOrLegacy === 'string') {
+        return { kind: filtersOrLegacy };
+    }
+    return filtersOrLegacy;
+}
+function resolveLegacyKindFilter(kind) {
+    return kind === 'build' || kind === 'preview' ? kind : 'all';
+}
+function isLocalFilePath(path) {
+    const trimmed = path.trim();
+    if (!trimmed) {
+        return false;
+    }
+    // Windows drive paths (`C:/foo`, `D:\bar`) and UNC paths (`\\server\share`)
+    // must be recognised as local before the URI-scheme check below — `C:` would
+    // otherwise match the scheme regex and the artifact would slip through the
+    // `excludeUndeclaredSourceEdits` filter.
+    if (/^[A-Za-z]:[\\/]/.test(trimmed)) {
+        return true;
+    }
+    if (trimmed.startsWith('\\\\')) {
+        return true;
+    }
+    // Multi-character scheme followed by `:` (e.g. `http:`, `file:`, `data:`).
+    // Single-letter prefixes are excluded above, so this only flags real URI
+    // schemes as non-local.
+    if (/^[A-Za-z][A-Za-z0-9+.-]+:/.test(trimmed)) {
+        return false;
+    }
+    return true;
+}
+function hasArtifactDeclaration(artifact) {
+    return asRecord(artifact.metadata.codeArtifactDeclaration) !== null;
+}
+function isUndeclaredSourceEdit(artifact) {
+    // PLAN-081 Task 4.4 frames "declared" as "has a `codeArtifactDeclaration`",
+    // not the narrower "has a `producerLabel`". A declaration object can exist
+    // without a producerLabel (legacy declarations, system-candidate variants),
+    // and those should still be considered declared so they remain in the
+    // sidebar.
+    if (hasArtifactDeclaration(artifact)) {
+        return false;
+    }
+    return artifact.path !== null && isLocalFilePath(artifact.path);
+}
+function applyExtendedArtifactFilters(core, artifacts, filters) {
+    return artifacts.filter((artifact) => {
+        if (filters.kind
+            && filters.kind !== 'all'
+            && filters.kind !== 'build'
+            && filters.kind !== 'preview'
+            && artifact.kind !== filters.kind) {
+            return false;
+        }
+        if (filters.status && artifact.status !== filters.status) {
+            return false;
+        }
+        if (filters.producerLabel
+            && readArtifactDeclarationProducerLabel(artifact) !== filters.producerLabel) {
+            return false;
+        }
+        if (filters.taskId && artifact.taskId !== filters.taskId) {
+            return false;
+        }
+        if (filters.runId && artifact.runId !== filters.runId) {
+            return false;
+        }
+        if (filters.workspacePath) {
+            const path = resolveArtifactWorkspacePath(core, artifact);
+            if (!path || !workspacePathMatches(path, filters.workspacePath)) {
+                return false;
+            }
+        }
+        if (filters.excludeUndeclaredSourceEdits && isUndeclaredSourceEdit(artifact)) {
+            return false;
+        }
+        return true;
+    });
+}
+export function buildCodeArtifactListProjection(core, filtersOrLegacy = {}) {
+    const filters = normalizeArtifactFilters(filtersOrLegacy);
+    const legacyKindFilter = resolveLegacyKindFilter(filters.kind);
+    const allTasks = listCodeTasks(core);
+    const taskItems = allTasks.map((task) => buildCodeTaskListItem(core, task));
+    const taskItemById = new Map(taskItems.map((task) => [task.id, task]));
+    const baseArtifacts = listCodeArtifacts(core, allTasks, legacyKindFilter, {
+        includeWorkspaceAnchored: true,
+    });
+    const allArtifacts = applyExtendedArtifactFilters(core, baseArtifacts, filters);
+    const artifacts = allArtifacts
+        .slice(0, CODE_DASHBOARD_ARTIFACT_LIMIT)
+        .map((artifact) => buildCodeArtifactListItem(core, artifact, taskItemById));
+    return {
+        filter: legacyKindFilter,
+        filters,
+        artifacts,
+        summary: buildCodeArtifactListSummary(allArtifacts, artifacts),
+    };
+}
+export function buildCodeTaskDetailProjection(core, task, evidenceEvents = []) {
+    const conversation = resolveConversation(core, task.conversationId);
+    const workItem = resolveTaskWorkItemRecord(core, task.id);
+    const codeArtifacts = listCodeArtifacts(core, [task])
+        .slice(0, CODE_DETAIL_ARTIFACT_LIMIT);
+    const taskListProjection = buildCodeTaskListProjection(core);
+    const taskItemById = new Map(taskListProjection.tasks.map((item) => [item.id, item]));
+    const linkedArtifacts = codeArtifacts.map((artifact) => buildCodeArtifactListItem(core, artifact, taskItemById));
+    const artifactSummary = buildCodeArtifactListSummary(listCodeArtifacts(core, [task]), linkedArtifacts);
+    const timeline = queryCoreTaskTimelineView(core, task, { limit: CODE_TIMELINE_PREVIEW_LIMIT });
+    const inspection = buildCoreTaskInspectionView(core, task);
+    return {
+        product: createCodeProductRef(),
+        task,
+        conversation,
+        workItem: buildWorkItemReference(core, workItem),
+        effectiveStrategy: resolveEffectiveTaskStrategy('code', readTaskPlanningMetadataFromTask(task)),
+        workspace: readCodeWorkspaceSummaryFromTask(task),
+        plan: readCodePlanFromTask(task),
+        inspection,
+        supervision: inspection.latestRun
+            ? buildSupervisedRunInspectionProjection(core, inspection.latestRun.id, evidenceEvents)
+            : null,
+        controlPlane: buildCoreTaskControlPlaneView(core, task),
+        recovery: buildCoreTaskRecoveryView(core, task),
+        timeline: {
+            summary: timeline.summary,
+            view: timeline.timeline,
+        },
+        linkedArtifacts,
+        artifactSummary: {
+            totalCount: artifactSummary.totalAvailable,
+            buildCount: artifactSummary.buildCount,
+            previewCount: artifactSummary.previewCount,
+            readyCount: artifactSummary.readyCount,
+        },
+    };
+}
+export function buildCodeArtifactDetailProjection(core, artifact) {
+    const task = artifact.taskId
+        ? core.tasks.find((candidate) => candidate.id === artifact.taskId) ?? null
+        : null;
+    const workItem = artifact.workItemId
+        ? core.workItems.find((candidate) => candidate.id === artifact.workItemId) ?? null
+        : (task ? resolveTaskWorkItemRecord(core, task.id) : null);
+    const project = artifact.projectId
+        ? core.projects.find((candidate) => candidate.id === artifact.projectId) ?? null
+        : (workItem?.projectId
+            ? core.projects.find((candidate) => candidate.id === workItem.projectId) ?? null
+            : null);
+    const conversation = resolveConversation(core, artifact.conversationId ?? task?.conversationId ?? workItem?.conversationId ?? null);
+    const taskProjection = task ? buildCodeTaskListItem(core, task) : null;
+    const codeTasks = listCodeTasks(core);
+    const taskItems = codeTasks.map((candidate) => buildCodeTaskListItem(core, candidate));
+    const taskItemById = new Map(taskItems.map((item) => [item.id, item]));
+    const relatedArtifacts = listCodeArtifacts(core, codeTasks, 'all', {
+        includeWorkspaceAnchored: true,
+    })
+        .filter((candidate) => candidate.id !== artifact.id
+        && ((artifact.taskId && candidate.taskId === artifact.taskId)
+            || (artifact.workItemId && candidate.workItemId === artifact.workItemId)))
+        .slice(0, CODE_DETAIL_ARTIFACT_LIMIT)
+        .map((candidate) => buildCodeArtifactListItem(core, candidate, taskItemById));
+    return {
+        product: createCodeProductRef(),
+        artifact,
+        task: taskProjection,
+        workItem: buildWorkItemReference(core, workItem),
+        project,
+        conversation: buildArtifactConversationSummary(conversation),
+        relatedArtifacts,
+        focus: {
+            kind: artifact.kind === 'build'
+                ? 'build'
+                : artifact.kind === 'preview'
+                    ? 'preview'
+                    : 'artifact',
+            isReady: artifact.status === 'ready',
+            isPublished: artifact.status === 'published',
+        },
+    };
+}
+function buildArtifactConversationSummary(conversation) {
+    if (!conversation) {
+        return null;
+    }
+    return {
+        id: conversation.id,
+        title: conversation.title,
+        kind: conversation.kind,
+        sourceChannelId: conversation.sourceChannelId,
+    };
+}
+export function buildCodeDashboardProjection(core) {
+    const taskList = buildCodeTaskListProjection(core);
+    const workItemList = buildCodeWorkItemListProjection(core);
+    const artifactList = buildCodeArtifactListProjection(core);
+    return {
+        product: createActiveCodeProductRef(),
+        summary: {
+            ownerActorId: core.ownerProfile.actorId,
+            actorCount: core.actors.length,
+            conversationCount: core.conversations.length,
+            workItemCount: workItemList.summary.totalAvailable,
+            taskCount: taskList.summary.totalAvailable,
+            artifactCount: artifactList.summary.totalAvailable,
+            buildCount: artifactList.summary.buildCount,
+            previewCount: artifactList.summary.previewCount,
+            inProgressTaskCount: taskList.summary.inProgressCount,
+            readyArtifactCount: artifactList.summary.readyCount,
+        },
+        sections: {
+            workItems: {
+                title: 'Code Work Items',
+                emptyState: 'No code-targeted Work Items have been created yet.',
+                items: workItemList.workItems,
+                summary: workItemList.summary,
+            },
+            tasks: {
+                title: 'Code Tasks',
+                emptyState: 'No code-oriented tasks have been routed into Cats Core yet.',
+                items: taskList.tasks,
+                summary: taskList.summary,
+            },
+            artifacts: {
+                title: 'Builds and Previews',
+                emptyState: 'No build, preview, or code-linked artifacts have been recorded yet.',
+                items: artifactList.artifacts,
+                summary: artifactList.summary,
+            },
+        },
+        selection: {
+            defaultWorkItemId: workItemList.workItems[0]?.id ?? null,
+            defaultTaskId: taskList.tasks[0]?.id ?? null,
+            defaultArtifactId: selectDefaultCodeArtifactId(artifactList.artifacts),
+        },
+        extensionPoints: {
+            projectionSource: 'cats-core',
+            futureRoutes: [
+                CODE_API_TASKS_PATH,
+                CODE_API_TASK_DETAIL_PATH_TEMPLATE,
+                CODE_API_CODESPACES_PATH,
+                CODE_API_CODESPACE_DETAIL_PATH_TEMPLATE,
+                CODE_API_ARTIFACTS_PATH,
+                CODE_API_ARTIFACT_DETAIL_PATH_TEMPLATE,
+                CODE_API_BUILDS_PATH,
+                CODE_API_PREVIEWS_PATH,
+            ],
+        },
+    };
+}
+//# sourceMappingURL=projection.js.map