@a5c-ai/agent-comm-mux 5.0.1-staging.04ca6ab00d21

package/dist/kanban.js

@@ -0,0 +1,1155 @@
+const DEFAULT_PROJECT_STATUSES = [
+    { id: 'backlog', name: 'Backlog', kind: 'backlog' },
+    { id: 'ready', name: 'Ready', kind: 'backlog' },
+    { id: 'in-progress', name: 'In Progress', kind: 'active', wipLimit: 3 },
+    { id: 'review', name: 'Review', kind: 'active', wipLimit: 3 },
+    { id: 'done', name: 'Done', kind: 'done' },
+];
+const DEFAULT_TEAM_SETTINGS = {
+    visibility: 'team',
+    defaultRole: 'contributor',
+    allowSelfAssign: true,
+};
+const DEFAULT_PROJECT_SETTINGS = {
+    reviewRequiredForDone: true,
+    activityScope: 'project-and-issues',
+    workspaceProvisioning: 'owners-maintainers',
+};
+const DEFAULT_PERMISSION_GRANTS = [
+    {
+        action: 'manage-project-settings',
+        roles: ['owner', 'maintainer'],
+        description: 'Only owners and maintainers can change shared project settings.',
+    },
+    {
+        action: 'manage-team-members',
+        roles: ['owner', 'maintainer'],
+        description: 'Team roster and role changes require elevated project roles.',
+    },
+    {
+        action: 'edit-board',
+        roles: ['owner', 'maintainer', 'contributor'],
+        description: 'Contributors can move cards and edit the shared board.',
+    },
+    {
+        action: 'assign-issues',
+        roles: ['owner', 'maintainer', 'contributor'],
+        description: 'Contributors can collaborate and self-assign when team settings allow it.',
+    },
+    {
+        action: 'review-work',
+        roles: ['owner', 'maintainer', 'contributor', 'viewer'],
+        description: 'Every collaborator can participate in review and activity visibility.',
+    },
+    {
+        action: 'manage-workspaces',
+        roles: ['owner', 'maintainer'],
+        description: 'Workspace lifecycle actions remain restricted to trusted roles.',
+    },
+];
+const WORKFLOW_STATE_ORDER = [
+    'todo',
+    'in-progress',
+    'review',
+    'done',
+];
+const DEFAULT_SWIMLANES = [
+    { id: 'expedite', name: 'Expedite' },
+    { id: 'standard', name: 'Standard' },
+    { id: 'blocked', name: 'Blocked' },
+];
+const DEFAULT_BOARD_POLICY_HOOKS = [
+    {
+        id: 'dispatch-ready',
+        name: 'Dispatch readiness gate',
+        description: 'Only ready issues can move from todo into active work.',
+        scope: 'card',
+        blocking: true,
+        columnIds: ['in-progress'],
+    },
+    {
+        id: 'wip-limit',
+        name: 'WIP limit',
+        description: 'Active workflow columns enforce configured work-in-progress limits.',
+        scope: 'column',
+        blocking: true,
+        columnIds: ['in-progress', 'review'],
+    },
+    {
+        id: 'blocked-flow',
+        name: 'Blocked flow gate',
+        description: 'Blocked issues cannot advance into review or done.',
+        scope: 'card',
+        blocking: true,
+        columnIds: ['review', 'done'],
+    },
+    {
+        id: 'acceptance-complete',
+        name: 'Acceptance completion gate',
+        description: 'Issues can only move to done after every acceptance criterion is satisfied.',
+        scope: 'card',
+        blocking: true,
+        columnIds: ['done'],
+    },
+    {
+        id: 'repo-ci',
+        name: 'CI gate visibility',
+        description: 'Repository-scoped CI results should be visible on each work item.',
+        scope: 'card',
+        blocking: false,
+    },
+    {
+        id: 'merge-status',
+        name: 'Merge readiness',
+        description: 'PR review and merge readiness should be visible from the board.',
+        scope: 'card',
+        blocking: false,
+    },
+    {
+        id: 'publish-status',
+        name: 'Publish lifecycle',
+        description: 'Merged work should expose publish readiness and release state.',
+        scope: 'card',
+        blocking: false,
+    },
+];
+function uniqueById(items) {
+    const seen = new Set();
+    const normalized = [];
+    for (const item of items) {
+        if (seen.has(item.id))
+            continue;
+        seen.add(item.id);
+        normalized.push(item);
+    }
+    return normalized;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+export function normalizeKanbanTaskTagKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .replace(/_+/g, '_');
+}
+export function normalizeKanbanDispatchContextLabelKey(value) {
+    return normalizeKanbanTaskTagKey(value);
+}
+function compareKanbanDispatchContextLabels(left, right) {
+    return (left.order - right.order ||
+        left.label.localeCompare(right.label) ||
+        left.key.localeCompare(right.key) ||
+        left.id.localeCompare(right.id));
+}
+export function normalizeKanbanDispatchContextLabel(label) {
+    const normalizedLabel = label.label.trim();
+    const normalizedKey = normalizeKanbanDispatchContextLabelKey(label.key ?? normalizedLabel);
+    return {
+        ...label,
+        label: normalizedLabel,
+        key: normalizedKey || normalizeKanbanDispatchContextLabelKey(label.id),
+        instruction: label.instruction.replace(/\r\n?/g, '\n').trim(),
+        description: label.description?.trim() || undefined,
+        order: typeof label.order === 'number' && Number.isFinite(label.order)
+            ? Math.max(0, Math.floor(label.order))
+            : 0,
+    };
+}
+export function normalizeKanbanDispatchContextLabels(labels) {
+    return labels
+        .map((label) => normalizeKanbanDispatchContextLabel(label))
+        .sort(compareKanbanDispatchContextLabels);
+}
+export function normalizeKanbanDispatchContextLabelRefs(refs) {
+    return Array.from(new Set(refs
+        .map((ref) => ref.labelId?.trim() || '')
+        .filter(Boolean))).map((labelId) => ({ labelId }));
+}
+export function projectDispatchContextLabels(definitions, refs) {
+    const definitionMap = new Map(definitions.map((definition) => [definition.id, definition]));
+    return normalizeKanbanDispatchContextLabelRefs(refs)
+        .map((ref) => definitionMap.get(ref.labelId))
+        .filter((definition) => Boolean(definition))
+        .sort(compareKanbanDispatchContextLabels)
+        .map((definition) => ({
+        labelId: definition.id,
+        key: definition.key,
+        label: definition.label,
+        instruction: definition.instruction,
+    }));
+}
+export function renderDispatchContextLabels(definitions, refs) {
+    return projectDispatchContextLabels(definitions, refs)
+        .map((projection) => `- [${projection.key}] ${projection.instruction}`)
+        .join('\n');
+}
+export function renderKanbanExecutionContextBlock(input) {
+    const labelIds = Array.from(new Set(input.labelIds ?? []));
+    const labels = input.labels ?? [];
+    const projectSummary = input.projectKey?.trim()
+        ? input.projectName?.trim()
+            ? `${input.projectKey} (${input.projectName})`
+            : input.projectKey
+        : input.projectName?.trim() || input.projectId;
+    const labelSummary = labels.length > 0
+        ? labels.map((label) => `- ${label.key} (${label.labelId}): ${label.label}`).join('\n')
+        : labelIds.length > 0
+            ? labelIds.map((labelId) => `- ${labelId}`).join('\n')
+            : '- none';
+    const renderedContext = input.renderedContext?.trim() || '- none';
+    const runSummary = (input.runIds ?? []).length > 0 ? (input.runIds ?? []).join(', ') : 'none';
+    const sessionSummary = (input.sessionIds ?? []).length > 0 ? (input.sessionIds ?? []).join(', ') : 'none';
+    return [
+        'Execution Context',
+        `Project: ${projectSummary}`,
+        `Issue: ${input.issueKey} (${input.issueId})`,
+        `Title: ${input.issueTitle}`,
+        `Applied Dispatch Context Labels (${labelIds.length}):`,
+        labelSummary,
+        `Run IDs: ${runSummary}`,
+        `Session IDs: ${sessionSummary}`,
+        `Last Dispatched At: ${input.lastDispatchedAt ?? 'none'}`,
+        'Rendered Dispatch Context:',
+        renderedContext,
+    ].join('\n');
+}
+export function buildKanbanExecutionContextEnvelope(input) {
+    const labelIds = normalizeKanbanDispatchContextLabelRefs(input.issue.dispatch.contextLabels).map((ref) => ref.labelId);
+    const labels = input.issue.dispatch.contextLabelProjections ?? [];
+    const renderedContext = input.issue.dispatch.renderedContext?.trim() || undefined;
+    if (labelIds.length === 0 && labels.length === 0 && !renderedContext) {
+        return undefined;
+    }
+    return {
+        kind: 'dispatch-context-labels',
+        project: {
+            id: input.project?.id ?? input.issue.projectId,
+            key: input.project?.key,
+            name: input.project?.name,
+        },
+        issue: {
+            id: input.issue.id,
+            key: input.issue.key,
+            title: input.issue.title,
+        },
+        dispatch: {
+            runIds: Array.from(new Set(input.issue.dispatch.runIds ?? [])),
+            sessionIds: Array.from(new Set(input.issue.dispatch.sessionIds ?? [])),
+            labelIds,
+            labels,
+            renderedContext,
+            lastDispatchedAt: input.issue.dispatch.lastDispatchedAt,
+        },
+        block: renderKanbanExecutionContextBlock({
+            projectId: input.project?.id ?? input.issue.projectId,
+            projectKey: input.project?.key,
+            projectName: input.project?.name,
+            issueId: input.issue.id,
+            issueKey: input.issue.key,
+            issueTitle: input.issue.title,
+            runIds: input.issue.dispatch.runIds,
+            sessionIds: input.issue.dispatch.sessionIds,
+            labelIds,
+            labels,
+            renderedContext,
+            lastDispatchedAt: input.issue.dispatch.lastDispatchedAt,
+        }),
+    };
+}
+export function buildDispatchContextExecutionEnvelope(definitions, refs) {
+    const appliedLabels = projectDispatchContextLabels(definitions, refs);
+    if (appliedLabels.length === 0) {
+        return undefined;
+    }
+    return {
+        source: 'dispatch-context-labels',
+        appliedLabels,
+        renderedBlock: renderDispatchContextLabels(definitions, refs),
+        metadata: {
+            labelIds: appliedLabels.map((projection) => projection.labelId),
+            labelKeys: appliedLabels.map((projection) => projection.key),
+            labelCount: appliedLabels.length,
+        },
+    };
+}
+function findKanbanExecutionContextEnvelopes(snapshot, matcher) {
+    const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
+    return snapshot.issues
+        .filter(matcher)
+        .map((issue) => buildKanbanExecutionContextEnvelope({ issue, project: projectsById.get(issue.projectId) }))
+        .filter((envelope) => Boolean(envelope))
+        .sort((left, right) => left.issue.key.localeCompare(right.issue.key) || left.issue.id.localeCompare(right.issue.id));
+}
+export function findKanbanExecutionContextEnvelopesForRun(snapshot, runId) {
+    const normalizedRunId = runId.trim();
+    if (!normalizedRunId) {
+        return [];
+    }
+    return findKanbanExecutionContextEnvelopes(snapshot, (issue) => issue.dispatch.runIds.includes(normalizedRunId));
+}
+export function findKanbanExecutionContextEnvelopesForSession(snapshot, sessionId) {
+    const normalizedSessionId = sessionId.trim();
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return findKanbanExecutionContextEnvelopes(snapshot, (issue) => issue.dispatch.sessionIds.includes(normalizedSessionId));
+}
+function normalizeKanbanTaskTagScope(scope) {
+    if (!scope)
+        return undefined;
+    const kind = scope.kind === 'project' || scope.kind === 'workspace' ? scope.kind : 'global';
+    const refId = scope.refId?.trim() || undefined;
+    return refId ? { kind, refId } : { kind };
+}
+function normalizeKanbanTaskTagContent(content) {
+    return content.replace(/\r\n?/g, '\n').trim();
+}
+function compareKanbanTaskTags(left, right) {
+    return (left.order - right.order ||
+        left.label.localeCompare(right.label) ||
+        left.key.localeCompare(right.key) ||
+        left.id.localeCompare(right.id));
+}
+export function normalizeKanbanTaskTag(taskTag) {
+    const label = taskTag.label.trim();
+    const normalizedKey = normalizeKanbanTaskTagKey(taskTag.key ?? label);
+    return {
+        ...taskTag,
+        label,
+        key: normalizedKey || normalizeKanbanTaskTagKey(taskTag.id),
+        content: normalizeKanbanTaskTagContent(taskTag.content),
+        description: taskTag.description?.trim() || undefined,
+        order: typeof taskTag.order === 'number' && Number.isFinite(taskTag.order) ? Math.max(0, Math.floor(taskTag.order)) : 0,
+        scope: normalizeKanbanTaskTagScope(taskTag.scope),
+    };
+}
+export function normalizeKanbanTaskTags(taskTags) {
+    return taskTags.map((taskTag) => normalizeKanbanTaskTag(taskTag)).sort(compareKanbanTaskTags);
+}
+function normalizeCollaboratorRole(role) {
+    switch (role) {
+        case 'owner':
+        case 'maintainer':
+        case 'contributor':
+        case 'viewer':
+            return role;
+        default:
+            return 'contributor';
+    }
+}
+function normalizeCollaborator(collaborator) {
+    return {
+        ...collaborator,
+        displayName: collaborator.displayName.trim(),
+        email: collaborator.email?.trim() || undefined,
+        avatarUrl: collaborator.avatarUrl?.trim() || undefined,
+        role: normalizeCollaboratorRole(collaborator.role),
+    };
+}
+function normalizeTeamSettings(settings) {
+    return {
+        visibility: settings?.visibility === 'private' || settings?.visibility === 'workspace-shared'
+            ? settings.visibility
+            : DEFAULT_TEAM_SETTINGS.visibility,
+        defaultRole: normalizeCollaboratorRole(settings?.defaultRole ?? DEFAULT_TEAM_SETTINGS.defaultRole),
+        allowSelfAssign: settings?.allowSelfAssign ?? DEFAULT_TEAM_SETTINGS.allowSelfAssign,
+    };
+}
+function normalizeProjectSettings(settings) {
+    return {
+        reviewRequiredForDone: settings?.reviewRequiredForDone ?? DEFAULT_PROJECT_SETTINGS.reviewRequiredForDone,
+        activityScope: settings?.activityScope === 'all-board-entities'
+            ? 'all-board-entities'
+            : DEFAULT_PROJECT_SETTINGS.activityScope,
+        workspaceProvisioning: settings?.workspaceProvisioning === 'contributors-and-up'
+            ? 'contributors-and-up'
+            : DEFAULT_PROJECT_SETTINGS.workspaceProvisioning,
+    };
+}
+function normalizePermissionGrants(permissions) {
+    const seen = new Set();
+    const normalized = [];
+    for (const permission of permissions?.length ? permissions : DEFAULT_PERMISSION_GRANTS) {
+        if (seen.has(permission.action)) {
+            continue;
+        }
+        seen.add(permission.action);
+        normalized.push({
+            action: permission.action,
+            roles: uniqueStrings(permission.roles.map((role) => normalizeCollaboratorRole(role))),
+            description: permission.description?.trim() || undefined,
+        });
+    }
+    return normalized;
+}
+function normalizeActivityEntry(entry) {
+    return {
+        ...entry,
+        action: entry.action.trim(),
+        summary: entry.summary.trim(),
+        actor: {
+            ...entry.actor,
+            displayName: entry.actor.displayName.trim(),
+            role: entry.actor.role ? normalizeCollaboratorRole(entry.actor.role) : undefined,
+        },
+    };
+}
+function normalizeTeam(team, project) {
+    return {
+        id: team?.id?.trim() || `team-${project.id}`,
+        name: team?.name?.trim() || `${project.name} Team`,
+        members: uniqueById((team?.members ?? []).map(normalizeCollaborator)),
+        settings: normalizeTeamSettings(team?.settings),
+    };
+}
+function normalizeRepositorySettings(settings, defaultBranch) {
+    return {
+        baseBranch: settings?.baseBranch?.trim() || defaultBranch,
+        autoMerge: settings?.autoMerge ?? false,
+        requiredApprovals: typeof settings?.requiredApprovals === 'number' && settings.requiredApprovals >= 0
+            ? Math.floor(settings.requiredApprovals)
+            : 1,
+        ciProvider: settings?.ciProvider?.trim() || undefined,
+        publishTarget: settings?.publishTarget?.trim() || undefined,
+    };
+}
+function normalizeRepositoryContext(repository) {
+    const owner = repository.owner.trim();
+    const name = repository.name.trim();
+    const fullName = repository.fullName?.trim() || `${owner}/${name}`;
+    const defaultBranch = repository.defaultBranch?.trim() || 'main';
+    return {
+        ...repository,
+        owner,
+        name,
+        fullName,
+        defaultBranch,
+        url: repository.url?.trim() || undefined,
+        settings: normalizeRepositorySettings(repository.settings, defaultBranch),
+    };
+}
+function normalizeIntegrationPrerequisites(prerequisites) {
+    const seen = new Set();
+    const normalized = [];
+    for (const prerequisite of prerequisites ?? []) {
+        const key = prerequisite.key.trim();
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        normalized.push({
+            ...prerequisite,
+            key,
+            label: prerequisite.label.trim(),
+            guidance: prerequisite.guidance?.trim() || undefined,
+        });
+    }
+    return normalized;
+}
+function normalizeIntegrationActionState(actions, status) {
+    const blockedByStatus = status === 'disconnected' ||
+        status === 'expired-auth' ||
+        status === 'missing-scopes' ||
+        status === 'failing';
+    const canCreatePullRequest = actions?.canCreatePullRequest ?? !blockedByStatus;
+    const canManagePullRequest = actions?.canManagePullRequest ?? !blockedByStatus;
+    const canApproveFromReview = actions?.canApproveFromReview ?? !blockedByStatus;
+    return {
+        canCreatePullRequest,
+        canManagePullRequest,
+        canApproveFromReview,
+        reason: actions?.reason?.trim() || undefined,
+    };
+}
+function normalizeIntegrationConnection(connection) {
+    return {
+        ...connection,
+        label: connection.label.trim(),
+        accountLabel: connection.accountLabel?.trim() || undefined,
+        connectedAt: connection.connectedAt,
+        failureMessage: connection.failureMessage?.trim() || undefined,
+        missingScopes: uniqueStrings((connection.missingScopes ?? []).map((scope) => scope.trim()).filter(Boolean)),
+        prerequisites: normalizeIntegrationPrerequisites(connection.prerequisites),
+        guidance: connection.guidance.trim(),
+        actions: normalizeIntegrationActionState(connection.actions, connection.status),
+    };
+}
+function normalizeRepositoryIntegrationState(integration, provider, pullRequest) {
+    if (!integration || (integration.provider !== 'github' && integration.provider !== 'azure-repos')) {
+        return undefined;
+    }
+    const normalizedLinkState = integration.linkState ??
+        (pullRequest ? pullRequest.linkState ?? 'linked' : 'unlinked');
+    return {
+        ...integration,
+        provider: integration.provider,
+        status: integration.status,
+        linkState: normalizedLinkState,
+        failureMessage: integration.failureMessage?.trim() || undefined,
+        guidance: integration.guidance.trim(),
+        missingScopes: uniqueStrings((integration.missingScopes ?? []).map((scope) => scope.trim()).filter(Boolean)),
+        prerequisites: normalizeIntegrationPrerequisites(integration.prerequisites),
+        actions: normalizeIntegrationActionState(integration.actions, integration.status),
+    };
+}
+function resolveReviewStatus(pullRequest) {
+    if (!pullRequest) {
+        return 'unlinked';
+    }
+    if (pullRequest.reviewLinks.some((review) => review.status === 'changes-requested')) {
+        return 'changes-requested';
+    }
+    if (pullRequest.reviewLinks.length > 0 && pullRequest.reviewLinks.every((review) => review.status === 'approved')) {
+        return 'approved';
+    }
+    if (pullRequest.reviewLinks.length > 0 || pullRequest.status === 'in-review') {
+        return 'pending';
+    }
+    if (pullRequest.status === 'approved') {
+        return 'approved';
+    }
+    if (pullRequest.status === 'changes-requested') {
+        return 'changes-requested';
+    }
+    return 'pending';
+}
+function resolveMergeStatus(lifecycle) {
+    if (!lifecycle.pullRequest) {
+        return 'not-ready';
+    }
+    if (lifecycle.pullRequest.status === 'merged') {
+        return 'merged';
+    }
+    const blockingGate = lifecycle.ciGates.some((gate) => gate.required && gate.status !== 'passing' && gate.status !== 'skipped');
+    if (blockingGate) {
+        return 'blocked';
+    }
+    return lifecycle.reviewStatus === 'approved' ? 'ready' : 'blocked';
+}
+function resolvePublishStatus(lifecycle) {
+    if (lifecycle.publishStatus === 'published' || lifecycle.lastPublishedAt) {
+        return 'published';
+    }
+    if (lifecycle.publishStatus === 'failed') {
+        return 'failed';
+    }
+    if (lifecycle.publishStatus === 'pending') {
+        return 'pending';
+    }
+    if (lifecycle.mergeStatus === 'merged') {
+        return 'ready';
+    }
+    return 'not-ready';
+}
+function normalizeIssueRepositoryLifecycle(lifecycle, repositoryMap) {
+    if (!lifecycle) {
+        return undefined;
+    }
+    const repository = repositoryMap.get(lifecycle.repositoryId);
+    const branchName = lifecycle.branchName?.trim() || repository?.defaultBranch || 'main';
+    const ciGates = uniqueById(lifecycle.ciGates.map((gate) => ({
+        ...gate,
+        name: gate.name.trim(),
+        provider: gate.provider?.trim() || repository?.settings.ciProvider,
+        summary: gate.summary?.trim() || undefined,
+        url: gate.url?.trim() || undefined,
+    })));
+    const pullRequest = lifecycle.pullRequest
+        ? {
+            ...lifecycle.pullRequest,
+            title: lifecycle.pullRequest.title.trim(),
+            branchName: lifecycle.pullRequest.branchName?.trim() || branchName,
+            baseBranch: lifecycle.pullRequest.baseBranch?.trim() ||
+                repository?.settings.baseBranch ||
+                repository?.defaultBranch ||
+                'main',
+            reviewLinks: uniqueById(lifecycle.pullRequest.reviewLinks.map((reviewLink) => ({
+                ...reviewLink,
+                label: reviewLink.label.trim(),
+                reviewer: reviewLink.reviewer?.trim() || undefined,
+                url: reviewLink.url?.trim() || undefined,
+            }))),
+            url: lifecycle.pullRequest.url?.trim() || undefined,
+            linkState: lifecycle.pullRequest.linkState ?? 'linked',
+        }
+        : undefined;
+    const reviewStatus = resolveReviewStatus(pullRequest);
+    const mergeStatus = resolveMergeStatus({
+        ciGates,
+        pullRequest,
+        reviewStatus,
+    });
+    const publishStatus = resolvePublishStatus({
+        mergeStatus,
+        publishStatus: lifecycle.publishStatus,
+        lastPublishedAt: lifecycle.lastPublishedAt,
+    });
+    return {
+        ...lifecycle,
+        branchName,
+        ciGates,
+        integration: normalizeRepositoryIntegrationState(lifecycle.integration, repository?.provider, pullRequest),
+        pullRequest: pullRequest
+            ? {
+                ...pullRequest,
+                mergeStatus,
+                status: mergeStatus === 'merged'
+                    ? 'merged'
+                    : reviewStatus === 'approved'
+                        ? 'approved'
+                        : reviewStatus === 'changes-requested'
+                            ? 'changes-requested'
+                            : pullRequest.status,
+            }
+            : undefined,
+        reviewStatus,
+        mergeStatus,
+        publishStatus,
+        publishUrl: lifecycle.publishUrl?.trim() || undefined,
+        lastPublishedAt: lifecycle.lastPublishedAt,
+    };
+}
+function getColumnName(state) {
+    switch (state) {
+        case 'todo':
+            return 'Todo';
+        case 'in-progress':
+            return 'In Progress';
+        case 'review':
+            return 'Review';
+        case 'done':
+            return 'Done';
+    }
+}
+function getColumnWipLimit(project, state) {
+    if (state === 'todo' || state === 'done') {
+        return undefined;
+    }
+    return project.statuses.find((status) => status.id === state)?.wipLimit;
+}
+function getAllowedMoveStates(currentState) {
+    switch (currentState) {
+        case 'todo':
+            return ['in-progress'];
+        case 'in-progress':
+            return ['todo', 'review'];
+        case 'review':
+            return ['in-progress', 'done'];
+        case 'done':
+            return ['review'];
+    }
+}
+function acceptanceProgress(issue) {
+    return {
+        satisfied: issue.acceptanceCriteria.filter((criterion) => criterion.satisfied).length,
+        total: issue.acceptanceCriteria.length,
+    };
+}
+function isBlockedIssue(issue) {
+    return issue.status === 'blocked' || issue.dispatch.readiness === 'blocked';
+}
+function createPolicySignal(hookId, message, blocking = true) {
+    return {
+        hookId,
+        message,
+        blocking,
+        severity: blocking ? 'error' : 'warning',
+    };
+}
+export function summarizeKanbanReviewArtifact(artifact) {
+    return {
+        decision: artifact.decision,
+        queueState: artifact.queueState,
+        commentCount: artifact.comments.length,
+        openCommentCount: artifact.comments.filter((comment) => comment.status === 'open').length,
+        latestActivityAt: artifact.updatedAt,
+    };
+}
+function resolveReadiness(issue, issuesById) {
+    if (issue.status === 'done')
+        return 'completed';
+    if ((issue.dispatch?.runIds?.length ?? 0) > 0 || (issue.dispatch?.sessionIds?.length ?? 0) > 0) {
+        return 'dispatched';
+    }
+    if (issue.status === 'blocked')
+        return 'blocked';
+    const unresolvedDependencies = issue.dependencies.some((dependency) => {
+        if (dependency.type !== 'blocked-by')
+            return false;
+        return issuesById.get(dependency.issueId)?.status !== 'done';
+    });
+    if (unresolvedDependencies)
+        return 'blocked';
+    const unresolvedChildren = issue.childIssueIds.some((childIssueId) => {
+        return issuesById.get(childIssueId)?.status !== 'done';
+    });
+    if (unresolvedChildren)
+        return 'needs-decomposition';
+    const incompleteDecomposition = issue.decomposition.some((item) => item.status !== 'done' && !item.issueId);
+    if (incompleteDecomposition)
+        return 'needs-decomposition';
+    return 'ready';
+}
+function resolveBlockedReasons(issue, issuesById) {
+    const reasons = new Set(issue.dispatch?.blockedReasons ?? []);
+    for (const dependency of issue.dependencies) {
+        if (dependency.type !== 'blocked-by')
+            continue;
+        const dependencyIssue = issuesById.get(dependency.issueId);
+        if (!dependencyIssue || dependencyIssue.status !== 'done') {
+            reasons.add(`waiting on ${dependency.issueId}`);
+        }
+    }
+    if (issue.childIssueIds.some((childIssueId) => issuesById.get(childIssueId)?.status !== 'done')) {
+        reasons.add('child issues still open');
+    }
+    if (issue.decomposition.some((item) => item.status !== 'done' && !item.issueId)) {
+        reasons.add('decomposition incomplete');
+    }
+    return Array.from(reasons);
+}
+export function normalizeKanbanIssue(issue, issuesById, repositoryMap = new Map(), dispatchContextLabels = []) {
+    const labels = uniqueById(issue.labels);
+    const assignees = uniqueById(issue.assignees);
+    const collaborators = uniqueById((issue.collaborators ?? []).map(normalizeCollaborator));
+    const acceptanceCriteria = uniqueById(issue.acceptanceCriteria);
+    const decomposition = uniqueById(issue.decomposition);
+    const childIssueIds = Array.from(new Set(issue.childIssueIds));
+    const readiness = resolveReadiness({ ...issue, childIssueIds, decomposition }, issuesById);
+    const blockedReasons = resolveBlockedReasons({ ...issue, childIssueIds, decomposition }, issuesById);
+    const contextLabels = normalizeKanbanDispatchContextLabelRefs(issue.dispatch?.contextLabels ?? []);
+    const contextLabelProjections = projectDispatchContextLabels(dispatchContextLabels, contextLabels);
+    const executionContext = buildDispatchContextExecutionEnvelope(dispatchContextLabels, contextLabels);
+    const renderedContext = executionContext?.renderedBlock;
+    const workspaceLinks = Array.from(new Map((issue.workspaceLinks ?? [])
+        .filter((link) => typeof link.workspacePath === 'string' && link.workspacePath.trim().length > 0)
+        .map((link) => [
+        link.workspacePath.trim(),
+        {
+            workspacePath: link.workspacePath.trim(),
+            workspaceName: link.workspaceName.trim() || link.workspacePath.trim(),
+            branchName: link.branchName?.trim() || undefined,
+            linkedAt: link.linkedAt,
+            source: link.source,
+        },
+    ])).values());
+    return {
+        ...issue,
+        labels,
+        assignees,
+        collaborators,
+        acceptanceCriteria,
+        decomposition,
+        childIssueIds,
+        activity: uniqueById((issue.activity ?? []).map(normalizeActivityEntry)),
+        dispatch: {
+            readiness,
+            blockedReasons,
+            runIds: Array.from(new Set(issue.dispatch?.runIds ?? [])),
+            sessionIds: Array.from(new Set(issue.dispatch?.sessionIds ?? [])),
+            contextLabels,
+            contextLabelProjections,
+            executionContext,
+            renderedContext,
+            lastDispatchedAt: issue.dispatch?.lastDispatchedAt,
+        },
+        repositoryLifecycle: normalizeIssueRepositoryLifecycle(issue.repositoryLifecycle, repositoryMap),
+        workspaceLinks,
+    };
+}
+export function resolveKanbanWorkflowState(issue) {
+    switch (issue.status) {
+        case 'in-progress':
+        case 'blocked':
+            return 'in-progress';
+        case 'review':
+            return 'review';
+        case 'done':
+            return 'done';
+        case 'backlog':
+        case 'ready':
+        default:
+            return 'todo';
+    }
+}
+export function resolveKanbanSwimlane(issue) {
+    if (issue.status === 'blocked' || issue.dispatch.readiness === 'blocked') {
+        return 'blocked';
+    }
+    if (issue.priority === 'critical' || issue.priority === 'high') {
+        return 'expedite';
+    }
+    return 'standard';
+}
+export function resolveKanbanStatusForWorkflowState(issue, state) {
+    switch (state) {
+        case 'todo':
+            return issue.status === 'backlog' || issue.dispatch.readiness === 'needs-decomposition'
+                ? 'backlog'
+                : 'ready';
+        case 'in-progress':
+            return 'in-progress';
+        case 'review':
+            return 'review';
+        case 'done':
+            return 'done';
+    }
+}
+export function evaluateKanbanIssueMove(input) {
+    const issue = input.issues.find((candidate) => candidate.id === input.issueId);
+    if (!issue) {
+        return {
+            issueId: input.issueId,
+            fromState: 'todo',
+            toState: input.toState,
+            allowed: false,
+            signals: [createPolicySignal('dispatch-ready', `Issue ${input.issueId} does not exist.`)],
+        };
+    }
+    const fromState = resolveKanbanWorkflowState(issue);
+    const allowedStates = getAllowedMoveStates(fromState);
+    const signals = [];
+    if (!allowedStates.includes(input.toState)) {
+        signals.push(createPolicySignal('dispatch-ready', `Cannot move ${issue.key} from ${fromState} to ${input.toState}.`));
+    }
+    if (input.toState === 'in-progress') {
+        if (issue.dispatch.readiness !== 'ready' && issue.dispatch.readiness !== 'dispatched') {
+            signals.push(createPolicySignal('dispatch-ready', `${issue.key} is ${issue.dispatch.readiness} and cannot start active work yet.`));
+        }
+    }
+    if ((input.toState === 'review' || input.toState === 'done') && isBlockedIssue(issue)) {
+        signals.push(createPolicySignal('blocked-flow', `${issue.key} is blocked and cannot advance until the blocking reasons clear.`));
+    }
+    if (input.toState === 'done') {
+        const progress = acceptanceProgress(issue);
+        if (progress.total > 0 && progress.satisfied < progress.total) {
+            signals.push(createPolicySignal('acceptance-complete', `${issue.key} has ${progress.total - progress.satisfied} acceptance checks remaining.`));
+        }
+    }
+    const wipLimit = getColumnWipLimit(input.project, input.toState);
+    if (typeof wipLimit === 'number') {
+        const targetCount = input.issues.filter((candidate) => candidate.projectId === input.project.id &&
+            candidate.id !== issue.id &&
+            resolveKanbanWorkflowState(candidate) === input.toState).length;
+        if (targetCount + 1 > wipLimit) {
+            signals.push(createPolicySignal('wip-limit', `${getColumnName(input.toState)} would exceed its WIP limit of ${wipLimit}.`));
+        }
+    }
+    return {
+        issueId: issue.id,
+        fromState,
+        toState: input.toState,
+        allowed: signals.every((signal) => !signal.blocking),
+        nextStatus: signals.every((signal) => !signal.blocking)
+            ? resolveKanbanStatusForWorkflowState(issue, input.toState)
+            : undefined,
+        signals,
+    };
+}
+export function computeKanbanProjectMetrics(issues) {
+    let readyIssues = 0;
+    let blockedIssues = 0;
+    let dispatchedIssues = 0;
+    let completedIssues = 0;
+    let needsDecompositionIssues = 0;
+    let inProgressIssues = 0;
+    for (const issue of issues) {
+        if (issue.status === 'in-progress' || issue.status === 'review') {
+            inProgressIssues += 1;
+        }
+        switch (issue.dispatch.readiness) {
+            case 'ready':
+                readyIssues += 1;
+                break;
+            case 'blocked':
+                blockedIssues += 1;
+                break;
+            case 'dispatched':
+                dispatchedIssues += 1;
+                break;
+            case 'completed':
+                completedIssues += 1;
+                break;
+            case 'needs-decomposition':
+                needsDecompositionIssues += 1;
+                break;
+        }
+    }
+    return {
+        totalIssues: issues.length,
+        readyIssues,
+        blockedIssues,
+        dispatchedIssues,
+        completedIssues,
+        needsDecompositionIssues,
+        inProgressIssues,
+    };
+}
+export function buildKanbanBacklogSnapshot(input) {
+    const normalizedDispatchContextLabels = normalizeKanbanDispatchContextLabels(input.dispatchContextLabels ?? []);
+    const issueSeedMap = new Map();
+    for (const issue of input.issues) {
+        issueSeedMap.set(issue.id, {
+            ...issue,
+            collaborators: issue.collaborators ?? [],
+            activity: issue.activity ?? [],
+            dispatch: {
+                readiness: 'ready',
+                blockedReasons: [],
+                runIds: [],
+                sessionIds: [],
+                contextLabels: [],
+                contextLabelProjections: [],
+            },
+        });
+    }
+    const projects = input.projects.map((project) => ({
+        ...project,
+        labels: uniqueById(project.labels),
+        assignees: uniqueById(project.assignees),
+        team: normalizeTeam(project.team, project),
+        settings: normalizeProjectSettings(project.settings),
+        permissions: normalizePermissionGrants(project.permissions),
+        activity: uniqueById((project.activity ?? []).map(normalizeActivityEntry)),
+        statuses: project.statuses.length > 0 ? project.statuses : DEFAULT_PROJECT_STATUSES,
+        repositories: uniqueById((project.repositories ?? []).map(normalizeRepositoryContext)),
+        integrations: Array.from(new Map((project.integrations ?? [])
+            .map(normalizeIntegrationConnection)
+            .map((connection) => [connection.provider, connection])).values()),
+    }));
+    const repositoryMapByProject = new Map(projects.map((project) => [project.id, new Map(project.repositories.map((repository) => [repository.id, repository]))]));
+    const normalizedIssues = input.issues.map((issue) => normalizeKanbanIssue(issue, issueSeedMap, repositoryMapByProject.get(issue.projectId), normalizedDispatchContextLabels));
+    const normalizedIssueMap = new Map(normalizedIssues.map((issue) => [issue.id, issue]));
+    const projectsWithMetrics = projects.map((project) => {
+        const statuses = project.statuses.length > 0 ? project.statuses : DEFAULT_PROJECT_STATUSES;
+        const issueIds = Array.from(new Set([
+            ...project.issueIds,
+            ...normalizedIssues
+                .filter((issue) => issue.projectId === project.id)
+                .map((issue) => issue.id),
+        ]));
+        const projectIssues = issueIds
+            .map((issueId) => normalizedIssueMap.get(issueId))
+            .filter((issue) => Boolean(issue));
+        return {
+            ...project,
+            statuses,
+            issueIds,
+            metrics: computeKanbanProjectMetrics(projectIssues),
+        };
+    });
+    return {
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        projects: projectsWithMetrics,
+        issues: normalizedIssues,
+        dispatchContextLabels: normalizedDispatchContextLabels,
+    };
+}
+export function buildKanbanProjectBoard(input) {
+    const projectIssues = input.issues.filter((issue) => issue.projectId === input.project.id);
+    const repositoryMap = new Map(input.project.repositories.map((repository) => [repository.id, repository]));
+    const cards = projectIssues.map((issue) => {
+        const workflowState = resolveKanbanWorkflowState(issue);
+        const swimlaneId = resolveKanbanSwimlane(issue);
+        const signals = [];
+        const progress = acceptanceProgress(issue);
+        const repository = issue.repositoryLifecycle
+            ? repositoryMap.get(issue.repositoryLifecycle.repositoryId)
+            : undefined;
+        if (isBlockedIssue(issue)) {
+            for (const reason of issue.dispatch.blockedReasons) {
+                signals.push(createPolicySignal('blocked-flow', reason, false));
+            }
+        }
+        if (issue.dispatch.readiness === 'needs-decomposition') {
+            signals.push(createPolicySignal('dispatch-ready', `${issue.key} still needs decomposition before it can be dispatched.`, false));
+        }
+        const currentLimit = getColumnWipLimit(input.project, workflowState);
+        if (typeof currentLimit === 'number') {
+            const currentCount = projectIssues.filter((candidate) => resolveKanbanWorkflowState(candidate) === workflowState).length;
+            if (currentCount > currentLimit) {
+                signals.push(createPolicySignal('wip-limit', `${getColumnName(workflowState)} is over its WIP limit (${currentCount}/${currentLimit}).`, false));
+            }
+        }
+        if (issue.repositoryLifecycle?.ciGates.some((gate) => gate.required && gate.status === 'failing')) {
+            signals.push(createPolicySignal('repo-ci', `${issue.key} has failing required CI gates.`, false));
+        }
+        if (issue.repositoryLifecycle?.pullRequest && issue.repositoryLifecycle.mergeStatus === 'ready') {
+            signals.push(createPolicySignal('merge-status', `${issue.key} is approved and ready to merge.`, false));
+        }
+        if (issue.repositoryLifecycle?.publishStatus === 'published') {
+            signals.push(createPolicySignal('publish-status', `${issue.key} has already been published.`, false));
+        }
+        return {
+            issueId: issue.id,
+            issueKey: issue.key,
+            projectId: issue.projectId,
+            title: issue.title,
+            summary: issue.summary,
+            workflowState,
+            swimlaneId,
+            priority: issue.priority,
+            readiness: issue.dispatch.readiness,
+            blocked: isBlockedIssue(issue),
+            blockedReasons: issue.dispatch.blockedReasons,
+            labelNames: uniqueStrings(issue.labels.map((label) => label.name)),
+            assigneeNames: uniqueStrings(issue.assignees.map((assignee) => assignee.displayName)),
+            collaboratorNames: uniqueStrings(issue.collaborators.map((collaborator) => collaborator.displayName)),
+            dependencyCount: issue.dependencies.length,
+            childCount: issue.childIssueIds.length,
+            activityCount: issue.activity.length,
+            latestActivityAt: issue.activity[0]?.createdAt,
+            acceptanceProgress: progress,
+            repository,
+            repositoryLifecycle: issue.repositoryLifecycle,
+            moveTargets: getAllowedMoveStates(workflowState).map((state) => {
+                const evaluation = evaluateKanbanIssueMove({
+                    project: input.project,
+                    issues: projectIssues,
+                    issueId: issue.id,
+                    toState: state,
+                });
+                return {
+                    state,
+                    allowed: evaluation.allowed,
+                    signals: evaluation.signals,
+                };
+            }),
+            policySignals: signals,
+            review: issue.review,
+        };
+    });
+    const columns = WORKFLOW_STATE_ORDER.map((state) => {
+        const issueIds = cards
+            .filter((card) => card.workflowState === state)
+            .map((card) => card.issueId);
+        const wipLimit = getColumnWipLimit(input.project, state);
+        return {
+            id: state,
+            name: getColumnName(state),
+            issueIds,
+            issueCount: issueIds.length,
+            wipLimit,
+            isOverLimit: typeof wipLimit === 'number' ? issueIds.length > wipLimit : false,
+        };
+    });
+    const swimlanes = DEFAULT_SWIMLANES.map((swimlane) => ({
+        ...swimlane,
+        issueIds: cards
+            .filter((card) => card.swimlaneId === swimlane.id)
+            .map((card) => card.issueId),
+    }));
+    return {
+        projectId: input.project.id,
+        projectKey: input.project.key,
+        projectName: input.project.name,
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        columns,
+        swimlanes,
+        cards,
+        policyHooks: DEFAULT_BOARD_POLICY_HOOKS,
+    };
+}
+export function buildKanbanBoardSnapshot(snapshot) {
+    return {
+        generatedAt: snapshot.generatedAt,
+        projects: snapshot.projects.map((project) => buildKanbanProjectBoard({
+            generatedAt: snapshot.generatedAt,
+            project,
+            issues: snapshot.issues,
+        })),
+    };
+}
+export function upsertKanbanProjectRepository(project, repository) {
+    const repositories = uniqueById([
+        ...(project.repositories ?? []).filter((candidate) => candidate.id !== repository.id),
+        normalizeRepositoryContext(repository),
+    ]);
+    return {
+        ...project,
+        repositories,
+    };
+}
+export function updateKanbanProjectRepositorySettings(project, input) {
+    return {
+        ...project,
+        repositories: (project.repositories ?? []).map((repository) => repository.id === input.repositoryId
+            ? {
+                ...repository,
+                settings: normalizeRepositorySettings({
+                    ...repository.settings,
+                    ...input.settings,
+                }, repository.defaultBranch),
+            }
+            : repository),
+    };
+}
+export function linkKanbanIssueRepository(issue, input) {
+    return {
+        ...issue,
+        repositoryLifecycle: {
+            repositoryId: input.repositoryId,
+            branchName: input.branchName.trim(),
+            reviewStatus: issue.repositoryLifecycle?.reviewStatus ?? 'unlinked',
+            mergeStatus: issue.repositoryLifecycle?.mergeStatus ?? 'not-ready',
+            publishStatus: issue.repositoryLifecycle?.publishStatus ?? 'not-ready',
+            ciGates: issue.repositoryLifecycle?.ciGates ?? [],
+            pullRequest: issue.repositoryLifecycle?.pullRequest,
+            integration: input.integration ?? issue.repositoryLifecycle?.integration,
+            publishUrl: issue.repositoryLifecycle?.publishUrl,
+            lastPublishedAt: issue.repositoryLifecycle?.lastPublishedAt,
+        },
+    };
+}
+export function createKanbanIssuePullRequest(issue, input) {
+    if (!issue.repositoryLifecycle) {
+        return issue;
+    }
+    const reviewLinks = (input.reviewLinks ?? []).map((reviewLink, index) => ({
+        ...reviewLink,
+        id: `${issue.repositoryLifecycle.repositoryId}-review-${index + 1}`,
+    }));
+    return {
+        ...issue,
+        repositoryLifecycle: {
+            ...issue.repositoryLifecycle,
+            branchName: input.branchName.trim(),
+            reviewStatus: reviewLinks.length > 0 ? 'pending' : 'unlinked',
+            mergeStatus: 'blocked',
+            ciGates: issue.repositoryLifecycle.ciGates.length > 0
+                ? issue.repositoryLifecycle.ciGates
+                : [
+                    {
+                        id: `${issue.repositoryLifecycle.repositoryId}-ci-build`,
+                        name: 'Build',
+                        required: true,
+                        status: 'pending',
+                    },
+                    {
+                        id: `${issue.repositoryLifecycle.repositoryId}-ci-tests`,
+                        name: 'Tests',
+                        required: true,
+                        status: 'pending',
+                    },
+                ],
+            pullRequest: {
+                id: `${issue.repositoryLifecycle.repositoryId}-pr-${input.number}`,
+                number: input.number,
+                title: input.title.trim(),
+                status: reviewLinks.length > 0 ? 'in-review' : 'open',
+                branchName: input.branchName.trim(),
+                baseBranch: input.baseBranch.trim(),
+                mergeStatus: 'blocked',
+                reviewLinks,
+                url: input.url?.trim() || undefined,
+                linkState: input.linkState ?? 'linked',
+                createdAt: input.now,
+                updatedAt: input.now,
+            },
+        },
+    };
+}
+//# sourceMappingURL=kanban.js.map